esp32tool 1.1.8 → 1.2.0

package/dist/esp_loader.js

@@ -1,9 +1,8 @@
 /// <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, } 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) {
@@ -11,9 +10,9 @@ export class ESPLoader extends EventTarget {
         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;
@@ -24,12 +23,110 @@ export class ESPLoader extends EventTarget {
         this._isESP32S2NativeUSB = false;
         this._initializationSucceeded = false;
         this.__commandLock = Promise.resolve([0, []]);
-        this._isReconfiguring = false;
+        this.__isReconfiguring = false;
+        this.__abandonCurrentOperation = false;
+        // 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;
+        }
+    }
     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
@@ -55,6 +152,95 @@ export class ESPLoader extends EventTarget {
             this.__commandLock = value;
         }
     }
+    get _isReconfiguring() {
+        return this._parent
+            ? this._parent._isReconfiguring
+            : this.__isReconfiguring;
+    }
+    set _isReconfiguring(value) {
+        if (this._parent) {
+            this._parent._isReconfiguring = value;
+        }
+        else {
+            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 = {
@@ -102,6 +288,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();
@@ -116,6 +303,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();
@@ -172,7 +365,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 {
@@ -249,6 +442,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
@@ -281,6 +486,12 @@ export class ESPLoader extends EventTarget {
         catch {
             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;
+        }
         // Disconnected!
         this.connected = false;
         // Check if this is ESP32-S2 Native USB that needs port reselection
@@ -297,6 +508,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:
@@ -309,6 +523,511 @@ 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) {
+        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;
+        // 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 () => {
+                            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: 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 - 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}`);
+    }
     async hardReset(bootloader = false) {
         if (bootloader) {
             // enter flash mode
@@ -317,16 +1036,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.setRTSWebUSB(true); // EN->LOW
+                await this.sleep(200);
+                await this.setRTSWebUSB(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));
     }
@@ -451,6 +1188,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");
@@ -499,71 +1242,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;
-        const startTime = Date.now();
-        while (true) {
-            // 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._inputBuffer.length === 0) {
-                await sleep(1);
-                continue;
-            }
-            // Process all available bytes without going back to outer loop
-            // This is critical for handling high-speed burst transfers
-            while (this._inputBuffer.length > 0) {
-                const b = this._inputBuffer.shift();
-                if (partialPacket === null) {
-                    // waiting for packet header
-                    if (b == 0xc0) {
-                        partialPacket = [];
+        // 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)");
+                }
+                // 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;
+                }
+                // 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);
+                    }
                 }
             }
         }
@@ -595,7 +1436,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
@@ -647,8 +1488,9 @@ export class ESPLoader extends EventTarget {
     }
     async reconfigurePort(baud) {
         var _a;
+        // Block new writes during the entire reconfiguration (all paths)
+        this._isReconfiguring = true;
         try {
-            this._isReconfiguring = true;
             // Wait for pending writes to complete
             try {
                 await this._writeChain;
@@ -656,6 +1498,30 @@ export class ESPLoader extends EventTarget {
             catch (err) {
                 this.logger.debug(`Pending write error during reconfigure: ${err}`);
             }
+            // 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 {
@@ -684,110 +1550,44 @@ export class ESPLoader extends EventTarget {
             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
@@ -796,7 +1596,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);
@@ -820,8 +1620,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;
@@ -1296,12 +2098,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));
         })
@@ -1312,7 +2121,7 @@ export class ESPLoader extends EventTarget {
                 try {
                     this._writer.releaseLock();
                 }
-                catch (e) {
+                catch {
                     // Ignore release errors
                 }
                 this._writer = undefined;
@@ -1332,49 +2141,69 @@ export class ESPLoader extends EventTarget {
             this.logger.debug("Port already closed, skipping disconnect");
             return;
         }
+        // Wait for pending writes to complete
         try {
-            this._isReconfiguring = true;
-            // 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}`);
             }
-            // Release persistent writer before closing
-            if (this._writer) {
-                try {
-                    await this._writer.close();
-                    this._writer.releaseLock();
-                }
-                catch (err) {
-                    this.logger.debug(`Writer close/release error: ${err}`);
-                }
-                this._writer = undefined;
+            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();
             }
-            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}`);
-                }
+            catch (err) {
+                this.logger.debug(`Direct writer close error: ${err}`);
             }
-            await new Promise((resolve) => {
-                if (!this._reader) {
-                    resolve(undefined);
-                }
-                this.addEventListener("disconnect", resolve, { once: true });
+        }
+        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();
-            });
-            this.connected = false;
+            }
+            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");
         }
-        finally {
-            this._isReconfiguring = false;
+        catch (err) {
+            this.logger.debug(`Port close error: ${err}`);
         }
     }
     /**
@@ -1387,10 +2216,10 @@ export class ESPLoader extends EventTarget {
             return;
         }
         try {
-            this._isReconfiguring = true;
             this.logger.log("Reconnecting serial port...");
             this.connected = false;
             this.__inputBuffer = [];
+            this.__inputBufferReadIndex = 0;
             // Wait for pending writes to complete
             try {
                 await this._writeChain;
@@ -1398,6 +2227,8 @@ export class ESPLoader extends EventTarget {
             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 {
@@ -1439,6 +2270,8 @@ export class ESPLoader extends EventTarget {
             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;
             // Save chip info and flash size (no need to detect again)
             const savedChipFamily = this.chipFamily;
             const savedChipName = this.chipName;
@@ -1449,6 +2282,7 @@ export class ESPLoader extends EventTarget {
             await this.hardReset(true);
             if (!this._parent) {
                 this.__inputBuffer = [];
+                this.__inputBufferReadIndex = 0;
                 this.__totalBytesRead = 0;
                 this.readLoop();
             }
@@ -1476,14 +2310,16 @@ 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");
         }
-        finally {
+        catch (err) {
+            // Ensure flag is reset on error
             this._isReconfiguring = false;
+            throw err;
         }
     }
     /**
@@ -1509,8 +2345,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++;
                 }
@@ -1526,6 +2362,7 @@ export class ESPLoader extends EventTarget {
         // Final clear of application buffer
         if (!this._parent) {
             this.__inputBuffer = [];
+            this.__inputBufferReadIndex = 0;
         }
     }
     /**
@@ -1537,12 +2374,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");
     }
@@ -1561,7 +2400,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;
@@ -1569,18 +2436,35 @@ export class ESPLoader extends EventTarget {
             const chunkSize = Math.min(CHUNK_SIZE, remainingSize);
             let chunkSuccess = false;
             let retryCount = 0;
-            const MAX_RETRIES = 15;
+            const MAX_RETRIES = 5;
+            let deepRecoveryAttempted = false;
             // 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);
@@ -1623,10 +2507,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
@@ -1635,9 +2528,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) {
@@ -1655,7 +2601,27 @@ export class ESPLoader extends EventTarget {
                             }
                         }
                         else {
-                            throw new Error(`Failed to read chunk at 0x${currentAddr.toString(16)} after ${MAX_RETRIES} retries: ${err}`);
+                            // 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 recovery (close and reopen port)...`);
+                                try {
+                                    // Reconnect will close port, reopen, and reload stub
+                                    await this.reconnect();
+                                    this.logger.log("Deep recovery successful. Resuming read from current position...");
+                                    // Reset retry counter to give it another chance after recovery
+                                    retryCount = 0;
+                                    continue;
+                                }
+                                catch (recoveryErr) {
+                                    throw new Error(`Failed to read chunk at 0x${currentAddr.toString(16)} after ${MAX_RETRIES} retries and recovery failed: ${recoveryErr}`);
+                                }
+                            }
+                            else {
+                                // Recovery already attempted, give up
+                                throw new Error(`Failed to read chunk at 0x${currentAddr.toString(16)} after ${MAX_RETRIES} retries and recovery attempt`);
+                            }
                         }
                     }
                     else {
@@ -1672,7 +2638,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;
     }
 }
@@ -1720,10 +2685,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);
+    }
 }