tasmota-webserial-esptool 9.2.8 → 9.2.10

package/dist/esp_loader.js

@@ -1,10 +1,17 @@
 /// <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_GPIO_STRAP_REG, ESP32S2_GPIO_STRAP_SPI_BOOT_MASK, 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_GPIO_STRAP_REG, ESP32S3_GPIO_STRAP_SPI_BOOT_MASK, ESP32S3_RTC_CNTL_OPTION1_REG, ESP32S3_RTC_CNTL_FORCE_DOWNLOAD_BOOT_MASK, } 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, 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_GPIO_STRAP_REG, ESP32S2_GPIO_STRAP_SPI_BOOT_MASK, 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_GPIO_STRAP_REG, ESP32S3_GPIO_STRAP_SPI_BOOT_MASK, ESP32S3_RTC_CNTL_OPTION1_REG, ESP32S3_RTC_CNTL_FORCE_DOWNLOAD_BOOT_MASK, 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, 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_UARTDEV_BUF_NO, ESP32C5_UARTDEV_BUF_NO_USB_JTAG_SERIAL, ESP32C6_UARTDEV_BUF_NO, ESP32C6_UARTDEV_BUF_NO_USB_JTAG_SERIAL, ESP32P4_RTC_CNTL_WDTWPROTECT_REG, ESP32P4_RTC_CNTL_WDTCONFIG0_REG, ESP32P4_RTC_CNTL_WDTCONFIG1_REG, ESP32P4_RTC_CNTL_WDT_WKEY, ESP32P4_UARTDEV_BUF_NO_REV0, ESP32P4_UARTDEV_BUF_NO_REV300, ESP32P4_UARTDEV_BUF_NO_USB_OTG, ESP32P4_UARTDEV_BUF_NO_USB_JTAG_SERIAL, ESP32P4_RTC_CNTL_OPTION1_REG, ESP32P4_RTC_CNTL_FORCE_DOWNLOAD_BOOT_MASK, ESP32H2_UARTDEV_BUF_NO, ESP32H2_UARTDEV_BUF_NO_USB_JTAG_SERIAL, } from "./const";
 import { getStubCode } from "./stubs";
 import { hexFormatter, sleep, slipEncode, toHex } from "./util";
 import { deflate } from "pako";
 import { pack, unpack } from "./struct";
 export class ESPLoader extends EventTarget {
+    /**
+     * Check if device is using USB-JTAG or USB-OTG (not external serial chip)
+     * Returns undefined if not yet determined
+     */
+    get isUsbJtagOrOtg() {
+        return this._parent ? this._parent._isUsbJtagOrOtg : this._isUsbJtagOrOtg;
+    }
     constructor(port, logger, _parent) {
         super();
         this.port = port;
@@ -19,12 +26,19 @@ export class ESPLoader extends EventTarget {
         this.IS_STUB = false;
         this.connected = true;
         this.flashSize = null;
-        this.__currentBaudRate = ESP_ROM_BAUD;
+        this.currentBaudRate = ESP_ROM_BAUD;
+        this.SLIP_END = 0xc0;
+        this.SLIP_ESC = 0xdb;
+        this.SLIP_ESC_END = 0xdc;
+        this.SLIP_ESC_ESC = 0xdd;
         this._isESP32S2NativeUSB = false;
         this._initializationSucceeded = false;
         this.__commandLock = Promise.resolve([0, []]);
         this.__isReconfiguring = false;
         this.__abandonCurrentOperation = false;
+        this._suppressDisconnect = false;
+        this.__consoleMode = false;
+        this._isUsbJtagOrOtg = undefined;
         // Adaptive speed adjustment for flash read operations
         this.__adaptiveBlockMultiplier = 1;
         this.__adaptiveMaxInFlightMultiplier = 1;
@@ -81,6 +95,22 @@ export class ESPLoader extends EventTarget {
             this.__chipVariant = value;
         }
     }
+    // Console mode with parent delegation
+    get _consoleMode() {
+        return this._parent ? this._parent._consoleMode : this.__consoleMode;
+    }
+    set _consoleMode(value) {
+        if (this._parent) {
+            this._parent._consoleMode = value;
+        }
+        else {
+            this.__consoleMode = value;
+        }
+    }
+    // Public setter for console mode (used by script.js)
+    setConsoleMode(value) {
+        this._consoleMode = value;
+    }
     get _inputBuffer() {
         if (this._parent) {
             return this._parent._inputBuffer;
@@ -317,6 +347,16 @@ export class ESPLoader extends EventTarget {
         await this.connectWithResetStrategies();
         // Detect chip type
         await this.detectChip();
+        // Detect if device is using USB-JTAG/Serial or USB-OTG (not external serial chip)
+        // This is needed to determine the correct reset strategy for console mode
+        try {
+            this._isUsbJtagOrOtg = await this.detectUsbConnectionType();
+            this.logger.debug(`USB connection type: ${this._isUsbJtagOrOtg ? "USB-JTAG/OTG" : "External Serial Chip"}`);
+        }
+        catch (err) {
+            this.logger.debug(`Could not detect USB connection type: ${err}`);
+            // Leave as undefined if detection fails
+        }
         // Read the OTP data for this chip and store into this.efuses array
         const FlAddr = getSpiFlashAddresses(this.getChipFamily());
         const AddrMAC = FlAddr.macFuse;
@@ -340,7 +380,7 @@ export class ESPLoader extends EventTarget {
             if (chipInfo) {
                 this.chipName = chipInfo.name;
                 this.chipFamily = chipInfo.family;
-                // Get chip revision for ESP32-P4
+                // 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}`);
@@ -353,6 +393,10 @@ export class ESPLoader extends EventTarget {
                     }
                     this.logger.debug(`ESP32-P4 variant: ${this.chipVariant}`);
                 }
+                else if (this.chipFamily === CHIP_FAMILY_ESP32C3) {
+                    this.chipRevision = await this.getChipRevision();
+                    this.logger.debug(`ESP32-C3 revision: ${this.chipRevision}`);
+                }
                 this.logger.debug(`Detected chip via IMAGE_CHIP_ID: ${chipId} (${this.chipName})`);
                 return;
             }
@@ -385,7 +429,6 @@ export class ESPLoader extends EventTarget {
         this.chipFamily = chip.family;
         if (this.chipFamily === CHIP_FAMILY_ESP32P4) {
             this.chipRevision = await this.getChipRevision();
-            this.logger.debug(`ESP32-P4 revision: ${this.chipRevision}`);
             if (this.chipRevision >= 300) {
                 this.chipVariant = "rev300";
             }
@@ -394,24 +437,30 @@ export class ESPLoader extends EventTarget {
             }
             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) {
-            return 0;
+        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();
         }
-        // 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;
+        return 0;
     }
     /**
      * Get security info including chip ID (ESP32-C3 and later)
@@ -484,13 +533,24 @@ export class ESPLoader extends EventTarget {
             }
         }
         catch {
-            this.logger.error("Read loop got disconnected");
+            //      this.logger.error("Read loop got disconnected");
         }
         finally {
             // Always reset reconfiguring flag when read loop ends
             // This prevents "Cannot write during port reconfiguration" errors
             // when the read loop dies unexpectedly
             this._isReconfiguring = false;
+            // Release reader if still locked
+            if (this._reader) {
+                try {
+                    this._reader.releaseLock();
+                    this.logger.debug("Reader released in readLoop cleanup");
+                }
+                catch (err) {
+                    this.logger.debug(`Reader release error in readLoop: ${err}`);
+                }
+                this._reader = undefined;
+            }
         }
         // Disconnected!
         this.connected = false;
@@ -502,7 +562,11 @@ export class ESPLoader extends EventTarget {
                 detail: { message: "ESP32-S2 Native USB requires port reselection" },
             }));
         }
-        this.dispatchEvent(new Event("disconnect"));
+        // Only dispatch disconnect event if not suppressed
+        if (!this._suppressDisconnect) {
+            this.dispatchEvent(new Event("disconnect"));
+        }
+        this._suppressDisconnect = false;
         this.logger.debug("Finished read loop");
     }
     sleep(ms = 100) {
@@ -564,6 +628,30 @@ export class ESPLoader extends EventTarget {
         await this.setDTR(false); // IO0=HIGH, done
         await this.sleep(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);
+    }
     /**
      * @name hardResetUnixTight
      * Unix Tight reset for Web Serial (Desktop) - sets DTR and RTS simultaneously
@@ -1013,7 +1101,7 @@ export class ESPLoader extends EventTarget {
             try {
                 // Check if port is still open, if not, skip this strategy
                 if (!this.connected || !this.port.writable) {
-                    this.logger.log(`Port disconnected, skipping ${strategy.name} reset`);
+                    this.logger.debug(`Port disconnected, skipping ${strategy.name} reset`);
                     continue;
                 }
                 // Clear abandon flag before starting new strategy
@@ -1055,7 +1143,9 @@ export class ESPLoader extends EventTarget {
             }
             catch (error) {
                 lastError = error;
-                this.logger.log(`${strategy.name} reset failed: ${error.message}`);
+                //        this.logger.debug(
+                //          `${strategy.name} reset failed: ${(error as Error).message}`,
+                //        );
                 // Set abandon flag to stop any in-flight operations
                 this._abandonCurrentOperation = true;
                 // Wait a bit for in-flight operations to abort
@@ -1077,12 +1167,134 @@ export class ESPLoader extends EventTarget {
     }
     /**
      * @name watchdogReset
-     * Watchdog reset for ESP32-S2/S3 with USB-OTG
+     * Watchdog reset for ESP32-S2/S3/C3 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
      */
     async watchdogReset() {
-        this.logger.log("Hard resetting with watchdog timer...");
-        // Select correct register addresses based on chip family
+        await this.rtcWdtResetChipSpecific();
+    }
+    /**
+     * Check if current chip is using USB-OTG
+     * Supports ESP32-S2 and ESP32-S3
+     */
+    async usingUsbOtg() {
+        let uartDevBufNo;
+        let usbOtgValue;
+        if (this.chipFamily === CHIP_FAMILY_ESP32S2) {
+            uartDevBufNo = ESP32S2_UARTDEV_BUF_NO;
+            usbOtgValue = ESP32S2_UARTDEV_BUF_NO_USB_OTG;
+        }
+        else if (this.chipFamily === CHIP_FAMILY_ESP32S3) {
+            uartDevBufNo = ESP32S3_UARTDEV_BUF_NO;
+            usbOtgValue = ESP32S3_UARTDEV_BUF_NO_USB_OTG;
+        }
+        else if (this.chipFamily === CHIP_FAMILY_ESP32P4) {
+            // P4: UARTDEV_BUF_NO depends on chip revision
+            if (this.chipRevision === null) {
+                this.chipRevision = await this.getChipRevision();
+            }
+            if (this.chipRevision < 300) {
+                uartDevBufNo = ESP32P4_UARTDEV_BUF_NO_REV0;
+            }
+            else {
+                uartDevBufNo = ESP32P4_UARTDEV_BUF_NO_REV300;
+            }
+            usbOtgValue = ESP32P4_UARTDEV_BUF_NO_USB_OTG;
+        }
+        else {
+            return false;
+        }
+        const uartNo = (await this.readRegister(uartDevBufNo)) & 0xff;
+        return uartNo === usbOtgValue;
+    }
+    /**
+     * Check if current chip is using USB-JTAG/Serial
+     * Supports ESP32-S3 and ESP32-C3
+     */
+    async usingUsbJtagSerial() {
+        let uartDevBufNo;
+        let usbJtagSerialValue;
+        if (this.chipFamily === CHIP_FAMILY_ESP32S3) {
+            uartDevBufNo = ESP32S3_UARTDEV_BUF_NO;
+            usbJtagSerialValue = ESP32S3_UARTDEV_BUF_NO_USB_JTAG_SERIAL;
+        }
+        else if (this.chipFamily === CHIP_FAMILY_ESP32C3) {
+            // ESP32-C3: BSS_UART_DEV_ADDR depends on chip revision
+            // Revision < 101: 0x3FCDF064
+            // Revision >= 101: 0x3FCDF060
+            let bssUartDevAddr;
+            // Get chip revision if not already set
+            if (this.chipRevision === null) {
+                this.chipRevision = await this.getChipRevisionC3();
+            }
+            if (this.chipRevision < 101) {
+                bssUartDevAddr = 0x3fcdf064;
+            }
+            else {
+                bssUartDevAddr = 0x3fcdf060;
+            }
+            uartDevBufNo = bssUartDevAddr + ESP32C3_BUF_UART_NO_OFFSET;
+            usbJtagSerialValue = ESP32C3_UARTDEV_BUF_NO_USB_JTAG_SERIAL;
+        }
+        else if (this.chipFamily === CHIP_FAMILY_ESP32C5) {
+            uartDevBufNo = ESP32C5_UARTDEV_BUF_NO;
+            usbJtagSerialValue = ESP32C5_UARTDEV_BUF_NO_USB_JTAG_SERIAL;
+        }
+        else if (this.chipFamily === CHIP_FAMILY_ESP32C6) {
+            uartDevBufNo = ESP32C6_UARTDEV_BUF_NO;
+            usbJtagSerialValue = ESP32C6_UARTDEV_BUF_NO_USB_JTAG_SERIAL;
+        }
+        else if (this.chipFamily === CHIP_FAMILY_ESP32P4) {
+            // P4: UARTDEV_BUF_NO depends on chip revision
+            // Revision < 300: 0x4FF3FEC8
+            // Revision >= 300: 0x4FFBFEC8
+            if (this.chipRevision === null) {
+                this.chipRevision = await this.getChipRevision();
+            }
+            if (this.chipRevision < 300) {
+                uartDevBufNo = ESP32P4_UARTDEV_BUF_NO_REV0;
+            }
+            else {
+                uartDevBufNo = ESP32P4_UARTDEV_BUF_NO_REV300;
+            }
+            usbJtagSerialValue = ESP32P4_UARTDEV_BUF_NO_USB_JTAG_SERIAL;
+        }
+        else if (this.chipFamily === CHIP_FAMILY_ESP32H2) {
+            uartDevBufNo = ESP32H2_UARTDEV_BUF_NO;
+            usbJtagSerialValue = ESP32H2_UARTDEV_BUF_NO_USB_JTAG_SERIAL;
+        }
+        else {
+            return false;
+        }
+        const uartNo = (await this.readRegister(uartDevBufNo)) & 0xff;
+        return uartNo === usbJtagSerialValue;
+    }
+    /**
+     * 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
+     * Uses specific registers for each chip family
+     * Note: ESP32-H2 does NOT support WDT reset
+     */
+    async rtcWdtResetChipSpecific() {
+        this.logger.debug("Hard resetting with watchdog timer...");
         let WDTWPROTECT_REG;
         let WDTCONFIG0_REG;
         let WDTCONFIG1_REG;
@@ -1099,12 +1311,62 @@ 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;
+            WDTCONFIG0_REG = ESP32P4_RTC_CNTL_WDTCONFIG0_REG;
+            WDTCONFIG1_REG = ESP32P4_RTC_CNTL_WDTCONFIG1_REG;
+            WDT_WKEY = ESP32P4_RTC_CNTL_WDT_WKEY;
+        }
         else {
-            throw new Error(`watchdogReset() is only supported for ESP32-S2 and ESP32-S3, not ${this.chipFamily}`);
+            throw new Error(`rtcWdtResetChipSpecific() is not supported for ${this.chipFamily}`);
         }
         // Unlock watchdog registers
         await this.writeRegister(WDTWPROTECT_REG, WDT_WKEY, undefined, 0);
-        // Set WDT timeout to 2000ms
+        // Clear force download boot register (if applicable) BEFORE triggering WDT reset
+        // This ensures the chip boots into firmware mode after reset
+        if (this.chipFamily === CHIP_FAMILY_ESP32S2) {
+            try {
+                await this.writeRegister(ESP32S2_RTC_CNTL_OPTION1_REG, 0, ESP32S2_RTC_CNTL_FORCE_DOWNLOAD_BOOT_MASK, 0);
+                this.logger.debug("Cleared force download boot mask");
+            }
+            catch (err) {
+                this.logger.debug(`Expected error clearing force download boot mask: ${err}`);
+            }
+        }
+        else if (this.chipFamily === CHIP_FAMILY_ESP32S3) {
+            try {
+                await this.writeRegister(ESP32S3_RTC_CNTL_OPTION1_REG, 0, ESP32S3_RTC_CNTL_FORCE_DOWNLOAD_BOOT_MASK, 0);
+                this.logger.debug("Cleared force download boot mask");
+            }
+            catch (err) {
+                this.logger.debug(`Expected error clearing force download boot mask: ${err}`);
+            }
+        }
+        else if (this.chipFamily === CHIP_FAMILY_ESP32P4) {
+            try {
+                await this.writeRegister(ESP32P4_RTC_CNTL_OPTION1_REG, 0, ESP32P4_RTC_CNTL_FORCE_DOWNLOAD_BOOT_MASK, 0);
+                this.logger.debug("Cleared force download boot mask");
+            }
+            catch (err) {
+                this.logger.debug(`Expected error clearing force download boot mask: ${err}`);
+            }
+        }
+        // Set WDT timeout to 2000ms (matches Python esptool)
         await this.writeRegister(WDTCONFIG1_REG, 2000, undefined, 0);
         // Enable WDT: bit 31 = enable, bits 28-30 = stage, bit 8 = sys reset, bits 0-2 = prescaler
         const wdtConfig = (1 << 31) | (5 << 28) | (1 << 8) | 2;
@@ -1114,102 +1376,139 @@ export class ESPLoader extends EventTarget {
         // Wait for reset to take effect
         await this.sleep(500);
     }
+    /**
+     * Helper: Check if USB-based WDT reset should be used for S2/S3
+     * Returns true if WDT reset was performed, false otherwise
+     */
+    async tryUsbWdtReset(chipName, GPIO_STRAP_REG, GPIO_STRAP_SPI_BOOT_MASK, RTC_CNTL_OPTION1_REG, RTC_CNTL_FORCE_DOWNLOAD_BOOT_MASK) {
+        const isUsingUsbOtg = await this.usingUsbOtg();
+        const isUsingUsbJtagSerial = await this.usingUsbJtagSerial();
+        if (isUsingUsbOtg || isUsingUsbJtagSerial) {
+            const strapReg = await this.readRegister(GPIO_STRAP_REG);
+            const forceDlReg = await this.readRegister(RTC_CNTL_OPTION1_REG);
+            // Only use watchdog reset if GPIO0 is low AND force download boot mode is not set
+            if ((strapReg & GPIO_STRAP_SPI_BOOT_MASK) === 0 &&
+                (forceDlReg & RTC_CNTL_FORCE_DOWNLOAD_BOOT_MASK) === 0) {
+                await this.rtcWdtResetChipSpecific();
+                this.logger.debug(`${chipName}: RTC WDT reset (USB detected, GPIO0 low)`);
+                return true;
+            }
+        }
+        return false;
+    }
+    /**
+     * Chip-specific hard reset for ESP32-S2
+     * Checks if using USB-JTAG/Serial and uses watchdog reset if necessary
+     */
+    async hardResetS2() {
+        const isUsingUsbOtg = await this.usingUsbOtg();
+        if (isUsingUsbOtg) {
+            await this.rtcWdtResetChipSpecific();
+            this.logger.debug("ESP32-S2: RTC WDT reset (USB-OTG detected)");
+        }
+        else {
+            // Use standard hardware reset
+            await this.hardResetClassic();
+            this.logger.debug("ESP32-S2: Classic reset");
+        }
+    }
+    /**
+     * Chip-specific hard reset for ESP32-S3
+     * Checks if using USB-JTAG/Serial and uses watchdog reset if necessary
+     */
+    async hardResetS3() {
+        const isUsingUsbJtagSerial = await this.usingUsbJtagSerial();
+        if (isUsingUsbJtagSerial) {
+            await this.rtcWdtResetChipSpecific();
+            this.logger.debug("ESP32-S3: RTC WDT reset (USB-JTAG/Serial detected)");
+        }
+        else {
+            // Use standard hardware reset
+            await this.hardResetClassic();
+            this.logger.debug("ESP32-S3: Classic reset");
+        }
+    }
+    /**
+     * Chip-specific hard reset for ESP32-C3
+     * Checks if using USB-JTAG/Serial and uses watchdog reset if necessary
+     */
+    async hardResetC3() {
+        const isUsingUsbJtagSerial = await this.usingUsbJtagSerial();
+        if (isUsingUsbJtagSerial) {
+            await this.rtcWdtResetChipSpecific();
+            this.logger.debug("ESP32-C3: RTC WDT reset (USB-JTAG/Serial detected)");
+        }
+        else {
+            // Use standard hardware reset
+            await this.hardResetClassic();
+            this.logger.debug("ESP32-C3: Classic reset");
+        }
+    }
     async hardReset(bootloader = false) {
+        // In console mode, only allow simple hardware reset (no bootloader entry)
+        if (this._consoleMode) {
+            if (bootloader) {
+                this.logger.debug("Skipping bootloader reset - device is in console mode");
+                return;
+            }
+            // 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();
+            }
+            this.logger.debug("Hardware reset complete");
+            return;
+        }
         if (bootloader) {
             // enter flash mode
             if (this.port.getInfo().usbProductId === USB_JTAG_SERIAL_PID) {
                 await this.hardResetUSBJTAGSerial();
-                this.logger.log("USB-JTAG/Serial reset.");
+                this.logger.debug("USB-JTAG/Serial reset.");
             }
             else {
                 // Use different reset strategy for WebUSB (Android) vs Web Serial (Desktop)
                 if (this.isWebUSB()) {
                     await this.hardResetClassicWebUSB();
-                    this.logger.log("Classic reset (WebUSB/Android).");
+                    this.logger.debug("Classic reset (WebUSB/Android).");
                 }
                 else {
                     await this.hardResetClassic();
-                    this.logger.log("Classic reset.");
+                    this.logger.debug("Classic reset.");
                 }
             }
         }
         else {
             // just reset (no bootloader mode)
-            // For ESP32-S2/S3 with USB-OTG, check if watchdog reset is needed
-            if (this.port.getInfo().usbProductId === USB_JTAG_SERIAL_PID &&
-                (this.chipFamily === CHIP_FAMILY_ESP32S2 ||
-                    this.chipFamily === CHIP_FAMILY_ESP32S3)) {
-                // ESP32-S2/S3: Clear force download boot mode first
-                try {
-                    // Clear force download boot mode to avoid chip being stuck in download mode
-                    // after reset. Workaround for issue:
-                    // https://github.com/espressif/arduino-esp32/issues/6762
-                    const RTC_CNTL_OPTION1_REG = this.chipFamily === CHIP_FAMILY_ESP32S2
-                        ? ESP32S2_RTC_CNTL_OPTION1_REG
-                        : ESP32S3_RTC_CNTL_OPTION1_REG;
-                    const RTC_CNTL_FORCE_DOWNLOAD_BOOT_MASK = this.chipFamily === CHIP_FAMILY_ESP32S2
-                        ? ESP32S2_RTC_CNTL_FORCE_DOWNLOAD_BOOT_MASK
-                        : ESP32S3_RTC_CNTL_FORCE_DOWNLOAD_BOOT_MASK;
-                    await this.writeRegister(RTC_CNTL_OPTION1_REG, 0, RTC_CNTL_FORCE_DOWNLOAD_BOOT_MASK, 0);
-                }
-                catch (e) {
-                    // Skip invalid response and continue reset (can happen when monitoring during reset)
-                    this.logger.log("Warning: Could not clear force download boot mode:", e);
-                }
-                // Check the strapping register to see if we can perform a watchdog reset
-                // Only use watchdog reset if GPIO0 is low AND force download boot mode is not set
-                let useWatchdogReset = false;
-                try {
-                    const GPIO_STRAP_REG = this.chipFamily === CHIP_FAMILY_ESP32S2
-                        ? ESP32S2_GPIO_STRAP_REG
-                        : ESP32S3_GPIO_STRAP_REG;
-                    const GPIO_STRAP_SPI_BOOT_MASK = this.chipFamily === CHIP_FAMILY_ESP32S2
-                        ? ESP32S2_GPIO_STRAP_SPI_BOOT_MASK
-                        : ESP32S3_GPIO_STRAP_SPI_BOOT_MASK;
-                    const RTC_CNTL_OPTION1_REG = this.chipFamily === CHIP_FAMILY_ESP32S2
-                        ? ESP32S2_RTC_CNTL_OPTION1_REG
-                        : ESP32S3_RTC_CNTL_OPTION1_REG;
-                    const RTC_CNTL_FORCE_DOWNLOAD_BOOT_MASK = this.chipFamily === CHIP_FAMILY_ESP32S2
-                        ? ESP32S2_RTC_CNTL_FORCE_DOWNLOAD_BOOT_MASK
-                        : ESP32S3_RTC_CNTL_FORCE_DOWNLOAD_BOOT_MASK;
-                    const strapReg = await this.readRegister(GPIO_STRAP_REG);
-                    const forceDlReg = await this.readRegister(RTC_CNTL_OPTION1_REG);
-                    // GPIO0 low (download mode) AND force download boot not set
-                    if ((strapReg & GPIO_STRAP_SPI_BOOT_MASK) === 0 &&
-                        (forceDlReg & RTC_CNTL_FORCE_DOWNLOAD_BOOT_MASK) === 0) {
-                        useWatchdogReset = true;
-                    }
-                }
-                catch (e) {
-                    // If we can't read the registers, use watchdog reset as fallback
-                    this.logger.log("Warning: Could not read strap/option registers, using watchdog reset:", e);
-                    useWatchdogReset = true;
-                }
-                if (useWatchdogReset) {
-                    await this.watchdogReset();
-                    this.logger.log("Watchdog reset (USB-OTG).");
-                }
-                else {
-                    // Not in download mode, can use DTR/RTS reset
-                    // But USB-OTG doesn't have DTR/RTS, so fall back to watchdog
-                    await this.watchdogReset();
-                    this.logger.log("Watchdog reset (USB-OTG, normal boot).");
-                }
+            // For ESP32-S2/S3 with USB-OTG or USB-JTAG/Serial, check if watchdog reset is needed
+            if (this.chipFamily === CHIP_FAMILY_ESP32S2 && !this._consoleMode) {
+                const wdtResetUsed = await this.tryUsbWdtReset("ESP32-S2", ESP32S2_GPIO_STRAP_REG, ESP32S2_GPIO_STRAP_SPI_BOOT_MASK, ESP32S2_RTC_CNTL_OPTION1_REG, ESP32S2_RTC_CNTL_FORCE_DOWNLOAD_BOOT_MASK);
+                if (wdtResetUsed)
+                    return;
+            }
+            else if (this.chipFamily === CHIP_FAMILY_ESP32S3 &&
+                !this._consoleMode) {
+                const wdtResetUsed = await this.tryUsbWdtReset("ESP32-S3", ESP32S3_GPIO_STRAP_REG, ESP32S3_GPIO_STRAP_SPI_BOOT_MASK, ESP32S3_RTC_CNTL_OPTION1_REG, ESP32S3_RTC_CNTL_FORCE_DOWNLOAD_BOOT_MASK);
+                if (wdtResetUsed)
+                    return;
             }
-            else if (this.isWebUSB()) {
+            // 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.log("Hard reset (WebUSB).");
+                this.logger.debug("Hard reset (WebUSB).");
             }
             else {
                 // Web Serial: Standard reset
                 await this.setRTS(true); // EN->LOW
                 await this.sleep(100);
                 await this.setRTS(false);
-                this.logger.log("Hard reset.");
+                this.logger.debug("Hard reset.");
             }
         }
         await new Promise((resolve) => setTimeout(resolve, 1000));
@@ -1425,44 +1724,44 @@ export class ESPLoader extends EventTarget {
                         const waitingFor = partialPacket === null ? "header" : "content";
                         throw new SlipReadError("Timed out waiting for packet " + waitingFor);
                     }
-                    const b = this._readByte();
+                    const byte = this._readByte();
                     if (partialPacket === null) {
                         // waiting for packet header
-                        if (b == 0xc0) {
+                        if (byte == this.SLIP_END) {
                             partialPacket = [];
                         }
                         else {
                             if (this.debug) {
-                                this.logger.debug("Read invalid data: " + toHex(b));
+                                this.logger.debug("Read invalid data: " + toHex(byte));
                                 this.logger.debug("Remaining data in serial buffer: " +
                                     hexFormatter(this._inputBuffer));
                             }
-                            throw new SlipReadError("Invalid head of packet (" + toHex(b) + ")");
+                            throw new SlipReadError("Invalid head of packet (" + toHex(byte) + ")");
                         }
                     }
                     else if (inEscape) {
                         // part-way through escape sequence
                         inEscape = false;
-                        if (b == 0xdc) {
-                            partialPacket.push(0xc0);
+                        if (byte == this.SLIP_ESC_END) {
+                            partialPacket.push(this.SLIP_END);
                         }
-                        else if (b == 0xdd) {
-                            partialPacket.push(0xdb);
+                        else if (byte == this.SLIP_ESC_ESC) {
+                            partialPacket.push(this.SLIP_ESC);
                         }
                         else {
                             if (this.debug) {
-                                this.logger.debug("Read invalid data: " + toHex(b));
+                                this.logger.debug("Read invalid data: " + toHex(byte));
                                 this.logger.debug("Remaining data in serial buffer: " +
                                     hexFormatter(this._inputBuffer));
                             }
-                            throw new SlipReadError("Invalid SLIP escape (0xdb, " + toHex(b) + ")");
+                            throw new SlipReadError("Invalid SLIP escape (0xdb, " + toHex(byte) + ")");
                         }
                     }
-                    else if (b == 0xdb) {
+                    else if (byte == this.SLIP_ESC) {
                         // start of escape sequence
                         inEscape = true;
                     }
-                    else if (b == 0xc0) {
+                    else if (byte == this.SLIP_END) {
                         // end of packet
                         if (this.debug)
                             this.logger.debug("Received full packet: " + hexFormatter(partialPacket));
@@ -1472,7 +1771,7 @@ export class ESPLoader extends EventTarget {
                     }
                     else {
                         // normal byte in packet
-                        partialPacket.push(b);
+                        partialPacket.push(byte);
                     }
                 }
             }
@@ -1503,44 +1802,44 @@ export class ESPLoader extends EventTarget {
                 }
                 if (this.debug)
                     this.logger.debug("Read " + readBytes.length + " bytes: " + hexFormatter(readBytes));
-                for (const b of readBytes) {
+                for (const byte of readBytes) {
                     if (partialPacket === null) {
                         // waiting for packet header
-                        if (b == 0xc0) {
+                        if (byte == this.SLIP_END) {
                             partialPacket = [];
                         }
                         else {
                             if (this.debug) {
-                                this.logger.debug("Read invalid data: " + toHex(b));
+                                this.logger.debug("Read invalid data: " + toHex(byte));
                                 this.logger.debug("Remaining data in serial buffer: " +
                                     hexFormatter(this._inputBuffer));
                             }
-                            throw new SlipReadError("Invalid head of packet (" + toHex(b) + ")");
+                            throw new SlipReadError("Invalid head of packet (" + toHex(byte) + ")");
                         }
                     }
                     else if (inEscape) {
                         // part-way through escape sequence
                         inEscape = false;
-                        if (b == 0xdc) {
-                            partialPacket.push(0xc0);
+                        if (byte == this.SLIP_ESC_END) {
+                            partialPacket.push(this.SLIP_END);
                         }
-                        else if (b == 0xdd) {
-                            partialPacket.push(0xdb);
+                        else if (byte == this.SLIP_ESC_ESC) {
+                            partialPacket.push(this.SLIP_ESC);
                         }
                         else {
                             if (this.debug) {
-                                this.logger.debug("Read invalid data: " + toHex(b));
+                                this.logger.debug("Read invalid data: " + toHex(byte));
                                 this.logger.debug("Remaining data in serial buffer: " +
                                     hexFormatter(this._inputBuffer));
                             }
-                            throw new SlipReadError("Invalid SLIP escape (0xdb, " + toHex(b) + ")");
+                            throw new SlipReadError("Invalid SLIP escape (0xdb, " + toHex(byte) + ")");
                         }
                     }
-                    else if (b == 0xdb) {
+                    else if (byte == this.SLIP_ESC) {
                         // start of escape sequence
                         inEscape = true;
                     }
-                    else if (b == 0xc0) {
+                    else if (byte == this.SLIP_END) {
                         // end of packet
                         if (this.debug)
                             this.logger.debug("Received full packet: " + hexFormatter(partialPacket));
@@ -1550,7 +1849,7 @@ export class ESPLoader extends EventTarget {
                     }
                     else {
                         // normal byte in packet
-                        partialPacket.push(b);
+                        partialPacket.push(byte);
                     }
                 }
             }
@@ -1615,10 +1914,10 @@ export class ESPLoader extends EventTarget {
         await sleep(SYNC_TIMEOUT);
         // Track current baudrate for reconnect
         if (this._parent) {
-            this._parent._currentBaudRate = baud;
+            this._parent.currentBaudRate = baud;
         }
         else {
-            this._currentBaudRate = baud;
+            this.currentBaudRate = baud;
         }
         // Warn if baudrate exceeds USB-Serial chip capability
         const maxBaud = this._parent
@@ -1690,8 +1989,8 @@ export class ESPLoader extends EventTarget {
             this.readLoop();
         }
         catch (e) {
-            this.logger.error(`Reconfigure port error: ${e}`);
-            throw new Error(`Unable to change the baud rate to ${baud}: ${e}`);
+            //      this.logger.error(`Reconfigure port error: ${e}`);
+            //      throw new Error(`Unable to change the baud rate to ${baud}: ${e}`);
         }
         finally {
             // Always reset flag, even on error or early return
@@ -2224,19 +2523,6 @@ export class ESPLoader extends EventTarget {
             this.__writeChain = value;
         }
     }
-    get _currentBaudRate() {
-        return this._parent
-            ? this._parent._currentBaudRate
-            : this.__currentBaudRate;
-    }
-    set _currentBaudRate(value) {
-        if (this._parent) {
-            this._parent._currentBaudRate = value;
-        }
-        else {
-            this.__currentBaudRate = value;
-        }
-    }
     async writeToStream(data) {
         if (!this.port.writable) {
             this.logger.debug("Port writable stream not available, skipping write");
@@ -2306,7 +2592,7 @@ export class ESPLoader extends EventTarget {
             return;
         }
         if (!this.port.writable) {
-            this.logger.debug("Port already closed, skipping disconnect");
+            //      this.logger.debug("Port already closed, skipping disconnect");
             return;
         }
         // Wait for pending writes to complete
@@ -2314,7 +2600,7 @@ export class ESPLoader extends EventTarget {
             await this._writeChain;
         }
         catch (err) {
-            this.logger.debug(`Pending write error during disconnect: ${err}`);
+            //      this.logger.debug(`Pending write error during disconnect: ${err}`);
         }
         // Release persistent writer before closing
         if (this._writer) {
@@ -2323,7 +2609,7 @@ export class ESPLoader extends EventTarget {
                 this._writer.releaseLock();
             }
             catch (err) {
-                this.logger.debug(`Writer close/release error: ${err}`);
+                //        this.logger.debug(`Writer close/release error: ${err}`);
             }
             this._writer = undefined;
         }
@@ -2336,7 +2622,7 @@ export class ESPLoader extends EventTarget {
                 writer.releaseLock();
             }
             catch (err) {
-                this.logger.debug(`Direct writer close error: ${err}`);
+                //        this.logger.debug(`Direct writer close error: ${err}`);
             }
         }
         await new Promise((resolve) => {
@@ -2358,7 +2644,7 @@ export class ESPLoader extends EventTarget {
                 this._reader.cancel();
             }
             catch (err) {
-                this.logger.debug(`Reader cancel error: ${err}`);
+                //        this.logger.debug(`Reader cancel error: ${err}`);
                 // Reader already released, resolve immediately
                 clearTimeout(timeout);
                 resolve(undefined);
@@ -2374,6 +2660,235 @@ export class ESPLoader extends EventTarget {
             this.logger.debug(`Port close error: ${err}`);
         }
     }
+    /**
+     * @name releaseReaderWriter
+     * Release reader and writer locks without closing the port
+     * Used when switching to console mode
+     */
+    async releaseReaderWriter() {
+        if (this._parent) {
+            await this._parent.releaseReaderWriter();
+            return;
+        }
+        // Check if device is in JTAG mode and needs reset to boot into firmware
+        const didReconnect = await this._resetToFirmwareIfNeeded();
+        // If we reconnected for console, the reader/writer are already released and restarted
+        if (didReconnect) {
+            return;
+        }
+        // Wait for pending writes to complete
+        try {
+            await this._writeChain;
+        }
+        catch (err) {
+            //      this.logger.debug(`Pending write error during release: ${err}`);
+        }
+        // Release writer
+        if (this._writer) {
+            try {
+                this._writer.releaseLock();
+                this.logger.debug("Writer released");
+            }
+            catch (err) {
+                this.logger.debug(`Writer release error: ${err}`);
+            }
+            this._writer = undefined;
+        }
+        // Cancel and release reader
+        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");
+            }
+            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;
+            }
+        }
+    }
+    /**
+     * @name resetToFirmware
+     * Public method to reset device from bootloader to firmware for console mode
+     * Automatically detects USB-JTAG/Serial and USB-OTG devices and performs appropriate reset
+     * @returns true if reset was performed, false if not needed
+     */
+    async resetToFirmware() {
+        return await this._resetToFirmwareIfNeeded();
+    }
+    /**
+     * @name detectUsbConnectionType
+     * Detect if device is using USB-JTAG/Serial or USB-OTG (not external serial chip)
+     * This helper extracts the detection logic from initialize() for reuse
+     * @returns true if USB-JTAG or USB-OTG, false if external serial chip
+     * @throws Error if detection fails and chipFamily is not set
+     */
+    async detectUsbConnectionType() {
+        if (!this.chipFamily) {
+            throw new Error("Cannot detect USB connection type: chipFamily not set");
+        }
+        if (this.chipFamily === CHIP_FAMILY_ESP32S2 ||
+            this.chipFamily === CHIP_FAMILY_ESP32S3) {
+            const isUsingUsbOtg = await this.usingUsbOtg();
+            const isUsingUsbJtagSerial = await this.usingUsbJtagSerial();
+            return isUsingUsbOtg || isUsingUsbJtagSerial;
+        }
+        else if (this.chipFamily === CHIP_FAMILY_ESP32C3 ||
+            this.chipFamily === CHIP_FAMILY_ESP32C5 ||
+            this.chipFamily === CHIP_FAMILY_ESP32C6) {
+            const isUsingUsbJtagSerial = await this.usingUsbJtagSerial();
+            return isUsingUsbJtagSerial;
+        }
+        else if (this.chipFamily === CHIP_FAMILY_ESP32P4) {
+            const isUsingUsbOtg = await this.usingUsbOtg();
+            const isUsingUsbJtagSerial = await this.usingUsbJtagSerial();
+            return isUsingUsbOtg || isUsingUsbJtagSerial;
+        }
+        else {
+            // Other chips don't have USB-JTAG/OTG
+            return false;
+        }
+    }
+    /**
+     * @name enterConsoleMode
+     * Prepare device for console mode by resetting to firmware
+     * Handles both USB-JTAG/OTG devices (closes port) and external serial chips (keeps port open)
+     * @returns true if port was closed (USB-JTAG), false if port stays open (serial chip)
+     */
+    async enterConsoleMode() {
+        // Set console mode flag
+        this._consoleMode = true;
+        // Re-detect USB connection type to ensure we have a definitive value
+        // This handles cases where isUsbJtagOrOtg might be undefined
+        let isUsbJtag;
+        try {
+            isUsbJtag = await this.detectUsbConnectionType();
+            this.logger.debug(`USB connection type detected: ${isUsbJtag ? "USB-JTAG/OTG" : "External Serial Chip"}`);
+        }
+        catch (err) {
+            // If detection fails, fall back to cached value or fail-fast
+            if (this.isUsbJtagOrOtg === undefined) {
+                throw new Error(`Cannot enter console mode: USB connection type unknown and detection failed: ${err}`);
+            }
+            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
+        if (isUsbJtag) {
+            // USB-JTAG/OTG devices: Use watchdog reset which closes port
+            const wasReset = await this._resetToFirmwareIfNeeded();
+            return wasReset; // true = port closed, caller must reopen
+        }
+        else {
+            // External serial chip devices: Release locks and do simple reset
+            try {
+                await this.releaseReaderWriter();
+                await this.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");
+            }
+            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) {
+                    this.logger.debug(`Failed to recreate WebUSB streams: ${err}`);
+                }
+            }
+            return false; // Port stays open
+        }
+    }
+    /**
+     * @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() {
+        try {
+            // Check if device is using USB-JTAG/Serial or USB-OTG
+            // Value should already be set during main() connection
+            // Use getter to access parent's value if this is a stub
+            const needsReset = this.isUsbJtagOrOtg === true;
+            if (needsReset) {
+                const resetMethod = this.chipFamily === CHIP_FAMILY_ESP32S2 ||
+                    this.chipFamily === CHIP_FAMILY_ESP32S3
+                    ? "USB-JTAG/Serial or USB-OTG"
+                    : "USB-JTAG/Serial";
+                this.logger.log(`Resetting ${this.chipName || "device"} (${resetMethod}) to boot into firmware...`);
+                // Set console mode flag before reset to prevent subsequent hardReset calls
+                this._consoleMode = true;
+                // For S2/S3: Clear force download boot mask before WDT reset
+                if (this.chipFamily === CHIP_FAMILY_ESP32S2 ||
+                    this.chipFamily === CHIP_FAMILY_ESP32S3) {
+                    const OPTION1_REG = this.chipFamily === CHIP_FAMILY_ESP32S2
+                        ? ESP32S2_RTC_CNTL_OPTION1_REG
+                        : ESP32S3_RTC_CNTL_OPTION1_REG;
+                    const FORCE_DOWNLOAD_BOOT_MASK = this.chipFamily === CHIP_FAMILY_ESP32S2
+                        ? ESP32S2_RTC_CNTL_FORCE_DOWNLOAD_BOOT_MASK
+                        : ESP32S3_RTC_CNTL_FORCE_DOWNLOAD_BOOT_MASK;
+                    try {
+                        // Clear force download boot mode to avoid chip being stuck in download mode
+                        await this.writeRegister(OPTION1_REG, 0, FORCE_DOWNLOAD_BOOT_MASK, 0);
+                        this.logger.debug("Cleared force download boot mask");
+                    }
+                    catch (err) {
+                        this.logger.debug(`Expected error clearing force download boot mask: ${err}`);
+                    }
+                }
+                // Perform watchdog reset to reboot into firmware
+                try {
+                    await this.rtcWdtResetChipSpecific();
+                    this.logger.debug("Watchdog reset triggered successfully");
+                }
+                catch (err) {
+                    // Error is expected - device resets before responding
+                    this.logger.debug(`Watchdog reset initiated (connection lost as expected: ${err})`);
+                }
+                // Wait for device to fully boot into firmware
+                this.logger.log("Waiting for device to boot into firmware...");
+                await this.sleep(1000);
+                // After WDT reset, streams are dead/locked - don't try to manipulate them
+                // Just mark everything as disconnected and let browser clean up
+                this.connected = false;
+                this._writer = undefined;
+                this._reader = undefined;
+                this.logger.debug("Device reset to firmware mode (port closed)");
+                return true;
+            }
+        }
+        catch (err) {
+            this.logger.debug(`Could not reset device to firmware mode: ${err}`);
+            // Continue anyway - console mode might still work
+        }
+        return false;
+    }
     /**
      * @name reconnectAndResume
      * Reconnect the serial port to flush browser buffers and reload stub
@@ -2385,6 +2900,7 @@ export class ESPLoader extends EventTarget {
         }
         try {
             this.logger.log("Reconnecting serial port...");
+            const savedBaudRate = this.currentBaudRate;
             this.connected = false;
             this.__inputBuffer = [];
             this.__inputBufferReadIndex = 0;
@@ -2420,7 +2936,7 @@ export class ESPLoader extends EventTarget {
             // Close port
             try {
                 await this.port.close();
-                this.logger.log("Port closed");
+                this.logger.debug("Port closed");
             }
             catch (err) {
                 this.logger.debug(`Port close error: ${err}`);
@@ -2430,6 +2946,7 @@ export class ESPLoader extends EventTarget {
             try {
                 await this.port.open({ baudRate: ESP_ROM_BAUD });
                 this.connected = true;
+                this.currentBaudRate = ESP_ROM_BAUD;
             }
             catch (err) {
                 throw new Error(`Failed to open port: ${err}`);
@@ -2471,8 +2988,8 @@ export class ESPLoader extends EventTarget {
             const stubLoader = await this.runStub(true);
             this.logger.debug("Stub loaded");
             // Restore baudrate if it was changed
-            if (this._currentBaudRate !== ESP_ROM_BAUD) {
-                await stubLoader.setBaudrate(this._currentBaudRate);
+            if (savedBaudRate !== ESP_ROM_BAUD) {
+                await stubLoader.setBaudrate(savedBaudRate);
                 // Verify port is still ready after baudrate change
                 if (!this.port.writable || !this.port.readable) {
                     throw new Error(`Port not ready after baudrate change (readable: ${!!this.port.readable}, writable: ${!!this.port.writable})`);
@@ -2502,6 +3019,8 @@ export class ESPLoader extends EventTarget {
         }
         try {
             this.logger.log("Reconnecting to bootloader mode...");
+            // Clear console mode flag when reconnecting to bootloader
+            this._consoleMode = false;
             this.connected = false;
             this.__inputBuffer = [];
             this.__inputBufferReadIndex = 0;
@@ -2537,7 +3056,7 @@ export class ESPLoader extends EventTarget {
             // Close port
             try {
                 await this.port.close();
-                this.logger.log("Port closed");
+                this.logger.debug("Port closed");
             }
             catch (err) {
                 this.logger.debug(`Port close error: ${err}`);
@@ -2547,6 +3066,7 @@ export class ESPLoader extends EventTarget {
             try {
                 await this.port.open({ baudRate: ESP_ROM_BAUD });
                 this.connected = true;
+                this.currentBaudRate = ESP_ROM_BAUD;
             }
             catch (err) {
                 throw new Error(`Failed to open port: ${err}`);
@@ -2560,6 +3080,8 @@ export class ESPLoader extends EventTarget {
             // Reset chip info and stub state
             this.__chipFamily = undefined;
             this.chipName = "Unknown Chip";
+            this.chipRevision = null;
+            this.chipVariant = null;
             this.IS_STUB = false;
             // Start read loop
             if (!this._parent) {
@@ -2582,6 +3104,98 @@ export class ESPLoader extends EventTarget {
             throw err;
         }
     }
+    /**
+     * @name exitConsoleMode
+     * Exit console mode and return to bootloader
+     * For ESP32-S2, uses reconnectToBootloader which will trigger port change
+     * @returns true if manual reconnection is needed (ESP32-S2), false otherwise
+     */
+    async exitConsoleMode() {
+        if (this._parent) {
+            return await this._parent.exitConsoleMode();
+        }
+        // Clear console mode flag
+        this._consoleMode = false;
+        // Check if this is ESP32-S2 with USB-JTAG/OTG
+        const isESP32S2 = this.chipFamily === CHIP_FAMILY_ESP32S2;
+        // For ESP32-S2: if _isUsbJtagOrOtg is undefined, try to detect it
+        // If detection fails or is undefined, assume USB-JTAG/OTG (conservative/safe path)
+        let isUsbJtagOrOtg = this._isUsbJtagOrOtg;
+        if (isESP32S2 && isUsbJtagOrOtg === undefined) {
+            try {
+                isUsbJtagOrOtg = await this.detectUsbConnectionType();
+            }
+            catch (err) {
+                this.logger.debug(`USB detection failed, assuming USB-JTAG/OTG for ESP32-S2: ${err}`);
+                isUsbJtagOrOtg = true; // Conservative fallback for ESP32-S2
+            }
+        }
+        if (isESP32S2 && isUsbJtagOrOtg) {
+            // ESP32-S2 USB: Use reconnectToBootloader which handles the mode switch
+            // This will close the port and the device will reboot to bootloader
+            this.logger.log("ESP32-S2 USB detected - reconnecting to bootloader");
+            try {
+                await this.reconnectToBootloader();
+            }
+            catch (err) {
+                this.logger.debug(`Reconnect error (expected for ESP32-S2): ${err}`);
+            }
+            // For ESP32-S2, port will change, so return true to indicate manual reconnection needed
+            return true;
+        }
+        // For other devices, use standard reconnectToBootloader
+        await this.reconnectToBootloader();
+        return false; // No manual reconnection needed
+    }
+    /**
+     * @name isConsoleResetSupported
+     * Check if console reset is supported for this device
+     * ESP32-S2 USB-JTAG/CDC does not support reset in console mode
+     * because any reset causes USB port to be lost (hardware limitation)
+     */
+    isConsoleResetSupported() {
+        if (this._parent) {
+            return this._parent.isConsoleResetSupported();
+        }
+        // For ESP32-S2: if _isUsbJtagOrOtg is undefined, assume USB-JTAG/OTG (conservative)
+        // This means console reset is NOT supported (safer default)
+        const isS2UsbJtag = this.chipFamily === CHIP_FAMILY_ESP32S2 &&
+            (this._isUsbJtagOrOtg === true || this._isUsbJtagOrOtg === undefined);
+        return !isS2UsbJtag; // Not supported for ESP32-S2 USB-JTAG/CDC
+    }
+    /**
+     * @name resetInConsoleMode
+     * Reset device while in console mode (firmware mode)
+     *
+     * NOTE: For ESP32-S2 USB-JTAG/CDC, ANY reset (hardware or software) causes
+     * the USB port to be lost because the device switches USB modes during reset.
+     * This is a hardware limitation - use isConsoleResetSupported() to check first.
+     */
+    async resetInConsoleMode() {
+        if (this._parent) {
+            return await this._parent.resetInConsoleMode();
+        }
+        if (!this.isConsoleResetSupported()) {
+            this.logger.debug("Console reset not supported for ESP32-S2 USB-JTAG/CDC");
+            return; // Do nothing
+        }
+        // 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();
+            }
+            this.logger.debug("Device reset complete");
+        }
+        catch (err) {
+            this.logger.error(`Reset failed: ${err}`);
+            throw err;
+        }
+    }
     /**
      * @name drainInputBuffer
      * Actively drain the input buffer by reading data for a specified time.
@@ -2596,7 +3210,7 @@ export class ESPLoader extends EventTarget {
         // Wait for the buffer to fill
         await sleep(bufferingTime);
         // Unsupported command response is sent 8 times and has
-        // 14 bytes length including delimiter 0xC0 bytes.
+        // 14 bytes length including delimiter SLIP_END (0xC0) bytes.
         // At least part of it is read as a command response,
         // but to be safe, read it all.
         const bytesToDrain = 14 * 8;
@@ -2651,9 +3265,13 @@ export class ESPLoader extends EventTarget {
      * @param addr - Address to read from
      * @param size - Number of bytes to read
      * @param onPacketReceived - Optional callback function called when packet is received
+     * @param options - Optional parameters for advanced control
+     *   - chunkSize: Amount of data to request from ESP in one command (bytes)
+     *   - blockSize: Size of each data block sent by ESP (bytes)
+     *   - maxInFlight: Maximum unacknowledged bytes (bytes)
      * @returns Uint8Array containing the flash data
      */
-    async readFlash(addr, size, onPacketReceived) {
+    async readFlash(addr, size, onPacketReceived, options) {
         if (!this.IS_STUB) {
             throw new Error("Reading flash is only supported in stub mode. Please run runStub() first.");
         }
@@ -2681,7 +3299,12 @@ export class ESPLoader extends EventTarget {
         // For WebUSB (Android), use smaller chunks to avoid timeouts and buffer issues
         // For Web Serial (Desktop), use larger chunks for better performance
         let CHUNK_SIZE;
-        if (this.isWebUSB()) {
+        if ((options === null || options === void 0 ? void 0 : options.chunkSize) !== undefined) {
+            // Use user-provided chunkSize if in advanced mode
+            CHUNK_SIZE = options.chunkSize;
+            this.logger.log(`Using custom chunk size: 0x${CHUNK_SIZE.toString(16)} bytes`);
+        }
+        else if (this.isWebUSB()) {
             // WebUSB: Use smaller chunks to avoid SLIP timeout issues
             CHUNK_SIZE = 0x4 * 0x1000; // 4KB = 16384 bytes
         }
@@ -2709,7 +3332,16 @@ export class ESPLoader extends EventTarget {
                     }
                     let blockSize;
                     let maxInFlight;
-                    if (this.isWebUSB()) {
+                    if ((options === null || options === void 0 ? void 0 : options.blockSize) !== undefined &&
+                        (options === null || options === void 0 ? void 0 : options.maxInFlight) !== undefined) {
+                        // Use user-provided values if in advanced mode
+                        blockSize = options.blockSize;
+                        maxInFlight = options.maxInFlight;
+                        if (retryCount === 0) {
+                            this.logger.debug(`Using custom parameters: blockSize=${blockSize}, maxInFlight=${maxInFlight}`);
+                        }
+                    }
+                    else if (this.isWebUSB()) {
                         // WebUSB (Android): All devices use adaptive speed
                         // All have maxTransferSize=64, baseBlockSize=31
                         const maxTransferSize = this.port.maxTransferSize || 64;
@@ -2742,7 +3374,7 @@ export class ESPLoader extends EventTarget {
                                 // The stub expects 4 bytes (ACK), if we send less it will break out
                                 try {
                                     // Send SLIP frame with no data (just delimiters)
-                                    const abortFrame = [0xc0, 0xc0]; // Empty SLIP frame
+                                    const abortFrame = [this.SLIP_END, this.SLIP_END]; // Empty SLIP frame
                                     await this.writeToStream(abortFrame);
                                     this.logger.debug(`Sent abort frame to stub`);
                                     // Give stub time to process abort
@@ -2847,7 +3479,7 @@ 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.log(`${err.message} at 0x${currentAddr.toString(16)}. Draining buffer and retrying (attempt ${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