tasmota-webserial-esptool 7.3.4 → 9.0.0

package/dist/esp_loader.js

@@ -2,8 +2,7 @@
 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 { 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 {
     constructor(port, logger, _parent) {
@@ -25,12 +24,58 @@ export class ESPLoader extends EventTarget {
         this._initializationSucceeded = false;
         this.__commandLock = Promise.resolve([0, []]);
         this.__isReconfiguring = false;
+        this.__abandonCurrentOperation = false;
+        // Adaptive speed adjustment for flash read operations - DISABLED
+        // Using fixed conservative values that work reliably
+        this.__adaptiveBlockMultiplier = 1;
+        this.__adaptiveMaxInFlightMultiplier = 1;
+        this.__consecutiveSuccessfulChunks = 0;
+        this.__lastAdaptiveAdjustment = 0;
+        this.__isCDCDevice = false;
         this.state_DTR = false;
         this.__writeChain = Promise.resolve();
     }
     get _inputBuffer() {
         return this._parent ? this._parent._inputBuffer : 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
             ? this._parent._totalBytesRead
@@ -68,6 +113,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 +236,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 +251,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();
@@ -185,7 +313,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 {
@@ -310,6 +438,9 @@ export class ESPLoader extends EventTarget {
     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,6 +453,509 @@ export class ESPLoader extends EventTarget {
         this.state_DTR = state;
         await this.port.setSignals({ dataTerminalReady: state });
     }
+    /**
+     * @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)
+     */
+    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);
+    }
+    // ============================================================================
+    // WebUSB (Android) - DTR/RTS Signal Handling & Reset Strategies
+    // ============================================================================
+    async setRTSWebUSB(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: undefined, // Let setSignals preserve current RTS state
+        });
+    }
+    async setDTRandRTSWebUSB(dtr, rts) {
+        this.state_DTR = dtr;
+        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;
+        // WebUSB (Android) uses different reset methods than Web Serial (Desktop)
+        if (this.isWebUSB()) {
+            // For USB-Serial chips (CP2102, CH340, etc.), try inverted strategies first
+            const isUSBSerialChip = !isUSBJTAGSerial && !isEspressifUSB;
+            // 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 function () {
+                            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 function () {
+                            return await self.hardResetUSBJTAGSerialInvertedDTRWebUSB();
+                        },
+                    });
+                    // Strategy 3: UnixTight (CDC fallback)
+                    resetStrategies.push({
+                        name: "UnixTight (WebUSB) - ESP32-S2 CDC",
+                        fn: async function () {
+                            return await self.hardResetUnixTightWebUSB();
+                        },
+                    });
+                    // Strategy 4: Classic reset (CDC fallback)
+                    resetStrategies.push({
+                        name: "Classic (WebUSB) - ESP32-S2 CDC",
+                        fn: async function () {
+                            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 function () {
+                            return await self.hardResetUSBJTAGSerialInvertedDTRWebUSB();
+                        },
+                    });
+                    resetStrategies.push({
+                        name: "USB-JTAG/Serial (WebUSB)",
+                        fn: async function () {
+                            return await self.hardResetUSBJTAGSerialWebUSB();
+                        },
+                    });
+                    resetStrategies.push({
+                        name: "Inverted DTR Classic (WebUSB)",
+                        fn: async function () {
+                            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 function () {
+                            return await self.hardResetUnixTightWebUSB();
+                        },
+                    });
+                    resetStrategies.push({
+                        name: "Classic (WebUSB) - CH34x",
+                        fn: async function () {
+                            return await self.hardResetClassicWebUSB();
+                        },
+                    });
+                    resetStrategies.push({
+                        name: "Inverted Both (WebUSB) - CH34x",
+                        fn: async function () {
+                            return await self.hardResetInvertedWebUSB();
+                        },
+                    });
+                    resetStrategies.push({
+                        name: "Inverted RTS (WebUSB) - CH34x",
+                        fn: async function () {
+                            return await self.hardResetInvertedRTSWebUSB();
+                        },
+                    });
+                    resetStrategies.push({
+                        name: "Inverted DTR (WebUSB) - CH34x",
+                        fn: async function () {
+                            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 function () {
+                            return await self.hardResetUnixTightWebUSB();
+                        },
+                    });
+                    resetStrategies.push({
+                        name: "Classic (WebUSB) - CP2102",
+                        fn: async function () {
+                            return await self.hardResetClassicWebUSB();
+                        },
+                    });
+                    resetStrategies.push({
+                        name: "Inverted Both (WebUSB) - CP2102",
+                        fn: async function () {
+                            return await self.hardResetInvertedWebUSB();
+                        },
+                    });
+                    resetStrategies.push({
+                        name: "Inverted RTS (WebUSB) - CP2102",
+                        fn: async function () {
+                            return await self.hardResetInvertedRTSWebUSB();
+                        },
+                    });
+                    resetStrategies.push({
+                        name: "Inverted DTR (WebUSB) - CP2102",
+                        fn: async function () {
+                            return await self.hardResetInvertedDTRWebUSB();
+                        },
+                    });
+                }
+                else {
+                    // For other USB-Serial chips, try UnixTight first, then multiple strategies
+                    resetStrategies.push({
+                        name: "UnixTight (WebUSB)",
+                        fn: async function () {
+                            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 {
+            // Web Serial (Desktop) strategies
+            // Strategy: USB-JTAG/Serial reset
+            if (isUSBJTAGSerial || isEspressifUSB) {
+                resetStrategies.push({
+                    name: "USB-JTAG/Serial",
+                    fn: async function () {
+                        return await self.hardResetUSBJTAGSerial();
+                    },
+                });
+            }
+            // Strategy: Classic reset
+            resetStrategies.push({
+                name: "Classic",
+                fn: async function () {
+                    return await self.hardResetClassic();
+                },
+            });
+            // 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.log(`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 with internally time-bounded sync (3 seconds per strategy)
+                const syncSuccess = await this.syncWithTimeout(3000);
+                if (syncSuccess) {
+                    // Sync succeeded
+                    this.logger.log(`Connected successfully with ${strategy.name} reset.`);
+                    return;
+                }
+                else {
+                    throw new Error("Sync timeout or abandoned");
+                }
+            }
+            catch (error) {
+                lastError = error;
+                this.logger.log(`${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
+        throw new Error(`Couldn't sync to ESP. Try resetting manually. Last error: ${lastError === null || lastError === void 0 ? void 0 : lastError.message}`);
+    }
     async hardReset(bootloader = false) {
         if (bootloader) {
             // enter flash mode
@@ -330,16 +964,34 @@ export class ESPLoader extends EventTarget {
                 this.logger.log("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.log("Classic reset (WebUSB/Android).");
+                }
+                else {
+                    await this.hardResetClassic();
+                    this.logger.log("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)
+            if (this.isWebUSB()) {
+                // WebUSB: Use longer delays for better compatibility
+                await this.setRTS(true); // EN->LOW
+                await this.sleep(200);
+                await this.setRTS(false);
+                await this.sleep(200);
+                this.logger.log("Hard reset (WebUSB).");
+            }
+            else {
+                // Web Serial: Standard reset
+                await this.setRTS(true); // EN->LOW
+                await this.sleep(100);
+                await this.setRTS(false);
+                this.logger.log("Hard reset.");
+            }
         }
         await new Promise((resolve) => setTimeout(resolve, 1000));
     }
@@ -464,6 +1116,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 +1170,164 @@ 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) {
+                    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) + ")");
+                        }
                     }
-                    else {
-                        if (this.debug) {
-                            this.logger.debug("Read invalid data: " + toHex(b));
-                            this.logger.debug("Remaining data in serial buffer: " +
-                                hexFormatter(this._inputBuffer));
+                    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) + ")");
                         }
-                        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 == 0xdb) {
+                        // start of escape sequence
+                        inEscape = true;
                     }
-                    else if (b == 0xdd) {
-                        partialPacket.push(0xdb);
+                    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 +1359,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
@@ -665,6 +1411,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 +1421,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 +1463,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
+     * @name syncWithTimeout
+     * Sync with timeout that can be abandoned (for reset strategy loop)
+     * This is internally time-bounded and checks the abandon flag
      */
-    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) {
+    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 +1519,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 +1543,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;
@@ -1315,12 +2021,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 +2044,7 @@ export class ESPLoader extends EventTarget {
                 try {
                     this._writer.releaseLock();
                 }
-                catch (e) {
+                catch {
                     // Ignore release errors
                 }
                 this._writer = undefined;
@@ -1387,6 +2100,7 @@ export class ESPLoader extends EventTarget {
             await new Promise((resolve) => {
                 if (!this._reader) {
                     resolve(undefined);
+                    return;
                 }
                 this.addEventListener("disconnect", resolve, { once: true });
                 this._reader.cancel();
@@ -1410,6 +2124,7 @@ export class ESPLoader extends EventTarget {
             this.logger.log("Reconnecting serial port...");
             this.connected = false;
             this.__inputBuffer = [];
+            this.__inputBufferReadIndex = 0;
             // Wait for pending writes to complete
             try {
                 await this._writeChain;
@@ -1472,6 +2187,7 @@ export class ESPLoader extends EventTarget {
             await this.hardReset(true);
             if (!this._parent) {
                 this.__inputBuffer = [];
+                this.__inputBufferReadIndex = 0;
                 this.__totalBytesRead = 0;
                 this.readLoop();
             }
@@ -1499,10 +2215,10 @@ export class ESPLoader extends EventTarget {
                     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) {
@@ -1534,8 +2250,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 +2267,7 @@ export class ESPLoader extends EventTarget {
         // Final clear of application buffer
         if (!this._parent) {
             this.__inputBuffer = [];
+            this.__inputBufferReadIndex = 0;
         }
     }
     /**
@@ -1562,12 +2279,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");
     }
@@ -1586,7 +2305,35 @@ export class ESPLoader extends EventTarget {
         // 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 (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 +2346,30 @@ 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 (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 +2412,18 @@ 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 after receiving maxInFlight bytes
+                            // This unblocks the stub to send the next batch of packets
+                            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,9 +2432,62 @@ 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) {
@@ -1681,10 +2505,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 +2518,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 +2542,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;
     }
 }