esp32tool 1.1.9 → 1.3.0

package/dist/esp_loader.js

@@ -1,35 +1,158 @@
 /// <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_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, } 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";
-// @ts-expect-error pako ESM module doesn't have proper type definitions
-import { deflate } from "pako/dist/pako.esm.mjs";
+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;
         this.logger = logger;
         this._parent = _parent;
-        this.chipName = null;
-        this.chipRevision = null;
-        this.chipVariant = null;
+        this.__chipName = null;
+        this.__chipRevision = null;
+        this.__chipVariant = null;
         this._efuses = new Array(4).fill(0);
         this._flashsize = 4 * 1024 * 1024;
         this.debug = false;
         this.IS_STUB = false;
         this.connected = true;
         this.flashSize = null;
-        this._currentBaudRate = ESP_ROM_BAUD;
+        this.currentBaudRate = ESP_ROM_BAUD;
         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;
+        this.__consecutiveSuccessfulChunks = 0;
+        this.__lastAdaptiveAdjustment = 0;
+        this.__isCDCDevice = false;
         this.state_DTR = false;
+        this.state_RTS = false;
         this.__writeChain = Promise.resolve();
     }
+    // Chip properties with parent delegation
+    // chipFamily accessed before initialization as designed
+    get chipFamily() {
+        return this._parent ? this._parent.chipFamily : this.__chipFamily;
+    }
+    set chipFamily(value) {
+        if (this._parent) {
+            this._parent.chipFamily = value;
+        }
+        else {
+            this.__chipFamily = value;
+        }
+    }
+    get chipName() {
+        return this._parent ? this._parent.chipName : this.__chipName;
+    }
+    set chipName(value) {
+        if (this._parent) {
+            this._parent.chipName = value;
+        }
+        else {
+            this.__chipName = value;
+        }
+    }
+    get chipRevision() {
+        return this._parent ? this._parent.chipRevision : this.__chipRevision;
+    }
+    set chipRevision(value) {
+        if (this._parent) {
+            this._parent.chipRevision = value;
+        }
+        else {
+            this.__chipRevision = value;
+        }
+    }
+    get chipVariant() {
+        return this._parent ? this._parent.chipVariant : this.__chipVariant;
+    }
+    set chipVariant(value) {
+        if (this._parent) {
+            this._parent.chipVariant = value;
+        }
+        else {
+            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() {
-        return this._parent ? this._parent._inputBuffer : this.__inputBuffer;
+        if (this._parent) {
+            return this._parent._inputBuffer;
+        }
+        if (this.__inputBuffer === undefined) {
+            throw new Error("_inputBuffer accessed before initialization");
+        }
+        return this.__inputBuffer;
+    }
+    get _inputBufferReadIndex() {
+        return this._parent
+            ? this._parent._inputBufferReadIndex
+            : this.__inputBufferReadIndex || 0;
+    }
+    set _inputBufferReadIndex(value) {
+        if (this._parent) {
+            this._parent._inputBufferReadIndex = value;
+        }
+        else {
+            this.__inputBufferReadIndex = value;
+        }
+    }
+    // Get available bytes in buffer (from read index to end)
+    get _inputBufferAvailable() {
+        return this._inputBuffer.length - this._inputBufferReadIndex;
+    }
+    // Read one byte from buffer (ring-buffer style with index pointer)
+    _readByte() {
+        if (this._inputBufferReadIndex >= this._inputBuffer.length) {
+            return undefined;
+        }
+        return this._inputBuffer[this._inputBufferReadIndex++];
+    }
+    // Clear input buffer and reset read index
+    _clearInputBuffer() {
+        this._inputBuffer.length = 0;
+        this._inputBufferReadIndex = 0;
+    }
+    // Compact buffer when read index gets too large (prevent memory growth)
+    _compactInputBuffer() {
+        if (this._inputBufferReadIndex > 1000 &&
+            this._inputBufferReadIndex > this._inputBuffer.length / 2) {
+            // Remove already-read bytes and reset index
+            this._inputBuffer.splice(0, this._inputBufferReadIndex);
+            this._inputBufferReadIndex = 0;
+        }
     }
     get _totalBytesRead() {
         return this._parent
@@ -68,6 +191,82 @@ export class ESPLoader extends EventTarget {
             this.__isReconfiguring = value;
         }
     }
+    get _abandonCurrentOperation() {
+        return this._parent
+            ? this._parent._abandonCurrentOperation
+            : this.__abandonCurrentOperation;
+    }
+    set _abandonCurrentOperation(value) {
+        if (this._parent) {
+            this._parent._abandonCurrentOperation = value;
+        }
+        else {
+            this.__abandonCurrentOperation = value;
+        }
+    }
+    get _adaptiveBlockMultiplier() {
+        return this._parent
+            ? this._parent._adaptiveBlockMultiplier
+            : this.__adaptiveBlockMultiplier;
+    }
+    set _adaptiveBlockMultiplier(value) {
+        if (this._parent) {
+            this._parent._adaptiveBlockMultiplier = value;
+        }
+        else {
+            this.__adaptiveBlockMultiplier = value;
+        }
+    }
+    get _adaptiveMaxInFlightMultiplier() {
+        return this._parent
+            ? this._parent._adaptiveMaxInFlightMultiplier
+            : this.__adaptiveMaxInFlightMultiplier;
+    }
+    set _adaptiveMaxInFlightMultiplier(value) {
+        if (this._parent) {
+            this._parent._adaptiveMaxInFlightMultiplier = value;
+        }
+        else {
+            this.__adaptiveMaxInFlightMultiplier = value;
+        }
+    }
+    get _consecutiveSuccessfulChunks() {
+        return this._parent
+            ? this._parent._consecutiveSuccessfulChunks
+            : this.__consecutiveSuccessfulChunks;
+    }
+    set _consecutiveSuccessfulChunks(value) {
+        if (this._parent) {
+            this._parent._consecutiveSuccessfulChunks = value;
+        }
+        else {
+            this.__consecutiveSuccessfulChunks = value;
+        }
+    }
+    get _lastAdaptiveAdjustment() {
+        return this._parent
+            ? this._parent._lastAdaptiveAdjustment
+            : this.__lastAdaptiveAdjustment;
+    }
+    set _lastAdaptiveAdjustment(value) {
+        if (this._parent) {
+            this._parent._lastAdaptiveAdjustment = value;
+        }
+        else {
+            this.__lastAdaptiveAdjustment = value;
+        }
+    }
+    get _isCDCDevice() {
+        return this._parent ? this._parent._isCDCDevice : this.__isCDCDevice;
+    }
+    set _isCDCDevice(value) {
+        if (this._parent) {
+            this._parent._isCDCDevice = value;
+        }
+        else {
+            this.__isCDCDevice = value;
+        }
+    }
     detectUSBSerialChip(vendorId, productId) {
         // Common USB-Serial chip vendors and their products
         const chips = {
@@ -115,6 +314,7 @@ export class ESPLoader extends EventTarget {
     async initialize() {
         if (!this._parent) {
             this.__inputBuffer = [];
+            this.__inputBufferReadIndex = 0;
             this.__totalBytesRead = 0;
             // Detect and log USB-Serial chip info
             const portInfo = this.port.getInfo();
@@ -129,6 +329,12 @@ export class ESPLoader extends EventTarget {
                 if (portInfo.usbVendorId === 0x303a && portInfo.usbProductId === 0x2) {
                     this._isESP32S2NativeUSB = true;
                 }
+                // Detect CDC devices for adaptive speed adjustment
+                // Espressif Native USB (VID: 0x303a) or CH343 (VID: 0x1a86, PID: 0x55d3)
+                if (portInfo.usbVendorId === 0x303a ||
+                    (portInfo.usbVendorId === 0x1a86 && portInfo.usbProductId === 0x55d3)) {
+                    this._isCDCDevice = true;
+                }
             }
             // Don't await this promise so it doesn't block rest of method.
             this.readLoop();
@@ -137,6 +343,36 @@ 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 {
+            if (this.chipFamily === CHIP_FAMILY_ESP32S2 ||
+                this.chipFamily === CHIP_FAMILY_ESP32S3) {
+                const isUsingUsbOtg = await this.usingUsbOtg();
+                const isUsingUsbJtagSerial = await this.usingUsbJtagSerial();
+                this._isUsbJtagOrOtg = isUsingUsbOtg || isUsingUsbJtagSerial;
+            }
+            else if (this.chipFamily === CHIP_FAMILY_ESP32C3 ||
+                this.chipFamily === CHIP_FAMILY_ESP32C5 ||
+                this.chipFamily === CHIP_FAMILY_ESP32C6) {
+                const isUsingUsbJtagSerial = await this.usingUsbJtagSerial();
+                this._isUsbJtagOrOtg = isUsingUsbJtagSerial;
+            }
+            else if (this.chipFamily === CHIP_FAMILY_ESP32P4) {
+                const isUsingUsbOtg = await this.usingUsbOtg();
+                const isUsingUsbJtagSerial = await this.usingUsbJtagSerial();
+                this._isUsbJtagOrOtg = isUsingUsbOtg || isUsingUsbJtagSerial;
+            }
+            else {
+                // Other chips don't have USB-JTAG/OTG
+                this._isUsbJtagOrOtg = false;
+            }
+            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;
@@ -160,7 +396,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}`);
@@ -173,6 +409,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;
             }
@@ -185,7 +425,7 @@ export class ESPLoader extends EventTarget {
             // This ensures all error responses are cleared before continuing
             await this.drainInputBuffer(200);
             // Clear input buffer and re-sync to recover from failed command
-            this._inputBuffer.length = 0;
+            this._clearInputBuffer();
             await sleep(SYNC_TIMEOUT);
             // Re-sync with the chip to ensure clean communication
             try {
@@ -214,24 +454,31 @@ 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 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)
@@ -262,6 +509,18 @@ export class ESPLoader extends EventTarget {
             apiVersion,
         };
     }
+    /**
+     * Get MAC address from efuses
+     */
+    async getMacAddress() {
+        if (!this._initializationSucceeded) {
+            throw new Error("getMacAddress() requires initialize() to have completed successfully");
+        }
+        const macBytes = this.macAddr(); // chip-family-aware
+        return macBytes
+            .map((b) => b.toString(16).padStart(2, "0").toUpperCase())
+            .join(":");
+    }
     /**
      * @name readLoop
      * Reads data from the input stream and places it in the inputBuffer
@@ -292,7 +551,27 @@ export class ESPLoader extends EventTarget {
             }
         }
         catch {
-            this.logger.error("Read loop got disconnected");
+            // Don't log error if this is an expected disconnect during console mode transition
+            if (!this._consoleMode) {
+                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;
@@ -304,12 +583,19 @@ 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) {
         return new Promise((resolve) => setTimeout(resolve, ms));
     }
+    // ============================================================================
+    // Web Serial (Desktop) - DTR/RTS Signal Handling & Reset Strategies
+    // ============================================================================
     async setRTS(state) {
         await this.port.setSignals({ requestToSend: state });
         // Work-around for adapters on Windows using the usbser.sys driver:
@@ -322,24 +608,928 @@ export class ESPLoader extends EventTarget {
         this.state_DTR = state;
         await this.port.setSignals({ dataTerminalReady: state });
     }
+    async setDTRandRTS(dtr, rts) {
+        this.state_DTR = dtr;
+        this.state_RTS = rts;
+        await this.port.setSignals({
+            dataTerminalReady: dtr,
+            requestToSend: rts,
+        });
+    }
+    /**
+     * @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);
+    }
+    /**
+     * @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);
+    }
+    /**
+     * 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
+     */
+    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);
+    }
+    // ============================================================================
+    // WebUSB (Android) - DTR/RTS Signal Handling & Reset Strategies
+    // ============================================================================
+    async setRTSWebUSB(state) {
+        this.state_RTS = state;
+        // Always specify both signals to avoid flipping the other line
+        // The WebUSB setSignals() now preserves unspecified signals, but being explicit is safer
+        await this.port.setSignals({
+            requestToSend: state,
+            dataTerminalReady: this.state_DTR,
+        });
+    }
+    async setDTRWebUSB(state) {
+        this.state_DTR = state;
+        // Always specify both signals to avoid flipping the other line
+        await this.port.setSignals({
+            dataTerminalReady: state,
+            requestToSend: this.state_RTS, // Explicitly preserve current RTS state
+        });
+    }
+    async setDTRandRTSWebUSB(dtr, rts) {
+        this.state_DTR = dtr;
+        this.state_RTS = rts;
+        await this.port.setSignals({
+            dataTerminalReady: dtr,
+            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);
+    }
+    /**
+     * @name hardResetClassicLongDelayWebUSB
+     * Classic reset with longer delays for WebUSB (Android)
+     * 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
+    }
+    /**
+     * @name hardResetClassicShortDelayWebUSB
+     * Classic reset with shorter delays for WebUSB (Android)
+     */
+    async hardResetClassicShortDelayWebUSB() {
+        await this.setDTRWebUSB(false); // IO0=HIGH
+        await this.setRTSWebUSB(true); // EN=LOW, chip in reset
+        await this.sleep(50);
+        await this.setDTRWebUSB(true); // IO0=LOW
+        await this.setRTSWebUSB(false); // EN=HIGH, chip out of reset
+        await this.sleep(25);
+        await this.setDTRWebUSB(false); // IO0=HIGH, done
+        await this.sleep(100);
+    }
+    /**
+     * @name hardResetInvertedWebUSB
+     * Inverted reset sequence for WebUSB (Android) - both signals inverted
+     */
+    async hardResetInvertedWebUSB() {
+        await this.setDTRWebUSB(true); // IO0=HIGH (inverted)
+        await this.setRTSWebUSB(false); // EN=LOW, chip in reset (inverted)
+        await this.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 this.setDTRWebUSB(true); // IO0=HIGH, done (inverted)
+        await this.sleep(200);
+    }
+    /**
+     * @name hardResetInvertedDTRWebUSB
+     * Only DTR inverted for WebUSB (Android)
+     */
+    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 this.setDTRWebUSB(false); // IO0=LOW (DTR inverted)
+        await this.setRTSWebUSB(false); // EN=HIGH, chip out of reset (RTS normal)
+        await this.sleep(50);
+        await this.setDTRWebUSB(true); // IO0=HIGH, done (DTR inverted)
+        await this.sleep(200);
+    }
+    /**
+     * @name hardResetInvertedRTSWebUSB
+     * Only RTS inverted for WebUSB (Android)
+     */
+    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 this.setDTRWebUSB(true); // IO0=LOW (DTR normal)
+        await this.setRTSWebUSB(true); // EN=HIGH, chip out of reset (RTS inverted)
+        await this.sleep(50);
+        await this.setDTRWebUSB(false); // IO0=HIGH, done (DTR normal)
+        await this.sleep(200);
+    }
+    /**
+     * Check if we're using WebUSB (Android) or Web Serial (Desktop)
+     */
+    isWebUSB() {
+        // WebUSBSerial class has isWebUSB flag - this is the most reliable check
+        return this.port.isWebUSB === true;
+    }
+    /**
+     * @name connectWithResetStrategies
+     * Try different reset strategies to enter bootloader mode
+     * Similar to esptool.py's connect() method with multiple reset strategies
+     */
+    async connectWithResetStrategies() {
+        const portInfo = this.port.getInfo();
+        const isUSBJTAGSerial = portInfo.usbProductId === USB_JTAG_SERIAL_PID;
+        const isEspressifUSB = portInfo.usbVendorId === 0x303a;
+        //    this.logger.log(
+        //      `Detected USB: VID=0x${portInfo.usbVendorId?.toString(16) || "unknown"}, PID=0x${portInfo.usbProductId?.toString(16) || "unknown"}`,
+        //    );
+        // Define reset strategies to try in order
+        const resetStrategies = [];
+        // eslint-disable-next-line @typescript-eslint/no-this-alias
+        const self = this;
+        // Detect if this is a USB-Serial chip (needs different sync approach)
+        const isUSBSerialChip = !isUSBJTAGSerial && !isEspressifUSB;
+        // WebUSB (Android) uses different reset methods than Web Serial (Desktop)
+        if (this.isWebUSB()) {
+            // For USB-Serial chips (CP2102, CH340, etc.), try inverted strategies first
+            // Detect specific chip types once
+            const isCP2102 = portInfo.usbVendorId === 0x10c4;
+            const isCH34x = portInfo.usbVendorId === 0x1a86;
+            // Check for ESP32-S2 Native USB (VID: 0x303a, PID: 0x0002)
+            const isESP32S2NativeUSB = portInfo.usbVendorId === 0x303a && portInfo.usbProductId === 0x0002;
+            // WebUSB Strategy 1: USB-JTAG/Serial reset (for Native USB only)
+            if (isUSBJTAGSerial || isEspressifUSB) {
+                if (isESP32S2NativeUSB) {
+                    // ESP32-S2 Native USB: Try multiple strategies
+                    // The device might be in JTAG mode OR CDC mode
+                    // Strategy 1: USB-JTAG/Serial (works in CDC mode on Desktop)
+                    resetStrategies.push({
+                        name: "USB-JTAG/Serial (WebUSB) - ESP32-S2",
+                        fn: async () => {
+                            return await self.hardResetUSBJTAGSerialWebUSB();
+                        },
+                    });
+                    // Strategy 2: USB-JTAG/Serial Inverted DTR (works in JTAG mode)
+                    resetStrategies.push({
+                        name: "USB-JTAG/Serial Inverted DTR (WebUSB) - ESP32-S2",
+                        fn: async () => {
+                            return await self.hardResetUSBJTAGSerialInvertedDTRWebUSB();
+                        },
+                    });
+                    // Strategy 3: UnixTight (CDC fallback)
+                    resetStrategies.push({
+                        name: "UnixTight (WebUSB) - ESP32-S2 CDC",
+                        fn: async () => {
+                            return await self.hardResetUnixTightWebUSB();
+                        },
+                    });
+                    // Strategy 4: Classic reset (CDC fallback)
+                    resetStrategies.push({
+                        name: "Classic (WebUSB) - ESP32-S2 CDC",
+                        fn: async () => {
+                            return await self.hardResetClassicWebUSB();
+                        },
+                    });
+                }
+                else {
+                    // Other USB-JTAG chips: Try Inverted DTR first - works best for ESP32-H2 and other JTAG chips
+                    resetStrategies.push({
+                        name: "USB-JTAG/Serial Inverted DTR (WebUSB)",
+                        fn: async () => {
+                            return await self.hardResetUSBJTAGSerialInvertedDTRWebUSB();
+                        },
+                    });
+                    resetStrategies.push({
+                        name: "USB-JTAG/Serial (WebUSB)",
+                        fn: async () => {
+                            return await self.hardResetUSBJTAGSerialWebUSB();
+                        },
+                    });
+                    resetStrategies.push({
+                        name: "Inverted DTR Classic (WebUSB)",
+                        fn: async () => {
+                            return await self.hardResetInvertedDTRWebUSB();
+                        },
+                    });
+                }
+            }
+            // For USB-Serial chips, try inverted strategies first
+            if (isUSBSerialChip) {
+                if (isCH34x) {
+                    // CH340/CH343: UnixTight works best (like CP2102)
+                    resetStrategies.push({
+                        name: "UnixTight (WebUSB) - CH34x",
+                        fn: async () => {
+                            return await self.hardResetUnixTightWebUSB();
+                        },
+                    });
+                    resetStrategies.push({
+                        name: "Classic (WebUSB) - CH34x",
+                        fn: async () => {
+                            return await self.hardResetClassicWebUSB();
+                        },
+                    });
+                    resetStrategies.push({
+                        name: "Inverted Both (WebUSB) - CH34x",
+                        fn: async () => {
+                            return await self.hardResetInvertedWebUSB();
+                        },
+                    });
+                    resetStrategies.push({
+                        name: "Inverted RTS (WebUSB) - CH34x",
+                        fn: async () => {
+                            return await self.hardResetInvertedRTSWebUSB();
+                        },
+                    });
+                    resetStrategies.push({
+                        name: "Inverted DTR (WebUSB) - CH34x",
+                        fn: async () => {
+                            return await self.hardResetInvertedDTRWebUSB();
+                        },
+                    });
+                }
+                else if (isCP2102) {
+                    // CP2102: UnixTight works best (tested and confirmed)
+                    // Try it first, then fallback to other strategies
+                    resetStrategies.push({
+                        name: "UnixTight (WebUSB) - CP2102",
+                        fn: async () => {
+                            return await self.hardResetUnixTightWebUSB();
+                        },
+                    });
+                    resetStrategies.push({
+                        name: "Classic (WebUSB) - CP2102",
+                        fn: async () => {
+                            return await self.hardResetClassicWebUSB();
+                        },
+                    });
+                    resetStrategies.push({
+                        name: "Inverted Both (WebUSB) - CP2102",
+                        fn: async () => {
+                            return await self.hardResetInvertedWebUSB();
+                        },
+                    });
+                    resetStrategies.push({
+                        name: "Inverted RTS (WebUSB) - CP2102",
+                        fn: async () => {
+                            return await self.hardResetInvertedRTSWebUSB();
+                        },
+                    });
+                    resetStrategies.push({
+                        name: "Inverted DTR (WebUSB) - CP2102",
+                        fn: async () => {
+                            return await self.hardResetInvertedDTRWebUSB();
+                        },
+                    });
+                }
+                else {
+                    // For other USB-Serial chips, try UnixTight first, then multiple strategies
+                    resetStrategies.push({
+                        name: "UnixTight (WebUSB)",
+                        fn: async () => {
+                            return await self.hardResetUnixTightWebUSB();
+                        },
+                    });
+                    resetStrategies.push({
+                        name: "Classic (WebUSB)",
+                        fn: async function () {
+                            return await self.hardResetClassicWebUSB();
+                        },
+                    });
+                    resetStrategies.push({
+                        name: "Inverted Both (WebUSB)",
+                        fn: async function () {
+                            return await self.hardResetInvertedWebUSB();
+                        },
+                    });
+                    resetStrategies.push({
+                        name: "Inverted RTS (WebUSB)",
+                        fn: async function () {
+                            return await self.hardResetInvertedRTSWebUSB();
+                        },
+                    });
+                    resetStrategies.push({
+                        name: "Inverted DTR (WebUSB)",
+                        fn: async function () {
+                            return await self.hardResetInvertedDTRWebUSB();
+                        },
+                    });
+                }
+            }
+            // Add general fallback strategies only for non-CP2102 and non-ESP32-S2 Native USB chips
+            if (!isCP2102 && !isESP32S2NativeUSB) {
+                // Classic reset (for chips not handled above)
+                if (portInfo.usbVendorId !== 0x1a86) {
+                    resetStrategies.push({
+                        name: "Classic (WebUSB)",
+                        fn: async function () {
+                            return await self.hardResetClassicWebUSB();
+                        },
+                    });
+                }
+                // UnixTight reset (sets DTR/RTS simultaneously)
+                resetStrategies.push({
+                    name: "UnixTight (WebUSB)",
+                    fn: async function () {
+                        return await self.hardResetUnixTightWebUSB();
+                    },
+                });
+                // WebUSB Strategy: Classic with long delays
+                resetStrategies.push({
+                    name: "Classic Long Delay (WebUSB)",
+                    fn: async function () {
+                        return await self.hardResetClassicLongDelayWebUSB();
+                    },
+                });
+                // WebUSB Strategy: Classic with short delays
+                resetStrategies.push({
+                    name: "Classic Short Delay (WebUSB)",
+                    fn: async function () {
+                        return await self.hardResetClassicShortDelayWebUSB();
+                    },
+                });
+                // WebUSB Strategy: USB-JTAG/Serial fallback
+                if (!isUSBJTAGSerial && !isEspressifUSB) {
+                    resetStrategies.push({
+                        name: "USB-JTAG/Serial fallback (WebUSB)",
+                        fn: async function () {
+                            return await self.hardResetUSBJTAGSerialWebUSB();
+                        },
+                    });
+                }
+            }
+        }
+        else {
+            // Strategy: USB-JTAG/Serial reset
+            if (isUSBJTAGSerial || isEspressifUSB) {
+                resetStrategies.push({
+                    name: "USB-JTAG/Serial",
+                    fn: async function () {
+                        return await self.hardResetUSBJTAGSerial();
+                    },
+                });
+            }
+            // Strategy: UnixTight reset
+            resetStrategies.push({
+                name: "UnixTight",
+                fn: async function () {
+                    return await self.hardResetUnixTight();
+                },
+            });
+            // Strategy: USB-JTAG/Serial fallback
+            if (!isUSBJTAGSerial && !isEspressifUSB) {
+                resetStrategies.push({
+                    name: "USB-JTAG/Serial (fallback)",
+                    fn: async function () {
+                        return await self.hardResetUSBJTAGSerial();
+                    },
+                });
+            }
+        }
+        let lastError = null;
+        // Try each reset strategy with timeout
+        for (const strategy of resetStrategies) {
+            try {
+                // Check if port is still open, if not, skip this strategy
+                if (!this.connected || !this.port.writable) {
+                    this.logger.debug(`Port disconnected, skipping ${strategy.name} reset`);
+                    continue;
+                }
+                // Clear abandon flag before starting new strategy
+                this._abandonCurrentOperation = false;
+                await strategy.fn();
+                // Try to sync after reset
+                // USB-Serial / native USB chips needs different sync approaches
+                if (isUSBSerialChip) {
+                    // USB-Serial chips: Use timeout strategy (2 seconds)
+                    //          this.logger.log(`USB-Serial chip detected, using sync with timeout.`);
+                    const syncSuccess = await this.syncWithTimeout(2000);
+                    if (syncSuccess) {
+                        // Sync succeeded
+                        this.logger.log(`Connected USB Serial successfully with ${strategy.name} reset.`);
+                        return;
+                    }
+                    else {
+                        throw new Error("Sync timeout or abandoned");
+                    }
+                }
+                else {
+                    // Native USB chips
+                    // Note: We use Promise.race with sync() directly instead of syncWithTimeout()
+                    // because syncWithTimeout causes CDC/JTAG devices to hang for unknown reasons.
+                    // The abandon flag in readPacket() prevents overlapping I/O.
+                    //          this.logger.log(`Native USB chip detected, using CDC/JTAG sync.`);
+                    const syncPromise = this.sync();
+                    const timeoutPromise = new Promise((_, reject) => setTimeout(() => reject(new Error("Sync timeout")), 1000));
+                    try {
+                        await Promise.race([syncPromise, timeoutPromise]);
+                        // Sync succeeded
+                        this.logger.log(`Connected CDC/JTAG successfully with ${strategy.name} reset.`);
+                        return;
+                    }
+                    catch (error) {
+                        throw new Error("Sync timeout or abandoned");
+                    }
+                }
+            }
+            catch (error) {
+                lastError = error;
+                this.logger.debug(`${strategy.name} reset failed: ${error.message}`);
+                // Set abandon flag to stop any in-flight operations
+                this._abandonCurrentOperation = true;
+                // Wait a bit for in-flight operations to abort
+                await sleep(100);
+                // If port got disconnected, we can't try more strategies
+                if (!this.connected || !this.port.writable) {
+                    this.logger.log(`Port disconnected during reset attempt`);
+                    break;
+                }
+                // Clear buffers before trying next strategy
+                this._clearInputBuffer();
+                await this.drainInputBuffer(200);
+                await this.flushSerialBuffers();
+            }
+        }
+        // All strategies failed - reset abandon flag before throwing
+        this._abandonCurrentOperation = false;
+        throw new Error(`Couldn't sync to ESP. Try resetting manually. Last error: ${lastError === null || lastError === void 0 ? void 0 : lastError.message}`);
+    }
+    /**
+     * @name watchdogReset
+     * 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() {
+        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;
+        this.logger.debug(`ESP32-C3 revision: ${revision}`);
+        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;
+        let WDT_WKEY;
+        if (this.chipFamily === CHIP_FAMILY_ESP32S2) {
+            WDTWPROTECT_REG = ESP32S2_RTC_CNTL_WDTWPROTECT_REG;
+            WDTCONFIG0_REG = ESP32S2_RTC_CNTL_WDTCONFIG0_REG;
+            WDTCONFIG1_REG = ESP32S2_RTC_CNTL_WDTCONFIG1_REG;
+            WDT_WKEY = ESP32S2_RTC_CNTL_WDT_WKEY;
+        }
+        else if (this.chipFamily === CHIP_FAMILY_ESP32S3) {
+            WDTWPROTECT_REG = ESP32S3_RTC_CNTL_WDTWPROTECT_REG;
+            WDTCONFIG0_REG = ESP32S3_RTC_CNTL_WDTCONFIG0_REG;
+            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(`rtcWdtResetChipSpecific() is not supported for ${this.chipFamily}`);
+        }
+        // Unlock watchdog registers
+        await this.writeRegister(WDTWPROTECT_REG, WDT_WKEY, undefined, 0);
+        // 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;
+        await this.writeRegister(WDTCONFIG0_REG, wdtConfig, undefined, 0);
+        // Lock watchdog registers
+        await this.writeRegister(WDTWPROTECT_REG, 0, undefined, 0);
+        // 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 {
-                await this.hardResetClassic();
-                this.logger.log("Classic reset.");
+                // 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.");
+                }
             }
         }
         else {
-            // just reset
-            await this.setRTS(true); // EN->LOW
-            await this.sleep(100);
-            await this.setRTS(false);
-            this.logger.log("Hard reset.");
+            // just reset (no bootloader mode)
+            // 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;
+            }
+            // 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).");
+            }
+            else {
+                // Web Serial: Standard reset
+                await this.setRTS(true); // EN->LOW
+                await this.sleep(100);
+                await this.setRTS(false);
+                this.logger.debug("Hard reset.");
+            }
         }
         await new Promise((resolve) => setTimeout(resolve, 1000));
     }
@@ -464,6 +1654,12 @@ export class ESPLoader extends EventTarget {
                 else if ([2, 4].includes(data.length)) {
                     statusLen = data.length;
                 }
+                else {
+                    // Default to 2-byte status if we can't determine
+                    // This prevents silent data corruption when statusLen would be 0
+                    statusLen = 2;
+                    this.logger.debug(`Unknown chip family, defaulting to 2-byte status (opcode: ${toHex(opcode)}, data.length: ${data.length})`);
+                }
             }
             if (data.length < statusLen) {
                 throw new Error("Didn't get enough status bytes");
@@ -512,76 +1708,169 @@ export class ESPLoader extends EventTarget {
      * @name readPacket
      * Generator to read SLIP packets from a serial port.
      * Yields one full SLIP packet at a time, raises exception on timeout or invalid data.
+     *
+     * Two implementations:
+     * - Burst: CDC devices (Native USB) and CH343 - very fast processing
+     * - Byte-by-byte: CH340, CP2102, and other USB-Serial adapters - stable fast processing
      */
     async readPacket(timeout) {
         let partialPacket = null;
         let inEscape = false;
-        let readBytes = [];
-        while (true) {
-            const stamp = Date.now();
-            readBytes = [];
-            while (Date.now() - stamp < timeout) {
-                if (this._inputBuffer.length > 0) {
-                    readBytes.push(this._inputBuffer.shift());
-                    break;
+        // CDC devices use burst processing, non-CDC use byte-by-byte
+        if (this._isCDCDevice) {
+            // Burst version: Process all available bytes in one pass for ultra-high-speed transfers
+            // Used for: CDC devices (all platforms) and CH343
+            const startTime = Date.now();
+            while (true) {
+                // Check abandon flag (for reset strategy timeout)
+                if (this._abandonCurrentOperation) {
+                    throw new SlipReadError("Operation abandoned (reset strategy timeout)");
                 }
-                else {
-                    // Reduced sleep time for faster response during high-speed transfers
+                // Check timeout
+                if (Date.now() - startTime > timeout) {
+                    const waitingFor = partialPacket === null ? "header" : "content";
+                    throw new SlipReadError("Timed out waiting for packet " + waitingFor);
+                }
+                // If no data available, wait a bit
+                if (this._inputBufferAvailable === 0) {
                     await sleep(1);
+                    continue;
                 }
-            }
-            if (readBytes.length == 0) {
-                const waitingFor = partialPacket === null ? "header" : "content";
-                throw new SlipReadError("Timed out waiting for packet " + waitingFor);
-            }
-            if (this.debug)
-                this.logger.debug("Read " + readBytes.length + " bytes: " + hexFormatter(readBytes));
-            for (const b of readBytes) {
-                if (partialPacket === null) {
-                    // waiting for packet header
-                    if (b == 0xc0) {
-                        partialPacket = [];
+                // Process all available bytes without going back to outer loop
+                // This is critical for handling high-speed burst transfers
+                while (this._inputBufferAvailable > 0) {
+                    // Periodic timeout check to prevent hang on slow data
+                    if (Date.now() - startTime > timeout) {
+                        const waitingFor = partialPacket === null ? "header" : "content";
+                        throw new SlipReadError("Timed out waiting for packet " + waitingFor);
                     }
-                    else {
-                        if (this.debug) {
-                            this.logger.debug("Read invalid data: " + toHex(b));
-                            this.logger.debug("Remaining data in serial buffer: " +
-                                hexFormatter(this._inputBuffer));
+                    const b = this._readByte();
+                    if (partialPacket === null) {
+                        // waiting for packet header
+                        if (b == 0xc0) {
+                            partialPacket = [];
+                        }
+                        else {
+                            if (this.debug) {
+                                this.logger.debug("Read invalid data: " + toHex(b));
+                                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(b) + ")");
                     }
-                }
-                else if (inEscape) {
-                    // part-way through escape sequence
-                    inEscape = false;
-                    if (b == 0xdc) {
-                        partialPacket.push(0xc0);
+                    else if (inEscape) {
+                        // part-way through escape sequence
+                        inEscape = false;
+                        if (b == 0xdc) {
+                            partialPacket.push(0xc0);
+                        }
+                        else if (b == 0xdd) {
+                            partialPacket.push(0xdb);
+                        }
+                        else {
+                            if (this.debug) {
+                                this.logger.debug("Read invalid data: " + toHex(b));
+                                this.logger.debug("Remaining data in serial buffer: " +
+                                    hexFormatter(this._inputBuffer));
+                            }
+                            throw new SlipReadError("Invalid SLIP escape (0xdb, " + toHex(b) + ")");
+                        }
                     }
-                    else if (b == 0xdd) {
-                        partialPacket.push(0xdb);
+                    else if (b == 0xdb) {
+                        // start of escape sequence
+                        inEscape = true;
+                    }
+                    else if (b == 0xc0) {
+                        // end of packet
+                        if (this.debug)
+                            this.logger.debug("Received full packet: " + hexFormatter(partialPacket));
+                        // Compact buffer periodically to prevent memory growth
+                        this._compactInputBuffer();
+                        return partialPacket;
                     }
                     else {
-                        if (this.debug) {
-                            this.logger.debug("Read invalid data: " + toHex(b));
-                            this.logger.debug("Remaining data in serial buffer: " +
-                                hexFormatter(this._inputBuffer));
-                        }
-                        throw new SlipReadError("Invalid SLIP escape (0xdb, " + toHex(b) + ")");
+                        // normal byte in packet
+                        partialPacket.push(b);
                     }
                 }
-                else if (b == 0xdb) {
-                    // start of escape sequence
-                    inEscape = true;
+            }
+        }
+        else {
+            // Byte-by-byte version: Stable for non CDC USB-Serial adapters (CH340, CP2102, etc.)
+            let readBytes = [];
+            while (true) {
+                // Check abandon flag (for reset strategy timeout)
+                if (this._abandonCurrentOperation) {
+                    throw new SlipReadError("Operation abandoned (reset strategy timeout)");
                 }
-                else if (b == 0xc0) {
-                    // end of packet
-                    if (this.debug)
-                        this.logger.debug("Received full packet: " + hexFormatter(partialPacket));
-                    return partialPacket;
+                const stamp = Date.now();
+                readBytes = [];
+                while (Date.now() - stamp < timeout) {
+                    if (this._inputBufferAvailable > 0) {
+                        readBytes.push(this._readByte());
+                        break;
+                    }
+                    else {
+                        // Reduced sleep time for faster response during high-speed transfers
+                        await sleep(1);
+                    }
                 }
-                else {
-                    // normal byte in packet
-                    partialPacket.push(b);
+                if (readBytes.length == 0) {
+                    const waitingFor = partialPacket === null ? "header" : "content";
+                    throw new SlipReadError("Timed out waiting for packet " + waitingFor);
+                }
+                if (this.debug)
+                    this.logger.debug("Read " + readBytes.length + " bytes: " + hexFormatter(readBytes));
+                for (const b of readBytes) {
+                    if (partialPacket === null) {
+                        // waiting for packet header
+                        if (b == 0xc0) {
+                            partialPacket = [];
+                        }
+                        else {
+                            if (this.debug) {
+                                this.logger.debug("Read invalid data: " + toHex(b));
+                                this.logger.debug("Remaining data in serial buffer: " +
+                                    hexFormatter(this._inputBuffer));
+                            }
+                            throw new SlipReadError("Invalid head of packet (" + toHex(b) + ")");
+                        }
+                    }
+                    else if (inEscape) {
+                        // part-way through escape sequence
+                        inEscape = false;
+                        if (b == 0xdc) {
+                            partialPacket.push(0xc0);
+                        }
+                        else if (b == 0xdd) {
+                            partialPacket.push(0xdb);
+                        }
+                        else {
+                            if (this.debug) {
+                                this.logger.debug("Read invalid data: " + toHex(b));
+                                this.logger.debug("Remaining data in serial buffer: " +
+                                    hexFormatter(this._inputBuffer));
+                            }
+                            throw new SlipReadError("Invalid SLIP escape (0xdb, " + toHex(b) + ")");
+                        }
+                    }
+                    else if (b == 0xdb) {
+                        // start of escape sequence
+                        inEscape = true;
+                    }
+                    else if (b == 0xc0) {
+                        // end of packet
+                        if (this.debug)
+                            this.logger.debug("Received full packet: " + hexFormatter(partialPacket));
+                        // Compact buffer periodically to prevent memory growth
+                        this._compactInputBuffer();
+                        return partialPacket;
+                    }
+                    else {
+                        // normal byte in packet
+                        partialPacket.push(b);
+                    }
                 }
             }
         }
@@ -613,7 +1902,7 @@ export class ESPLoader extends EventTarget {
                 throw new Error(`Invalid (unsupported) command ${toHex(opcode)}`);
             }
         }
-        throw "Response doesn't match request";
+        throw new Error("Response doesn't match request");
     }
     /**
      * @name checksum
@@ -626,9 +1915,6 @@ export class ESPLoader extends EventTarget {
         return state;
     }
     async setBaudrate(baud) {
-        if (this.chipFamily == CHIP_FAMILY_ESP8266) {
-            throw new Error("Changing baud rate is not supported on the ESP8266");
-        }
         try {
             // Send ESP_ROM_BAUD(115200) as the old one if running STUB otherwise 0
             const buffer = pack("<II", baud, this.IS_STUB ? ESP_ROM_BAUD : 0);
@@ -648,10 +1934,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
@@ -665,6 +1951,8 @@ export class ESPLoader extends EventTarget {
     }
     async reconfigurePort(baud) {
         var _a;
+        // Block new writes during the entire reconfiguration (all paths)
+        this._isReconfiguring = true;
         try {
             // Wait for pending writes to complete
             try {
@@ -673,8 +1961,30 @@ export class ESPLoader extends EventTarget {
             catch (err) {
                 this.logger.debug(`Pending write error during reconfigure: ${err}`);
             }
-            // Block new writes during port close/open
-            this._isReconfiguring = true;
+            // WebUSB: Check if we should use setBaudRate() or close/reopen
+            if (this.isWebUSB()) {
+                const portInfo = this.port.getInfo();
+                const isCH343 = portInfo.usbVendorId === 0x1a86 && portInfo.usbProductId === 0x55d3;
+                // CH343 is a CDC device and MUST use close/reopen
+                // Other chips (CH340, CP2102, FTDI) MUST use setBaudRate()
+                if (!isCH343 &&
+                    typeof this.port.setBaudRate === "function") {
+                    //          this.logger.log(
+                    //            `[WebUSB] Changing baudrate to ${baud} using setBaudRate()...`,
+                    //          );
+                    await this.port.setBaudRate(baud);
+                    //          this.logger.log(`[WebUSB] Baudrate changed to ${baud}`);
+                    // Give the chip time to adjust to new baudrate
+                    await sleep(100);
+                    return;
+                }
+                else if (isCH343) {
+                    //          this.logger.log(
+                    //            `[WebUSB] CH343 detected - using close/reopen for baudrate change`,
+                    //          );
+                }
+            }
+            // Web Serial or CH343: Close and reopen port
             // Release persistent writer before closing
             if (this._writer) {
                 try {
@@ -693,120 +2003,54 @@ export class ESPLoader extends EventTarget {
             await this.port.close();
             // Reopen Port
             await this.port.open({ baudRate: baud });
-            // Port is now open - allow writes again
-            this._isReconfiguring = false;
             // Clear buffer again
             await this.flushSerialBuffers();
             // Restart Readloop
             this.readLoop();
         }
         catch (e) {
-            this._isReconfiguring = false;
             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
+            this._isReconfiguring = false;
+        }
     }
     /**
-     * @name connectWithResetStrategies
-     * Try different reset strategies to enter bootloader mode
-     * Similar to esptool.py's connect() method with multiple reset strategies
-     */
-    async connectWithResetStrategies() {
-        var _a, _b;
-        const portInfo = this.port.getInfo();
-        const isUSBJTAGSerial = portInfo.usbProductId === USB_JTAG_SERIAL_PID;
-        const isEspressifUSB = portInfo.usbVendorId === 0x303a;
-        this.logger.log(`Detected USB: VID=0x${((_a = portInfo.usbVendorId) === null || _a === void 0 ? void 0 : _a.toString(16)) || "unknown"}, PID=0x${((_b = portInfo.usbProductId) === null || _b === void 0 ? void 0 : _b.toString(16)) || "unknown"}`);
-        // Define reset strategies to try in order
-        const resetStrategies = [];
-        // Strategy 1: USB-JTAG/Serial reset (for ESP32-C3, C6, S3, etc.)
-        // Try this first if we detect Espressif USB VID or the specific PID
-        if (isUSBJTAGSerial || isEspressifUSB) {
-            resetStrategies.push({
-                name: "USB-JTAG/Serial",
-                fn: async () => await this.hardResetUSBJTAGSerial(),
-            });
-        }
-        // Strategy 2: Classic reset (for USB-to-Serial bridges)
-        resetStrategies.push({
-            name: "Classic",
-            fn: async () => await this.hardResetClassic(),
-        });
-        // Strategy 3: If USB-JTAG/Serial was not tried yet, try it as fallback
-        if (!isUSBJTAGSerial && !isEspressifUSB) {
-            resetStrategies.push({
-                name: "USB-JTAG/Serial (fallback)",
-                fn: async () => await this.hardResetUSBJTAGSerial(),
-            });
-        }
-        let lastError = null;
-        // Try each reset strategy
-        for (const strategy of resetStrategies) {
+     * @name syncWithTimeout
+     * Sync with timeout that can be abandoned (for reset strategy loop)
+     * This is internally time-bounded and checks the abandon flag
+     */
+    async syncWithTimeout(timeoutMs) {
+        const startTime = Date.now();
+        for (let i = 0; i < 5; i++) {
+            // Check if we've exceeded the timeout
+            if (Date.now() - startTime > timeoutMs) {
+                return false;
+            }
+            // Check abandon flag
+            if (this._abandonCurrentOperation) {
+                return false;
+            }
+            this._clearInputBuffer();
             try {
-                this.logger.log(`Trying ${strategy.name} reset...`);
-                // 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`);
-                    continue;
+                const response = await this._sync();
+                if (response) {
+                    await sleep(SYNC_TIMEOUT);
+                    return true;
                 }
-                await strategy.fn();
-                // Try to sync after reset
-                await this.sync();
-                // If we get here, sync succeeded
-                this.logger.log(`Connected successfully with ${strategy.name} reset.`);
-                return;
+                // eslint-disable-next-line @typescript-eslint/no-unused-vars
             }
-            catch (error) {
-                lastError = error;
-                this.logger.log(`${strategy.name} reset failed: ${error.message}`);
-                // If port got disconnected, we can't try more strategies
-                if (!this.connected || !this.port.writable) {
-                    this.logger.log(`Port disconnected during reset attempt`);
-                    break;
+            catch (e) {
+                // Check abandon flag after error
+                if (this._abandonCurrentOperation) {
+                    return false;
                 }
-                // Clear buffers before trying next strategy
-                this._inputBuffer.length = 0;
-                await this.drainInputBuffer(200);
-                await this.flushSerialBuffers();
             }
+            await sleep(SYNC_TIMEOUT);
         }
-        // All strategies failed
-        throw new Error(`Couldn't sync to ESP. Try resetting manually. Last error: ${lastError === null || lastError === void 0 ? void 0 : lastError.message}`);
-    }
-    /**
-     * @name hardResetUSBJTAGSerial
-     * USB-JTAG/Serial reset sequence for ESP32-C3, ESP32-S3, ESP32-C6, etc.
-     */
-    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. Calls inverted to go through (1,1) instead of (0,0)
-        await this.setDTR(false);
-        await this.setRTS(true); // RTS set as Windows only propagates DTR on RTS setting
-        await this.sleep(100);
-        await this.setDTR(false);
-        await this.setRTS(false); // Chip out of reset
-        // Wait for chip to boot into bootloader
-        await this.sleep(200);
-    }
-    /**
-     * @name hardResetClassic
-     * Classic reset sequence for USB-to-Serial bridge chips (CH340, CP2102, etc.)
-     */
-    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
-        // Wait for chip to boot into bootloader
-        await this.sleep(200);
+        return false;
     }
     /**
      * @name sync
@@ -815,7 +2059,7 @@ export class ESPLoader extends EventTarget {
      */
     async sync() {
         for (let i = 0; i < 5; i++) {
-            this._inputBuffer.length = 0;
+            this._clearInputBuffer();
             const response = await this._sync();
             if (response) {
                 await sleep(SYNC_TIMEOUT);
@@ -839,8 +2083,10 @@ export class ESPLoader extends EventTarget {
                     return true;
                 }
             }
-            catch {
-                // If read packet fails.
+            catch (e) {
+                if (this.debug) {
+                    this.logger.debug(`Sync attempt ${i + 1} failed: ${e}`);
+                }
             }
         }
         return false;
@@ -975,7 +2221,7 @@ export class ESPLoader extends EventTarget {
             await this.checkCommand(ESP_SPI_ATTACH, new Array(8).fill(0));
         }
         const numBlocks = Math.floor((size + flashWriteSize - 1) / flashWriteSize);
-        if (this.chipFamily == CHIP_FAMILY_ESP8266) {
+        if (this.chipFamily == CHIP_FAMILY_ESP8266 && !this.IS_STUB) {
             eraseSize = this.getEraseSize(offset, size);
         }
         else {
@@ -1315,12 +2561,19 @@ export class ESPLoader extends EventTarget {
             await this._writer.write(new Uint8Array(data));
         }, async () => {
             // Previous write failed, but still attempt this write
+            this.logger.debug("Previous write failed, attempting recovery for current write");
             if (!this.port.writable) {
                 throw new Error("Port became unavailable during write");
             }
             // Writer was likely cleaned up by previous error, create new one
             if (!this._writer) {
-                this._writer = this.port.writable.getWriter();
+                try {
+                    this._writer = this.port.writable.getWriter();
+                }
+                catch (err) {
+                    this.logger.debug(`Failed to get writer in recovery: ${err}`);
+                    throw new Error("Cannot acquire writer lock");
+                }
             }
             await this._writer.write(new Uint8Array(data));
         })
@@ -1331,7 +2584,7 @@ export class ESPLoader extends EventTarget {
                 try {
                     this._writer.releaseLock();
                 }
-                catch (e) {
+                catch {
                     // Ignore release errors
                 }
                 this._writer = undefined;
@@ -1351,51 +2604,239 @@ export class ESPLoader extends EventTarget {
             this.logger.debug("Port already closed, skipping disconnect");
             return;
         }
+        // Wait for pending writes to complete
         try {
-            // Wait for pending writes to complete
+            await this._writeChain;
+        }
+        catch (err) {
+            this.logger.debug(`Pending write error during disconnect: ${err}`);
+        }
+        // Release persistent writer before closing
+        if (this._writer) {
             try {
-                await this._writeChain;
+                await this._writer.close();
+                this._writer.releaseLock();
             }
             catch (err) {
-                this.logger.debug(`Pending write error during disconnect: ${err}`);
+                this.logger.debug(`Writer close/release error: ${err}`);
             }
-            // Block new writes during disconnect
-            this._isReconfiguring = true;
-            // Release persistent writer before closing
-            if (this._writer) {
+            this._writer = undefined;
+        }
+        else {
+            // No persistent writer exists, close stream directly
+            // This path is taken when no writes have been queued
+            try {
+                const writer = this.port.writable.getWriter();
+                await writer.close();
+                writer.releaseLock();
+            }
+            catch (err) {
+                this.logger.debug(`Direct writer close error: ${err}`);
+            }
+        }
+        await new Promise((resolve) => {
+            if (!this._reader) {
+                resolve(undefined);
+                return;
+            }
+            // Set a timeout to prevent hanging (important for node-usb)
+            const timeout = setTimeout(() => {
+                this.logger.debug("Disconnect timeout - forcing resolution");
+                resolve(undefined);
+            }, 1000);
+            this.addEventListener("disconnect", () => {
+                clearTimeout(timeout);
+                resolve(undefined);
+            }, { once: true });
+            // Only cancel if reader is still active
+            try {
+                this._reader.cancel();
+            }
+            catch (err) {
+                this.logger.debug(`Reader cancel error: ${err}`);
+                // Reader already released, resolve immediately
+                clearTimeout(timeout);
+                resolve(undefined);
+            }
+        });
+        this.connected = false;
+        // Close the port (important for node-usb adapter)
+        try {
+            await this.port.close();
+            this.logger.debug("Port closed successfully");
+        }
+        catch (err) {
+            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 {
-                    await this._writer.close();
-                    this._writer.releaseLock();
+                    reader.releaseLock();
                 }
                 catch (err) {
-                    this.logger.debug(`Writer close/release error: ${err}`);
+                    this.logger.debug(`Reader release error: ${err}`);
                 }
-                this._writer = undefined;
             }
-            else {
-                // No persistent writer exists, close stream directly
-                // This path is taken when no writes have been queued
+            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 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;
+        // Check device type
+        const isUsbJtag = this.isUsbJtagOrOtg === true;
+        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}`);
+            }
+            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.chipFamily} (${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 {
-                    const writer = this.port.writable.getWriter();
-                    await writer.close();
-                    writer.releaseLock();
+                    await this.rtcWdtResetChipSpecific();
+                    this.logger.debug("Watchdog reset triggered successfully");
                 }
                 catch (err) {
-                    this.logger.debug(`Direct writer close error: ${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;
             }
-            await new Promise((resolve) => {
-                if (!this._reader) {
-                    resolve(undefined);
-                }
-                this.addEventListener("disconnect", resolve, { once: true });
-                this._reader.cancel();
-            });
-            this.connected = false;
         }
-        finally {
-            this._isReconfiguring = false;
+        catch (err) {
+            this.logger.debug(`Could not reset device to firmware mode: ${err}`);
+            // Continue anyway - console mode might still work
         }
+        return false;
     }
     /**
      * @name reconnectAndResume
@@ -1408,8 +2849,10 @@ export class ESPLoader extends EventTarget {
         }
         try {
             this.logger.log("Reconnecting serial port...");
+            const savedBaudRate = this.currentBaudRate;
             this.connected = false;
             this.__inputBuffer = [];
+            this.__inputBufferReadIndex = 0;
             // Wait for pending writes to complete
             try {
                 await this._writeChain;
@@ -1442,7 +2885,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}`);
@@ -1452,6 +2895,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}`);
@@ -1472,6 +2916,7 @@ export class ESPLoader extends EventTarget {
             await this.hardReset(true);
             if (!this._parent) {
                 this.__inputBuffer = [];
+                this.__inputBufferReadIndex = 0;
                 this.__totalBytesRead = 0;
                 this.readLoop();
             }
@@ -1492,17 +2937,17 @@ 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})`);
                 }
             }
-            // Copy stub state to this instance if we're a stub loader
-            if (this.IS_STUB) {
-                Object.assign(this, stubLoader);
-            }
+            // The stub is now running on the chip
+            // stubLoader has this instance as _parent, so all operations go through this
+            // We just need to mark this instance as running stub code
+            this.IS_STUB = true;
             this.logger.debug("Reconnection successful");
         }
         catch (err) {
@@ -1511,6 +2956,103 @@ export class ESPLoader extends EventTarget {
             throw err;
         }
     }
+    /**
+     * @name reconnectToBootloader
+     * Close and reopen the port, then reset ESP to bootloader mode
+     * This is needed after Improv or other operations that leave ESP in firmware mode
+     */
+    async reconnectToBootloader() {
+        if (this._parent) {
+            await this._parent.reconnectToBootloader();
+            return;
+        }
+        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;
+            // Wait for pending writes to complete
+            try {
+                await this._writeChain;
+            }
+            catch (err) {
+                this.logger.debug(`Pending write error during reconnect: ${err}`);
+            }
+            // Block new writes during port close/open
+            this._isReconfiguring = true;
+            // Release persistent writer
+            if (this._writer) {
+                try {
+                    this._writer.releaseLock();
+                }
+                catch (err) {
+                    this.logger.debug(`Writer release error during reconnect: ${err}`);
+                }
+                this._writer = undefined;
+            }
+            // Cancel reader
+            if (this._reader) {
+                try {
+                    await this._reader.cancel();
+                }
+                catch (err) {
+                    this.logger.debug(`Reader cancel error: ${err}`);
+                }
+                this._reader = undefined;
+            }
+            // Close port
+            try {
+                await this.port.close();
+                this.logger.debug("Port closed");
+            }
+            catch (err) {
+                this.logger.debug(`Port close error: ${err}`);
+            }
+            // Open the port
+            this.logger.debug("Opening port...");
+            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}`);
+            }
+            // Verify port streams are available
+            if (!this.port.readable || !this.port.writable) {
+                throw new Error(`Port streams not available after open (readable: ${!!this.port.readable}, writable: ${!!this.port.writable})`);
+            }
+            // Port is now open and ready - allow writes for initialization
+            this._isReconfiguring = false;
+            // 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) {
+                this.__inputBuffer = [];
+                this.__inputBufferReadIndex = 0;
+                this.__totalBytesRead = 0;
+                this.readLoop();
+            }
+            // Wait for readLoop to start
+            await sleep(100);
+            // Reset to bootloader mode using multiple strategies
+            await this.connectWithResetStrategies();
+            // Detect chip type
+            await this.detectChip();
+            this.logger.log(`Reconnected to bootloader: ${this.chipName}`);
+        }
+        catch (err) {
+            // Ensure flag is reset on error
+            this._isReconfiguring = false;
+            throw err;
+        }
+    }
     /**
      * @name drainInputBuffer
      * Actively drain the input buffer by reading data for a specified time.
@@ -1534,8 +3076,8 @@ export class ESPLoader extends EventTarget {
         const drainStart = Date.now();
         const drainTimeout = 100; // Short timeout for draining
         while (drained < bytesToDrain && Date.now() - drainStart < drainTimeout) {
-            if (this._inputBuffer.length > 0) {
-                const byte = this._inputBuffer.shift();
+            if (this._inputBufferAvailable > 0) {
+                const byte = this._readByte();
                 if (byte !== undefined) {
                     drained++;
                 }
@@ -1551,6 +3093,7 @@ export class ESPLoader extends EventTarget {
         // Final clear of application buffer
         if (!this._parent) {
             this.__inputBuffer = [];
+            this.__inputBufferReadIndex = 0;
         }
     }
     /**
@@ -1562,12 +3105,14 @@ export class ESPLoader extends EventTarget {
         // Clear application buffer
         if (!this._parent) {
             this.__inputBuffer = [];
+            this.__inputBufferReadIndex = 0;
         }
         // Wait for any pending data
         await sleep(SYNC_TIMEOUT);
         // Final clear
         if (!this._parent) {
             this.__inputBuffer = [];
+            this.__inputBufferReadIndex = 0;
         }
         this.logger.debug("Serial buffers flushed");
     }
@@ -1577,16 +3122,53 @@ 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.");
         }
         // Flush serial buffers before flash read operation
         await this.flushSerialBuffers();
         this.logger.log(`Reading ${size} bytes from flash at address 0x${addr.toString(16)}...`);
-        const CHUNK_SIZE = 0x10000; // 64KB chunks
+        // Initialize adaptive speed multipliers for WebUSB devices
+        if (this.isWebUSB()) {
+            if (this._isCDCDevice) {
+                // CDC devices (CH343): Start with maximum, adaptive adjustment enabled
+                this._adaptiveBlockMultiplier = 8; // blockSize = 248 bytes
+                this._adaptiveMaxInFlightMultiplier = 8; // maxInFlight = 248 bytes
+                this._consecutiveSuccessfulChunks = 0;
+                this.logger.debug(`CDC device - Initialized: blockMultiplier=${this._adaptiveBlockMultiplier}, maxInFlightMultiplier=${this._adaptiveMaxInFlightMultiplier}`);
+            }
+            else {
+                // Non-CDC devices (CH340, CP2102): Fixed values, no adaptive adjustment
+                this._adaptiveBlockMultiplier = 1; // blockSize = 31 bytes (fixed)
+                this._adaptiveMaxInFlightMultiplier = 1; // maxInFlight = 31 bytes (fixed)
+                this._consecutiveSuccessfulChunks = 0;
+                this.logger.debug(`Non-CDC device - Fixed values: blockSize=31, maxInFlight=31`);
+            }
+        }
+        // Chunk size: Amount of data to request from ESP in one command
+        // 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 ((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
+        }
+        else {
+            // Web Serial: Use larger chunks for better performance
+            CHUNK_SIZE = 0x40 * 0x1000;
+        }
         let allData = new Uint8Array(0);
         let currentAddr = addr;
         let remainingSize = size;
@@ -1599,14 +3181,39 @@ export class ESPLoader extends EventTarget {
             // Retry loop for this chunk
             while (!chunkSuccess && retryCount <= MAX_RETRIES) {
                 let resp = new Uint8Array(0);
+                let lastAckedLength = 0; // Track last acknowledged length
                 try {
                     // Only log on first attempt or retries
                     if (retryCount === 0) {
                         this.logger.debug(`Reading chunk at 0x${currentAddr.toString(16)}, size: 0x${chunkSize.toString(16)}`);
                     }
-                    // Send read flash command for this chunk
-                    // This must be inside the retry loop so we send a fresh command after errors
-                    const pkt = pack("<IIII", currentAddr, chunkSize, 0x1000, 1024);
+                    let blockSize;
+                    let maxInFlight;
+                    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;
+                        const baseBlockSize = Math.floor((maxTransferSize - 2) / 2); // 31 bytes
+                        // Use current adaptive multipliers (initialized at start of readFlash)
+                        blockSize = baseBlockSize * this._adaptiveBlockMultiplier;
+                        maxInFlight = baseBlockSize * this._adaptiveMaxInFlightMultiplier;
+                    }
+                    else {
+                        // Web Serial (Desktop): Use multiples of 63 for consistency
+                        const base = 63;
+                        blockSize = base * 65; // 63 * 65 = 4095 (close to 0x1000)
+                        maxInFlight = base * 130; // 63 * 130 = 8190 (close to blockSize * 2)
+                    }
+                    const pkt = pack("<IIII", currentAddr, chunkSize, blockSize, maxInFlight);
                     const [res] = await this.checkCommand(ESP_READ_FLASH, pkt);
                     if (res != 0) {
                         throw new Error("Failed to read memory: " + res);
@@ -1649,10 +3256,19 @@ export class ESPLoader extends EventTarget {
                             newResp.set(resp);
                             newResp.set(packetData, resp.length);
                             resp = newResp;
-                            // Send acknowledgment
-                            const ackData = pack("<I", resp.length);
-                            const slipEncodedAck = slipEncode(ackData);
-                            await this.writeToStream(slipEncodedAck);
+                            // Send acknowledgment when we've received maxInFlight bytes
+                            // The stub sends packets until (num_sent - num_acked) >= max_in_flight
+                            // We MUST wait for all packets before sending ACK
+                            const shouldAck = resp.length >= chunkSize || // End of chunk
+                                resp.length >= lastAckedLength + maxInFlight; // Received all packets
+                            if (shouldAck) {
+                                const ackData = pack("<I", resp.length);
+                                const slipEncodedAck = slipEncode(ackData);
+                                await this.writeToStream(slipEncodedAck);
+                                // Update lastAckedLength to current response length
+                                // This ensures next ACK is sent at the right time
+                                lastAckedLength = resp.length;
+                            }
                         }
                     }
                     // Chunk read successfully - append to all data
@@ -1661,13 +3277,66 @@ export class ESPLoader extends EventTarget {
                     newAllData.set(resp, allData.length);
                     allData = newAllData;
                     chunkSuccess = true;
+                    // ADAPTIVE SPEED ADJUSTMENT: Only for CDC devices
+                    // Non-CDC devices (CH340, CP2102) stay at fixed blockSize=31, maxInFlight=31
+                    if (this.isWebUSB() && this._isCDCDevice && retryCount === 0) {
+                        this._consecutiveSuccessfulChunks++;
+                        // After 2 consecutive successful chunks, increase speed gradually
+                        if (this._consecutiveSuccessfulChunks >= 2) {
+                            const maxTransferSize = this.port.maxTransferSize || 64;
+                            const baseBlockSize = Math.floor((maxTransferSize - 2) / 2); // 31 bytes
+                            // Maximum: blockSize=248 (8 * 31), maxInFlight=248 (8 * 31)
+                            const MAX_BLOCK_MULTIPLIER = 8; // 248 bytes - tested stable
+                            const MAX_INFLIGHT_MULTIPLIER = 8; // 248 bytes - tested stable
+                            let adjusted = false;
+                            // Increase blockSize first (up to 248), then maxInFlight
+                            if (this._adaptiveBlockMultiplier < MAX_BLOCK_MULTIPLIER) {
+                                this._adaptiveBlockMultiplier = Math.min(this._adaptiveBlockMultiplier * 2, MAX_BLOCK_MULTIPLIER);
+                                adjusted = true;
+                            }
+                            // Once blockSize is at maximum, increase maxInFlight
+                            else if (this._adaptiveMaxInFlightMultiplier < MAX_INFLIGHT_MULTIPLIER) {
+                                this._adaptiveMaxInFlightMultiplier = Math.min(this._adaptiveMaxInFlightMultiplier * 2, MAX_INFLIGHT_MULTIPLIER);
+                                adjusted = true;
+                            }
+                            if (adjusted) {
+                                const newBlockSize = baseBlockSize * this._adaptiveBlockMultiplier;
+                                const newMaxInFlight = baseBlockSize * this._adaptiveMaxInFlightMultiplier;
+                                this.logger.debug(`Speed increased: blockSize=${newBlockSize}, maxInFlight=${newMaxInFlight}`);
+                                this._lastAdaptiveAdjustment = Date.now();
+                            }
+                            // Reset counter
+                            this._consecutiveSuccessfulChunks = 0;
+                        }
+                    }
                 }
                 catch (err) {
                     retryCount++;
+                    // ADAPTIVE SPEED ADJUSTMENT: Only for CDC devices
+                    // Non-CDC devices stay at fixed values
+                    if (this.isWebUSB() && this._isCDCDevice && retryCount === 1) {
+                        // Only reduce if we're above minimum
+                        if (this._adaptiveBlockMultiplier > 1 ||
+                            this._adaptiveMaxInFlightMultiplier > 1) {
+                            // Reduce to minimum on error
+                            this._adaptiveBlockMultiplier = 1; // 31 bytes (for CH343)
+                            this._adaptiveMaxInFlightMultiplier = 1; // 31 bytes
+                            this._consecutiveSuccessfulChunks = 0; // Reset success counter
+                            const maxTransferSize = this.port.maxTransferSize || 64;
+                            const baseBlockSize = Math.floor((maxTransferSize - 2) / 2);
+                            const newBlockSize = baseBlockSize * this._adaptiveBlockMultiplier;
+                            const newMaxInFlight = baseBlockSize * this._adaptiveMaxInFlightMultiplier;
+                            this.logger.debug(`Error at higher speed - reduced to minimum: blockSize=${newBlockSize}, maxInFlight=${newMaxInFlight}`);
+                        }
+                        else {
+                            // Already at minimum and still failing - this is a real error
+                            this.logger.debug(`Error at minimum speed (blockSize=31, maxInFlight=31) - not a speed issue`);
+                        }
+                    }
                     // 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
@@ -1681,10 +3350,11 @@ export class ESPLoader extends EventTarget {
                             }
                         }
                         else {
-                            // All retries exhausted - attempt deep recovery by reconnecting and reloading stub
+                            // All retries exhausted - attempt recovery by reloading stub
+                            // IMPORTANT: Do NOT close port to keep ESP32 in bootloader mode
                             if (!deepRecoveryAttempted) {
                                 deepRecoveryAttempted = true;
-                                this.logger.log(`All retries exhausted at 0x${currentAddr.toString(16)}. Attempting deep recovery (reconnect + reload stub)...`);
+                                this.logger.log(`All retries exhausted at 0x${currentAddr.toString(16)}. Attempting recovery (close and reopen port)...`);
                                 try {
                                     // Reconnect will close port, reopen, and reload stub
                                     await this.reconnect();
@@ -1693,13 +3363,13 @@ export class ESPLoader extends EventTarget {
                                     retryCount = 0;
                                     continue;
                                 }
-                                catch (reconnectErr) {
-                                    throw new Error(`Failed to read chunk at 0x${currentAddr.toString(16)} after ${MAX_RETRIES} retries and deep recovery failed: ${reconnectErr}`);
+                                catch (recoveryErr) {
+                                    throw new Error(`Failed to read chunk at 0x${currentAddr.toString(16)} after ${MAX_RETRIES} retries and recovery failed: ${recoveryErr}`);
                                 }
                             }
                             else {
-                                // Deep recovery already attempted, give up
-                                throw new Error(`Failed to read chunk at 0x${currentAddr.toString(16)} after ${MAX_RETRIES} retries and deep recovery attempt`);
+                                // Recovery already attempted, give up
+                                throw new Error(`Failed to read chunk at 0x${currentAddr.toString(16)} after ${MAX_RETRIES} retries and recovery attempt`);
                             }
                         }
                     }
@@ -1717,7 +3387,6 @@ export class ESPLoader extends EventTarget {
             remainingSize -= chunkSize;
             this.logger.debug(`Total progress: 0x${allData.length.toString(16)} from 0x${size.toString(16)} bytes`);
         }
-        this.logger.debug(`Successfully read ${allData.length} bytes from flash`);
         return allData;
     }
 }
@@ -1765,10 +3434,50 @@ class EspStubLoader extends ESPLoader {
         return [0, []];
     }
     /**
-     * @name getEraseSize
-     * depending on flash chip model the erase may take this long (maybe longer!)
+     * @name eraseFlash
+     * Erase entire flash chip
      */
     async eraseFlash() {
         await this.checkCommand(ESP_ERASE_FLASH, [], 0, CHIP_ERASE_TIMEOUT);
     }
+    /**
+     * @name eraseRegion
+     * Erase a specific region of flash
+     */
+    async eraseRegion(offset, size) {
+        // Validate inputs
+        if (offset < 0) {
+            throw new Error(`Invalid offset: ${offset} (must be non-negative)`);
+        }
+        if (size < 0) {
+            throw new Error(`Invalid size: ${size} (must be non-negative)`);
+        }
+        // No-op for zero size
+        if (size === 0) {
+            this.logger.log("eraseRegion: size is 0, skipping erase");
+            return;
+        }
+        // Check for sector alignment
+        if (offset % FLASH_SECTOR_SIZE !== 0) {
+            throw new Error(`Offset ${offset} (0x${offset.toString(16)}) is not aligned to flash sector size ${FLASH_SECTOR_SIZE} (0x${FLASH_SECTOR_SIZE.toString(16)})`);
+        }
+        if (size % FLASH_SECTOR_SIZE !== 0) {
+            throw new Error(`Size ${size} (0x${size.toString(16)}) is not aligned to flash sector size ${FLASH_SECTOR_SIZE} (0x${FLASH_SECTOR_SIZE.toString(16)})`);
+        }
+        // Check for reasonable bounds (prevent wrapping in pack)
+        const maxValue = 0xffffffff; // 32-bit unsigned max
+        if (offset > maxValue) {
+            throw new Error(`Offset ${offset} exceeds maximum value ${maxValue}`);
+        }
+        if (size > maxValue) {
+            throw new Error(`Size ${size} exceeds maximum value ${maxValue}`);
+        }
+        // Check for wrap-around
+        if (offset + size > maxValue) {
+            throw new Error(`Region end (offset + size = ${offset + size}) exceeds maximum addressable range ${maxValue}`);
+        }
+        const timeout = timeoutPerMb(ERASE_REGION_TIMEOUT_PER_MB, size);
+        const buffer = pack("<II", offset, size);
+        await this.checkCommand(ESP_ERASE_REGION, buffer, 0, timeout);
+    }
 }