tasmota-webserial-esptool 6.5.4 → 7.0.1

package/dist/esp_loader.js

@@ -1,5 +1,5 @@
 /// <reference types="@types/w3c-web-serial" />
-import { CHIP_FAMILY_ESP32, CHIP_FAMILY_ESP32S2, CHIP_FAMILY_ESP32S3, CHIP_FAMILY_ESP32C2, CHIP_FAMILY_ESP32C3, CHIP_FAMILY_ESP32C5, CHIP_FAMILY_ESP32C6, CHIP_FAMILY_ESP32C61, CHIP_FAMILY_ESP32H2, CHIP_FAMILY_ESP32P4, 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, CHIP_ERASE_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_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-ignore
@@ -20,18 +20,84 @@ export class ESPLoader extends EventTarget {
         this.IS_STUB = false;
         this.connected = true;
         this.flashSize = null;
+        this._currentBaudRate = ESP_ROM_BAUD;
         this.state_DTR = false;
     }
     get _inputBuffer() {
         return this._parent ? this._parent._inputBuffer : this.__inputBuffer;
     }
+    get _totalBytesRead() {
+        return this._parent
+            ? this._parent._totalBytesRead
+            : this.__totalBytesRead || 0;
+    }
+    set _totalBytesRead(value) {
+        if (this._parent) {
+            this._parent._totalBytesRead = value;
+        }
+        else {
+            this.__totalBytesRead = value;
+        }
+    }
+    detectUSBSerialChip(vendorId, productId) {
+        // Common USB-Serial chip vendors and their products
+        const chips = {
+            0x1a86: {
+                // QinHeng Electronics
+                0x7523: { name: "CH340", maxBaudrate: 460800 },
+                0x55d4: { name: "CH9102", maxBaudrate: 6000000 },
+            },
+            0x10c4: {
+                // Silicon Labs
+                0xea60: { name: "CP2102(n)", maxBaudrate: 3000000 },
+                0xea70: { name: "CP2105", maxBaudrate: 2000000 },
+                0xea71: { name: "CP2108", maxBaudrate: 2000000 },
+            },
+            0x0403: {
+                // FTDI
+                0x6001: { name: "FT232R", maxBaudrate: 3000000 },
+                0x6010: { name: "FT2232", maxBaudrate: 3000000 },
+                0x6011: { name: "FT4232", maxBaudrate: 3000000 },
+                0x6014: { name: "FT232H", maxBaudrate: 12000000 },
+                0x6015: { name: "FT230X", maxBaudrate: 3000000 },
+            },
+            0x303a: {
+                // Espressif (native USB)
+                0x2: { name: "ESP32-S2 Native USB", maxBaudrate: 2000000 },
+                0x1001: { name: "ESP32 Native USB", maxBaudrate: 2000000 },
+                0x1002: { name: "ESP32 Native USB", maxBaudrate: 2000000 },
+                0x4002: { name: "ESP32 Native USB", maxBaudrate: 2000000 },
+                0x1000: { name: "ESP32 Native USB", maxBaudrate: 2000000 },
+            },
+        };
+        const vendor = chips[vendorId];
+        if (vendor && vendor[productId]) {
+            return vendor[productId];
+        }
+        return {
+            name: `Unknown (VID: 0x${vendorId.toString(16)}, PID: 0x${productId.toString(16)})`,
+        };
+    }
     async initialize() {
         await this.hardReset(true);
         if (!this._parent) {
             this.__inputBuffer = [];
+            this.__totalBytesRead = 0;
+            // Detect and log USB-Serial chip info
+            const portInfo = this.port.getInfo();
+            if (portInfo.usbVendorId && portInfo.usbProductId) {
+                const chipInfo = this.detectUSBSerialChip(portInfo.usbVendorId, portInfo.usbProductId);
+                this.logger.log(`USB-Serial: ${chipInfo.name} (VID: 0x${portInfo.usbVendorId.toString(16)}, PID: 0x${portInfo.usbProductId.toString(16)})`);
+                if (chipInfo.maxBaudrate) {
+                    this._maxUSBSerialBaudrate = chipInfo.maxBaudrate;
+                    this.logger.log(`Max baudrate: ${chipInfo.maxBaudrate}`);
+                }
+            }
             // Don't await this promise so it doesn't block rest of method.
             this.readLoop();
         }
+        // Clear buffer again after starting read loop
+        await this.flushSerialBuffers();
         await this.sync();
         // Detect chip type
         await this.detectChip();
@@ -42,7 +108,7 @@ export class ESPLoader extends EventTarget {
             this._efuses[i] = await this.readRegister(AddrMAC + 4 * i);
         }
         this.logger.log(`Chip type ${this.chipName}`);
-        //this.logger.log("FLASHID");
+        this.logger.debug(`Bootloader flash offset: 0x${FlAddr.flashOffs.toString(16)}`);
     }
     /**
      * Detect chip type using GET_SECURITY_INFO (for newer chips) or magic value (for older chips)
@@ -79,7 +145,7 @@ export class ESPLoader extends EventTarget {
             this.logger.debug(`GET_SECURITY_INFO failed, using magic value detection: ${err}`);
             // Clear input buffer and re-sync to recover from failed command
             this._inputBuffer.length = 0;
-            await sleep(100);
+            await sleep(SYNC_TIMEOUT);
             // Re-sync with the chip to ensure clean communication
             try {
                 await this.sync();
@@ -175,7 +241,12 @@ export class ESPLoader extends EventTarget {
                 if (!value || value.length === 0) {
                     continue;
                 }
-                this._inputBuffer.push(...Array.from(value));
+                // Always read from browser's serial buffer immediately
+                // to prevent browser buffer overflow. Don't apply back-pressure here.
+                const chunk = Array.from(value);
+                Array.prototype.push.apply(this._inputBuffer, chunk);
+                // Track total bytes read from serial port
+                this._totalBytesRead += value.length;
             }
         }
         catch (err) {
@@ -202,7 +273,6 @@ export class ESPLoader extends EventTarget {
         await this.port.setSignals({ dataTerminalReady: state });
     }
     async hardReset(bootloader = false) {
-        this.logger.log("Try hard reset.");
         if (bootloader) {
             // enter flash mode
             if (this.port.getInfo().usbProductId === USB_JTAG_SERIAL_PID) {
@@ -221,6 +291,7 @@ export class ESPLoader extends EventTarget {
                 await this.sleep(100);
                 await this.setDTR(false);
                 await this.setRTS(false);
+                this.logger.log("USB MCU reset.");
             }
             else {
                 // otherwise, esp chip should be connected to computer via usb-serial
@@ -233,6 +304,7 @@ export class ESPLoader extends EventTarget {
                 await this.setRTS(false);
                 await this.sleep(50);
                 await this.setDTR(false);
+                this.logger.log("DTR/RTS USB serial chip reset.");
             }
         }
         else {
@@ -240,6 +312,7 @@ export class ESPLoader extends EventTarget {
             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));
     }
@@ -290,7 +363,10 @@ export class ESPLoader extends EventTarget {
             this.chipFamily == CHIP_FAMILY_ESP32C6 ||
             this.chipFamily == CHIP_FAMILY_ESP32C61 ||
             this.chipFamily == CHIP_FAMILY_ESP32H2 ||
-            this.chipFamily == CHIP_FAMILY_ESP32P4) {
+            this.chipFamily == CHIP_FAMILY_ESP32H4 ||
+            this.chipFamily == CHIP_FAMILY_ESP32H21 ||
+            this.chipFamily == CHIP_FAMILY_ESP32P4 ||
+            this.chipFamily == CHIP_FAMILY_ESP32S31) {
             macAddr[0] = (mac1 >> 8) & 0xff;
             macAddr[1] = mac1 & 0xff;
             macAddr[2] = (mac0 >> 24) & 0xff;
@@ -339,7 +415,10 @@ export class ESPLoader extends EventTarget {
             CHIP_FAMILY_ESP32C6,
             CHIP_FAMILY_ESP32C61,
             CHIP_FAMILY_ESP32H2,
+            CHIP_FAMILY_ESP32H4,
+            CHIP_FAMILY_ESP32H21,
             CHIP_FAMILY_ESP32P4,
+            CHIP_FAMILY_ESP32S31,
         ].includes(this.chipFamily)) {
             statusLen = 4;
         }
@@ -392,8 +471,6 @@ 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.
-     * Designed to avoid too many calls to serial.read(1), which can bog
-     * down on slow systems.
      */
     async readPacket(timeout) {
         let partialPacket = null;
@@ -408,7 +485,8 @@ export class ESPLoader extends EventTarget {
                     break;
                 }
                 else {
-                    await sleep(10);
+                    // Reduced sleep time for faster response during high-speed transfers
+                    await sleep(1);
                 }
             }
             if (readBytes.length == 0) {
@@ -509,7 +587,6 @@ export class ESPLoader extends EventTarget {
         if (this.chipFamily == CHIP_FAMILY_ESP8266) {
             throw new Error("Changing baud rate is not supported on the ESP8266");
         }
-        this.logger.log("Attempting to change baud rate to " + baud + "...");
         try {
             // Send ESP_ROM_BAUD(115200) as the old one if running STUB otherwise 0
             let buffer = pack("<II", baud, this.IS_STUB ? ESP_ROM_BAUD : 0);
@@ -525,6 +602,21 @@ export class ESPLoader extends EventTarget {
         else {
             await this.reconfigurePort(baud);
         }
+        // Track current baudrate for reconnect
+        if (this._parent) {
+            this._parent._currentBaudRate = baud;
+        }
+        else {
+            this._currentBaudRate = baud;
+        }
+        // Warn if baudrate exceeds USB-Serial chip capability
+        const maxBaud = this._parent
+            ? this._parent._maxUSBSerialBaudrate
+            : this._maxUSBSerialBaudrate;
+        if (maxBaud && baud > maxBaud) {
+            this.logger.log(`⚠️  WARNING: Baudrate ${baud} exceeds USB-Serial chip limit (${maxBaud})!`);
+            this.logger.log(`⚠️  This may cause data corruption or connection failures!`);
+        }
         this.logger.log(`Changed baud rate to ${baud}`);
     }
     async reconfigurePort(baud) {
@@ -538,6 +630,8 @@ export class ESPLoader extends EventTarget {
             await this.port.close();
             // Reopen Port
             await this.port.open({ baudRate: baud });
+            // Clear buffer again
+            await this.flushSerialBuffers();
             // Restart Readloop
             this.readLoop();
         }
@@ -556,10 +650,10 @@ export class ESPLoader extends EventTarget {
             this._inputBuffer.length = 0;
             let response = await this._sync();
             if (response) {
-                await sleep(100);
+                await sleep(SYNC_TIMEOUT);
                 return true;
             }
-            await sleep(100);
+            await sleep(SYNC_TIMEOUT);
         }
         throw new Error("Couldn't sync to ESP. Try resetting.");
     }
@@ -690,6 +784,8 @@ export class ESPLoader extends EventTarget {
      *   number of blocks requred.
      */
     async flashBegin(size = 0, offset = 0, encrypted = false) {
+        // Flush serial buffers before flash write operation
+        await this.flushSerialBuffers();
         let eraseSize;
         let buffer;
         let flashWriteSize = this.getFlashWriteSize();
@@ -704,7 +800,10 @@ export class ESPLoader extends EventTarget {
                 CHIP_FAMILY_ESP32C6,
                 CHIP_FAMILY_ESP32C61,
                 CHIP_FAMILY_ESP32H2,
+                CHIP_FAMILY_ESP32H4,
+                CHIP_FAMILY_ESP32H21,
                 CHIP_FAMILY_ESP32P4,
+                CHIP_FAMILY_ESP32S31,
             ].includes(this.chipFamily)) {
             await this.checkCommand(ESP_SPI_ATTACH, new Array(8).fill(0));
         }
@@ -733,7 +832,10 @@ export class ESPLoader extends EventTarget {
             this.chipFamily == CHIP_FAMILY_ESP32C6 ||
             this.chipFamily == CHIP_FAMILY_ESP32C61 ||
             this.chipFamily == CHIP_FAMILY_ESP32H2 ||
-            this.chipFamily == CHIP_FAMILY_ESP32P4) {
+            this.chipFamily == CHIP_FAMILY_ESP32H4 ||
+            this.chipFamily == CHIP_FAMILY_ESP32H21 ||
+            this.chipFamily == CHIP_FAMILY_ESP32P4 ||
+            this.chipFamily == CHIP_FAMILY_ESP32S31) {
             buffer = buffer.concat(pack("<I", encrypted ? 1 : 0));
         }
         this.logger.log("Erase size " +
@@ -959,8 +1061,13 @@ export class ESPLoader extends EventTarget {
         let data = pack("<II", entrypoint == 0 ? 1 : 0, entrypoint);
         return await this.checkCommand(ESP_MEM_END, data, 0, timeout);
     }
-    async runStub() {
+    async runStub(skipFlashDetection = false) {
         const stub = await getStubCode(this.chipFamily, this.chipRevision);
+        // No stub available for this chip, return ROM loader
+        if (stub === null) {
+            this.logger.log(`Stub flasher is not yet supported on ${this.chipName}, using ROM loader`);
+            return this;
+        }
         // We're transferring over USB, right?
         let ramBlock = USB_RAM_BLOCK;
         // Upload
@@ -981,7 +1088,6 @@ export class ESPLoader extends EventTarget {
                 }
             }
         }
-        this.logger.log("Running stub...");
         await this.memFinish(stub["entry"]);
         let pChar;
         const p = await this.readPacket(500);
@@ -991,8 +1097,10 @@ export class ESPLoader extends EventTarget {
         }
         this.logger.log("Stub is now running...");
         const espStubLoader = new EspStubLoader(this.port, this.logger, this);
-        // Try to autodetect the flash size as soon as the stub is running.
-        await espStubLoader.detectFlashSize();
+        // Try to autodetect the flash size.
+        if (!skipFlashDetection) {
+            await espStubLoader.detectFlashSize();
+        }
         return espStubLoader;
     }
     async writeToStream(data) {
@@ -1020,6 +1128,254 @@ export class ESPLoader extends EventTarget {
         });
         this.connected = false;
     }
+    /**
+     * @name reconnectAndResume
+     * Reconnect the serial port to flush browser buffers and reload stub
+     */
+    async reconnect() {
+        if (this._parent) {
+            await this._parent.reconnect();
+            return;
+        }
+        this.logger.log("Reconnecting serial port...");
+        this.connected = false;
+        this.__inputBuffer = [];
+        // Cancel reader
+        if (this._reader) {
+            try {
+                await this._reader.cancel();
+            }
+            catch (err) {
+                this.logger.debug(`Reader cancel error: ${err}`);
+            }
+            this._reader = undefined;
+        }
+        await sleep(SYNC_TIMEOUT);
+        // Close port
+        try {
+            await this.port.close();
+            this.logger.log("Port closed");
+        }
+        catch (err) {
+            this.logger.debug(`Port close error: ${err}`);
+        }
+        // Wait for port to fully close
+        await sleep(SYNC_TIMEOUT);
+        // Open the port
+        this.logger.debug("Opening port...");
+        try {
+            await this.port.open({ baudRate: ESP_ROM_BAUD });
+            this.connected = true;
+        }
+        catch (err) {
+            throw new Error(`Failed to open port: ${err}`);
+        }
+        // Wait for port to be fully ready
+        await sleep(SYNC_TIMEOUT);
+        // Verify port streams are available
+        if (!this.port.readable || !this.port.writable) {
+            throw new Error(`Port streams not available after open (readable: ${!!this.port.readable}, writable: ${!!this.port.writable})`);
+        }
+        // Save chip info and flash size (no need to detect again)
+        const savedChipFamily = this.chipFamily;
+        const savedChipName = this.chipName;
+        const savedChipRevision = this.chipRevision;
+        const savedChipVariant = this.chipVariant;
+        const savedFlashSize = this.flashSize;
+        // Reinitialize without chip detection
+        await this.hardReset(true);
+        if (!this._parent) {
+            this.__inputBuffer = [];
+            this.__totalBytesRead = 0;
+            this.readLoop();
+        }
+        await this.flushSerialBuffers();
+        await this.sync();
+        // Restore chip info (skip detection)
+        this.chipFamily = savedChipFamily;
+        this.chipName = savedChipName;
+        this.chipRevision = savedChipRevision;
+        this.chipVariant = savedChipVariant;
+        this.flashSize = savedFlashSize;
+        this.logger.debug(`Reconnect complete (chip: ${this.chipName})`);
+        // Verify port is ready
+        if (!this.port.writable || !this.port.readable) {
+            throw new Error("Port not ready after reconnect");
+        }
+        // Load stub (skip flash detection)
+        const stubLoader = await this.runStub(true);
+        this.logger.debug("Stub loaded");
+        // Restore baudrate if it was changed
+        if (this._currentBaudRate !== ESP_ROM_BAUD) {
+            await stubLoader.setBaudrate(this._currentBaudRate);
+            // Wait for port to be ready after baudrate change
+            await sleep(SYNC_TIMEOUT);
+            // Verify port is still ready after baudrate change
+            if (!this.port.writable || !this.port.readable) {
+                throw new Error(`Port not ready after baudrate change (readable: ${!!this.port.readable}, writable: ${!!this.port.writable})`);
+            }
+        }
+        // Copy stub state to this instance if we're a stub loader
+        if (this.IS_STUB) {
+            Object.assign(this, stubLoader);
+        }
+        this.logger.debug("Reconnection successful");
+    }
+    /**
+     * @name flushSerialBuffers
+     * Flush any pending data in the TX and RX serial port buffers
+     * This clears both the application RX buffer and waits for hardware buffers to drain
+     */
+    async flushSerialBuffers() {
+        // Clear application RX buffer
+        if (!this._parent) {
+            this.__inputBuffer = [];
+        }
+        // Wait for any pending TX operations and in-flight RX data
+        await sleep(SYNC_TIMEOUT);
+        // Clear RX buffer again
+        if (!this._parent) {
+            this.__inputBuffer = [];
+        }
+        // Wait longer to ensure all stale data has been received and discarded
+        await sleep(SYNC_TIMEOUT * 2);
+        // Final clear
+        if (!this._parent) {
+            this.__inputBuffer = [];
+        }
+        this.logger.debug("Serial buffers flushed");
+    }
+    /**
+     * @name readFlash
+     * Read flash memory from the chip (only works with stub loader)
+     * @param addr - Address to read from
+     * @param size - Number of bytes to read
+     * @param onPacketReceived - Optional callback function called when packet is received
+     * @returns Uint8Array containing the flash data
+     */
+    async readFlash(addr, size, onPacketReceived) {
+        if (!this.IS_STUB) {
+            throw new Error("Reading flash is only supported in stub mode. Please run runStub() first.");
+        }
+        // Check if we should reconnect BEFORE starting the read
+        // Reconnect if total bytes read >= 4MB to ensure clean state
+        if (this._totalBytesRead >= 4 * 1024 * 1024) {
+            this.logger.log(
+            // `Total bytes read: ${this._totalBytesRead}. Reconnecting before new read...`,
+            `Reconnecting before new read...`);
+            try {
+                await this.reconnect();
+            }
+            catch (err) {
+                // If reconnect fails, throw error - don't continue with potentially broken state
+                throw new Error(`Reconnect failed: ${err}`);
+            }
+        }
+        // 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
+        let allData = new Uint8Array(0);
+        let currentAddr = addr;
+        let remainingSize = size;
+        while (remainingSize > 0) {
+            // Reconnect every 4MB to prevent browser buffer issues
+            if (allData.length > 0 && allData.length % (4 * 1024 * 1024) === 0) {
+                this.logger.debug(`Read ${allData.length} bytes. Reconnecting to clear buffers...`);
+                try {
+                    await this.reconnect();
+                }
+                catch (err) {
+                    throw new Error(`Reconnect failed during read: ${err}`);
+                }
+            }
+            const chunkSize = Math.min(CHUNK_SIZE, remainingSize);
+            let chunkSuccess = false;
+            let retryCount = 0;
+            const MAX_RETRIES = 3;
+            // Retry loop for this chunk
+            while (!chunkSuccess && retryCount <= MAX_RETRIES) {
+                try {
+                    this.logger.debug(`Reading chunk at 0x${currentAddr.toString(16)}, size: 0x${chunkSize.toString(16)}`);
+                    // Send read flash command for this chunk
+                    let pkt = pack("<IIII", currentAddr, chunkSize, 0x1000, 1024);
+                    const [res, _] = await this.checkCommand(ESP_READ_FLASH, pkt);
+                    if (res != 0) {
+                        throw new Error("Failed to read memory: " + res);
+                    }
+                    let resp = new Uint8Array(0);
+                    while (resp.length < chunkSize) {
+                        // Read a SLIP packet
+                        let packet;
+                        try {
+                            packet = await this.readPacket(FLASH_READ_TIMEOUT);
+                        }
+                        catch (err) {
+                            if (err instanceof SlipReadError) {
+                                this.logger.debug(`SLIP read error at ${resp.length} bytes: ${err.message}`);
+                                // If we've read all the data we need, break
+                                if (resp.length >= chunkSize) {
+                                    break;
+                                }
+                            }
+                            throw err;
+                        }
+                        if (packet && packet.length > 0) {
+                            const packetData = new Uint8Array(packet);
+                            // Append to response
+                            const newResp = new Uint8Array(resp.length + packetData.length);
+                            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);
+                        }
+                    }
+                    // Chunk read successfully - append to all data
+                    const newAllData = new Uint8Array(allData.length + resp.length);
+                    newAllData.set(allData);
+                    newAllData.set(resp, allData.length);
+                    allData = newAllData;
+                    chunkSuccess = true;
+                }
+                catch (err) {
+                    retryCount++;
+                    // Check if it's a timeout error
+                    if (err instanceof SlipReadError &&
+                        err.message.includes("Timed out")) {
+                        if (retryCount <= MAX_RETRIES) {
+                            this.logger.log(`⚠️  Timeout error at 0x${currentAddr.toString(16)}. Reconnecting and retrying (attempt ${retryCount}/${MAX_RETRIES})...`);
+                            try {
+                                await this.reconnect();
+                                // Continue to retry the same chunk
+                            }
+                            catch (reconnectErr) {
+                                throw new Error(`Reconnect failed: ${reconnectErr}`);
+                            }
+                        }
+                        else {
+                            throw new Error(`Failed to read chunk at 0x${currentAddr.toString(16)} after ${MAX_RETRIES} retries: ${err}`);
+                        }
+                    }
+                    else {
+                        // Non-timeout error, don't retry
+                        throw err;
+                    }
+                }
+            }
+            // Update progress (use empty array since we already appended to allData)
+            if (onPacketReceived) {
+                onPacketReceived(new Uint8Array(chunkSize), allData.length, size);
+            }
+            currentAddr += chunkSize;
+            remainingSize -= chunkSize;
+            this.logger.debug(`Total progress: 0x${allData.length.toString(16)}/0x${size.toString(16)} bytes`);
+        }
+        this.logger.debug(`Successfully read ${allData.length} bytes from flash`);
+        return allData;
+    }
 }
 class EspStubLoader extends ESPLoader {
     constructor() {
@@ -1036,6 +1392,10 @@ class EspStubLoader extends ESPLoader {
      */
     async memBegin(size, blocks, blocksize, offset) {
         let stub = await getStubCode(this.chipFamily, this.chipRevision);
+        // Stub may be null for chips without stub support
+        if (stub === null) {
+            return;
+        }
         let load_start = offset;
         let load_end = offset + size;
         console.log(load_start, load_end);

package/dist/index.d.ts

@@ -2,5 +2,5 @@ import { Logger } from "./const";
 import { ESPLoader } from "./esp_loader";
 export type { Logger } from "./const";
 export { ESPLoader } from "./esp_loader";
-export { CHIP_FAMILY_ESP32, CHIP_FAMILY_ESP32S2, CHIP_FAMILY_ESP32S3, CHIP_FAMILY_ESP8266, CHIP_FAMILY_ESP32C2, CHIP_FAMILY_ESP32C3, CHIP_FAMILY_ESP32C5, CHIP_FAMILY_ESP32C6, CHIP_FAMILY_ESP32C61, CHIP_FAMILY_ESP32H2, CHIP_FAMILY_ESP32P4, } from "./const";
+export { CHIP_FAMILY_ESP32, CHIP_FAMILY_ESP32S2, CHIP_FAMILY_ESP32S3, CHIP_FAMILY_ESP8266, 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, } from "./const";
 export declare const connect: (logger: Logger) => Promise<ESPLoader>;

package/dist/index.js

@@ -2,11 +2,10 @@
 import { ESP_ROM_BAUD } from "./const";
 import { ESPLoader } from "./esp_loader";
 export { ESPLoader } from "./esp_loader";
-export { CHIP_FAMILY_ESP32, CHIP_FAMILY_ESP32S2, CHIP_FAMILY_ESP32S3, CHIP_FAMILY_ESP8266, CHIP_FAMILY_ESP32C2, CHIP_FAMILY_ESP32C3, CHIP_FAMILY_ESP32C5, CHIP_FAMILY_ESP32C6, CHIP_FAMILY_ESP32C61, CHIP_FAMILY_ESP32H2, CHIP_FAMILY_ESP32P4, } from "./const";
+export { CHIP_FAMILY_ESP32, CHIP_FAMILY_ESP32S2, CHIP_FAMILY_ESP32S3, CHIP_FAMILY_ESP8266, 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, } from "./const";
 export const connect = async (logger) => {
     // - Request a port and open a connection.
     const port = await navigator.serial.requestPort();
-    logger.log("Connecting...");
     await port.open({ baudRate: ESP_ROM_BAUD });
     logger.log("Connected successfully.");
     return new ESPLoader(port, logger);

package/dist/partition.d.ts

@@ -0,0 +1,26 @@
+/**
+ * ESP32 Partition Table Parser
+ * Based on ESP-IDF partition table format
+ */
+export interface Partition {
+    name: string;
+    type: number;
+    subtype: number;
+    offset: number;
+    size: number;
+    flags: number;
+    typeName: string;
+    subtypeName: string;
+}
+/**
+ * Parse the entire partition table
+ */
+export declare function parsePartitionTable(data: Uint8Array): Partition[];
+/**
+ * Get the default partition table offset
+ */
+export declare function getPartitionTableOffset(): number;
+/**
+ * Format size in human-readable format
+ */
+export declare function formatSize(bytes: number): string;