tasmota-webserial-esptool 7.0.1 → 7.2.0

package/dist/esp_loader.js

@@ -2,7 +2,7 @@
 import { CHIP_FAMILY_ESP32, CHIP_FAMILY_ESP32S2, CHIP_FAMILY_ESP32S3, CHIP_FAMILY_ESP32C2, CHIP_FAMILY_ESP32C3, CHIP_FAMILY_ESP32C5, CHIP_FAMILY_ESP32C6, CHIP_FAMILY_ESP32C61, CHIP_FAMILY_ESP32H2, CHIP_FAMILY_ESP32H4, CHIP_FAMILY_ESP32H21, CHIP_FAMILY_ESP32P4, CHIP_FAMILY_ESP32S31, CHIP_FAMILY_ESP8266, MAX_TIMEOUT, DEFAULT_TIMEOUT, ERASE_REGION_TIMEOUT_PER_MB, ESP_CHANGE_BAUDRATE, ESP_CHECKSUM_MAGIC, ESP_FLASH_BEGIN, ESP_FLASH_DATA, ESP_FLASH_END, ESP_MEM_BEGIN, ESP_MEM_DATA, ESP_MEM_END, ESP_READ_REG, ESP_WRITE_REG, ESP_SPI_ATTACH, ESP_SYNC, ESP_GET_SECURITY_INFO, FLASH_SECTOR_SIZE, FLASH_WRITE_SIZE, STUB_FLASH_WRITE_SIZE, MEM_END_ROM_TIMEOUT, ROM_INVALID_RECV_MSG, SYNC_PACKET, SYNC_TIMEOUT, USB_RAM_BLOCK, ESP_ERASE_FLASH, ESP_READ_FLASH, CHIP_ERASE_TIMEOUT, FLASH_READ_TIMEOUT, timeoutPerMb, ESP_ROM_BAUD, USB_JTAG_SERIAL_PID, ESP_FLASH_DEFL_BEGIN, ESP_FLASH_DEFL_DATA, ESP_FLASH_DEFL_END, getSpiFlashAddresses, DETECTED_FLASH_SIZES, CHIP_DETECT_MAGIC_REG_ADDR, CHIP_DETECT_MAGIC_VALUES, CHIP_ID_TO_INFO, ESP32P4_EFUSE_BLOCK1_ADDR, SlipReadError, } from "./const";
 import { getStubCode } from "./stubs";
 import { hexFormatter, sleep, slipEncode, toHex } from "./util";
-// @ts-ignore
+// @ts-expect-error pako ESM module doesn't have proper type definitions
 import { deflate } from "pako/dist/pako.esm.mjs";
 import { pack, unpack } from "./struct";
 export class ESPLoader extends EventTarget {
@@ -21,6 +21,8 @@ export class ESPLoader extends EventTarget {
         this.connected = true;
         this.flashSize = null;
         this._currentBaudRate = ESP_ROM_BAUD;
+        this._isESP32S2NativeUSB = false;
+        this._initializationSucceeded = false;
         this.state_DTR = false;
     }
     get _inputBuffer() {
@@ -44,8 +46,13 @@ export class ESPLoader extends EventTarget {
         const chips = {
             0x1a86: {
                 // QinHeng Electronics
+                0x7522: { name: "CH340", maxBaudrate: 460800 },
                 0x7523: { name: "CH340", maxBaudrate: 460800 },
+                0x7584: { name: "CH340", maxBaudrate: 460800 },
+                0x5523: { name: "CH341", maxBaudrate: 2000000 },
+                0x55d3: { name: "CH343", maxBaudrate: 6000000 },
                 0x55d4: { name: "CH9102", maxBaudrate: 6000000 },
+                0x55d8: { name: "CH9101", maxBaudrate: 3000000 },
             },
             0x10c4: {
                 // Silicon Labs
@@ -92,6 +99,10 @@ export class ESPLoader extends EventTarget {
                     this._maxUSBSerialBaudrate = chipInfo.maxBaudrate;
                     this.logger.log(`Max baudrate: ${chipInfo.maxBaudrate}`);
                 }
+                // Detect ESP32-S2 Native USB
+                if (portInfo.usbVendorId === 0x303a && portInfo.usbProductId === 0x2) {
+                    this._isESP32S2NativeUSB = true;
+                }
             }
             // Don't await this promise so it doesn't block rest of method.
             this.readLoop();
@@ -102,13 +113,15 @@ export class ESPLoader extends EventTarget {
         // Detect chip type
         await this.detectChip();
         // Read the OTP data for this chip and store into this.efuses array
-        let FlAddr = getSpiFlashAddresses(this.getChipFamily());
-        let AddrMAC = FlAddr.macFuse;
+        const FlAddr = getSpiFlashAddresses(this.getChipFamily());
+        const AddrMAC = FlAddr.macFuse;
         for (let i = 0; i < 4; i++) {
             this._efuses[i] = await this.readRegister(AddrMAC + 4 * i);
         }
         this.logger.log(`Chip type ${this.chipName}`);
         this.logger.debug(`Bootloader flash offset: 0x${FlAddr.flashOffs.toString(16)}`);
+        // Mark initialization as successful
+        this._initializationSucceeded = true;
     }
     /**
      * Detect chip type using GET_SECURITY_INFO (for newer chips) or magic value (for older chips)
@@ -140,9 +153,9 @@ export class ESPLoader extends EventTarget {
             }
             this.logger.debug(`Unknown IMAGE_CHIP_ID: ${chipId}, falling back to magic value detection`);
         }
-        catch (err) {
+        catch (error) {
             // GET_SECURITY_INFO not supported, fall back to magic value detection
-            this.logger.debug(`GET_SECURITY_INFO failed, using magic value detection: ${err}`);
+            this.logger.debug(`GET_SECURITY_INFO failed, using magic value detection: ${error}`);
             // Clear input buffer and re-sync to recover from failed command
             this._inputBuffer.length = 0;
             await sleep(SYNC_TIMEOUT);
@@ -154,15 +167,14 @@ export class ESPLoader extends EventTarget {
                 this.logger.debug(`Re-sync after GET_SECURITY_INFO failure: ${syncErr}`);
             }
         }
-        // Fallback: Use magic value detection for ESP8266, ESP32, ESP32-S2, and ESP32-P4 RC versions
-        let chipMagicValue = await this.readRegister(CHIP_DETECT_MAGIC_REG_ADDR);
-        let chip = CHIP_DETECT_MAGIC_VALUES[chipMagicValue >>> 0];
+        // Fallback: Use magic value detection for ESP8266, ESP32, ESP32-S2
+        const chipMagicValue = await this.readRegister(CHIP_DETECT_MAGIC_REG_ADDR);
+        const chip = CHIP_DETECT_MAGIC_VALUES[chipMagicValue >>> 0];
         if (chip === undefined) {
             throw new Error(`Unknown Chip: Hex: ${toHex(chipMagicValue >>> 0, 8).toLowerCase()} Number: ${chipMagicValue}`);
         }
         this.chipName = chip.name;
         this.chipFamily = chip.family;
-        // For ESP32-P4 detected via magic value (old revisions), set variant
         if (this.chipFamily === CHIP_FAMILY_ESP32P4) {
             this.chipRevision = await this.getChipRevision();
             this.logger.debug(`ESP32-P4 revision: ${this.chipRevision}`);
@@ -197,7 +209,7 @@ export class ESPLoader extends EventTarget {
      * Get security info including chip ID (ESP32-C3 and later)
      */
     async getSecurityInfo() {
-        const [_, responseData] = await this.checkCommand(ESP_GET_SECURITY_INFO, [], 0);
+        const [, responseData] = await this.checkCommand(ESP_GET_SECURITY_INFO, [], 0);
         // Some chips/ROM versions return empty response or don't support this command
         if (responseData.length === 0) {
             throw new Error(`GET_SECURITY_INFO not supported or returned empty response`);
@@ -232,10 +244,12 @@ export class ESPLoader extends EventTarget {
         }
         this._reader = this.port.readable.getReader();
         try {
-            while (true) {
+            let keepReading = true;
+            while (keepReading) {
                 const { value, done } = await this._reader.read();
                 if (done) {
                     this._reader.releaseLock();
+                    keepReading = false;
                     break;
                 }
                 if (!value || value.length === 0) {
@@ -249,11 +263,19 @@ export class ESPLoader extends EventTarget {
                 this._totalBytesRead += value.length;
             }
         }
-        catch (err) {
-            console.error("Read loop got disconnected");
+        catch {
+            this.logger.error("Read loop got disconnected");
         }
         // Disconnected!
         this.connected = false;
+        // Check if this is ESP32-S2 Native USB that needs port reselection
+        // Only trigger reconnect if initialization did NOT succeed (wrong port)
+        if (this._isESP32S2NativeUSB && !this._initializationSucceeded) {
+            this.logger.log("ESP32-S2 Native USB detected - requesting port reselection");
+            this.dispatchEvent(new CustomEvent("esp32s2-usb-reconnect", {
+                detail: { message: "ESP32-S2 Native USB requires port reselection" },
+            }));
+        }
         this.dispatchEvent(new Event("disconnect"));
         this.logger.debug("Finished read loop");
     }
@@ -321,11 +343,11 @@ export class ESPLoader extends EventTarget {
      * The MAC address burned into the OTP memory of the ESP chip
      */
     macAddr() {
-        let macAddr = new Array(6).fill(0);
-        let mac0 = this._efuses[0];
-        let mac1 = this._efuses[1];
-        let mac2 = this._efuses[2];
-        let mac3 = this._efuses[3];
+        const macAddr = new Array(6).fill(0);
+        const mac0 = this._efuses[0];
+        const mac1 = this._efuses[1];
+        const mac2 = this._efuses[2];
+        const mac3 = this._efuses[3];
         let oui;
         if (this.chipFamily == CHIP_FAMILY_ESP8266) {
             if (mac3 != 0) {
@@ -383,9 +405,9 @@ export class ESPLoader extends EventTarget {
         if (this.debug) {
             this.logger.debug("Reading from Register " + toHex(reg, 8));
         }
-        let packet = pack("<I", reg);
+        const packet = pack("<I", reg);
         await this.sendCommand(ESP_READ_REG, packet);
-        let [val, _data] = await this.getResponse(ESP_READ_REG);
+        const [val] = await this.getResponse(ESP_READ_REG);
         return val;
     }
     /**
@@ -397,10 +419,11 @@ export class ESPLoader extends EventTarget {
     async checkCommand(opcode, buffer, checksum = 0, timeout = DEFAULT_TIMEOUT) {
         timeout = Math.min(timeout, MAX_TIMEOUT);
         await this.sendCommand(opcode, buffer, checksum);
-        let [value, data] = await this.getResponse(opcode, timeout);
-        if (data === null) {
+        const [value, responseData] = await this.getResponse(opcode, timeout);
+        if (responseData === null) {
             throw new Error("Didn't get enough status bytes");
         }
+        let data = responseData;
         let statusLen = 0;
         if (this.IS_STUB || this.chipFamily == CHIP_FAMILY_ESP8266) {
             statusLen = 2;
@@ -435,7 +458,7 @@ export class ESPLoader extends EventTarget {
         if (data.length < statusLen) {
             throw new Error("Didn't get enough status bytes");
         }
-        let status = data.slice(-statusLen, data.length);
+        const status = data.slice(-statusLen, data.length);
         data = data.slice(0, -statusLen);
         if (this.debug) {
             this.logger.debug("status", status);
@@ -458,7 +481,7 @@ export class ESPLoader extends EventTarget {
      * does not check response
      */
     async sendCommand(opcode, buffer, checksum = 0) {
-        let packet = slipEncode([
+        const packet = slipEncode([
             ...pack("<BBHI", 0x00, opcode, buffer.length, checksum),
             ...buffer,
         ]);
@@ -477,7 +500,7 @@ export class ESPLoader extends EventTarget {
         let inEscape = false;
         let readBytes = [];
         while (true) {
-            let stamp = Date.now();
+            const stamp = Date.now();
             readBytes = [];
             while (Date.now() - stamp < timeout) {
                 if (this._inputBuffer.length > 0) {
@@ -490,12 +513,12 @@ export class ESPLoader extends EventTarget {
                 }
             }
             if (readBytes.length == 0) {
-                let waitingFor = partialPacket === null ? "header" : "content";
+                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 (let b of readBytes) {
+            for (const b of readBytes) {
                 if (partialPacket === null) {
                     // waiting for packet header
                     if (b == 0xc0) {
@@ -558,7 +581,7 @@ export class ESPLoader extends EventTarget {
             if (packet.length < 8) {
                 continue;
             }
-            const [resp, opRet, _lenRet, val] = unpack("<BBHI", packet.slice(0, 8));
+            const [resp, opRet, , val] = unpack("<BBHI", packet.slice(0, 8));
             if (resp != 1) {
                 continue;
             }
@@ -578,7 +601,7 @@ export class ESPLoader extends EventTarget {
      * Calculate checksum of a blob, as it is defined by the ROM
      */
     checksum(data, state = ESP_CHECKSUM_MAGIC) {
-        for (let b of data) {
+        for (const b of data) {
             state ^= b;
         }
         return state;
@@ -589,11 +612,11 @@ export class ESPLoader extends EventTarget {
         }
         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);
+            const buffer = pack("<II", baud, this.IS_STUB ? ESP_ROM_BAUD : 0);
             await this.checkCommand(ESP_CHANGE_BAUDRATE, buffer);
         }
         catch (e) {
-            console.error(e);
+            this.logger.error(`Baudrate change error: ${e}`);
             throw new Error(`Unable to change the baud rate to ${baud}: No response from set baud rate command.`);
         }
         if (this._parent) {
@@ -636,7 +659,7 @@ export class ESPLoader extends EventTarget {
             this.readLoop();
         }
         catch (e) {
-            console.error(e);
+            this.logger.error(`Reconfigure port error: ${e}`);
             throw new Error(`Unable to change the baud rate to ${baud}: ${e}`);
         }
     }
@@ -648,7 +671,7 @@ export class ESPLoader extends EventTarget {
     async sync() {
         for (let i = 0; i < 5; i++) {
             this._inputBuffer.length = 0;
-            let response = await this._sync();
+            const response = await this._sync();
             if (response) {
                 await sleep(SYNC_TIMEOUT);
                 return true;
@@ -666,12 +689,12 @@ export class ESPLoader extends EventTarget {
         await this.sendCommand(ESP_SYNC, SYNC_PACKET);
         for (let i = 0; i < 8; i++) {
             try {
-                let [_reply, data] = await this.getResponse(ESP_SYNC, SYNC_TIMEOUT);
+                const [, data] = await this.getResponse(ESP_SYNC, SYNC_TIMEOUT);
                 if (data.length > 1 && data[0] == 0 && data[1] == 0) {
                     return true;
                 }
             }
-            catch (err) {
+            catch {
                 // If read packet fails.
             }
         }
@@ -697,13 +720,13 @@ export class ESPLoader extends EventTarget {
     async flashData(binaryData, updateProgress, offset = 0, compress = false) {
         if (binaryData.byteLength >= 8) {
             // unpack the (potential) image header
-            var header = Array.from(new Uint8Array(binaryData, 0, 4));
-            let headerMagic = header[0];
-            let headerFlashMode = header[2];
-            let headerFlashSizeFreq = header[3];
+            const header = Array.from(new Uint8Array(binaryData, 0, 4));
+            const headerMagic = header[0];
+            const headerFlashMode = header[2];
+            const headerFlashSizeFreq = header[3];
             this.logger.log(`Image header, Magic=${toHex(headerMagic)}, FlashMode=${toHex(headerFlashMode)}, FlashSizeFreq=${toHex(headerFlashSizeFreq)}`);
         }
-        let uncompressedFilesize = binaryData.byteLength;
+        const uncompressedFilesize = binaryData.byteLength;
         let compressedFilesize = 0;
         let dataToFlash;
         let timeout = DEFAULT_TIMEOUT;
@@ -724,9 +747,9 @@ export class ESPLoader extends EventTarget {
         let seq = 0;
         let written = 0;
         let position = 0;
-        let stamp = Date.now();
-        let flashWriteSize = this.getFlashWriteSize();
-        let filesize = compress ? compressedFilesize : uncompressedFilesize;
+        const stamp = Date.now();
+        const flashWriteSize = this.getFlashWriteSize();
+        const filesize = compress ? compressedFilesize : uncompressedFilesize;
         while (filesize - position > 0) {
             if (this.debug) {
                 this.logger.log(`Writing at ${toHex(offset + seq * flashWriteSize, 8)} `);
@@ -787,8 +810,7 @@ export class ESPLoader extends EventTarget {
         // Flush serial buffers before flash write operation
         await this.flushSerialBuffers();
         let eraseSize;
-        let buffer;
-        let flashWriteSize = this.getFlashWriteSize();
+        const flashWriteSize = this.getFlashWriteSize();
         if (!this.IS_STUB &&
             [
                 CHIP_FAMILY_ESP32,
@@ -807,22 +829,18 @@ export class ESPLoader extends EventTarget {
             ].includes(this.chipFamily)) {
             await this.checkCommand(ESP_SPI_ATTACH, new Array(8).fill(0));
         }
-        let numBlocks = Math.floor((size + flashWriteSize - 1) / flashWriteSize);
+        const numBlocks = Math.floor((size + flashWriteSize - 1) / flashWriteSize);
         if (this.chipFamily == CHIP_FAMILY_ESP8266) {
             eraseSize = this.getEraseSize(offset, size);
         }
         else {
             eraseSize = size;
         }
-        let timeout;
-        if (this.IS_STUB) {
-            timeout = DEFAULT_TIMEOUT;
-        }
-        else {
-            timeout = timeoutPerMb(ERASE_REGION_TIMEOUT_PER_MB, size);
-        }
-        let stamp = Date.now();
-        buffer = pack("<IIII", eraseSize, numBlocks, flashWriteSize, offset);
+        const timeout = this.IS_STUB
+            ? DEFAULT_TIMEOUT
+            : timeoutPerMb(ERASE_REGION_TIMEOUT_PER_MB, size);
+        const stamp = Date.now();
+        let buffer = pack("<IIII", eraseSize, numBlocks, flashWriteSize, offset);
         if (this.chipFamily == CHIP_FAMILY_ESP32 ||
             this.chipFamily == CHIP_FAMILY_ESP32S2 ||
             this.chipFamily == CHIP_FAMILY_ESP32S3 ||
@@ -858,15 +876,14 @@ export class ESPLoader extends EventTarget {
      * @name flashDeflBegin
      *
      */
-    async flashDeflBegin(size = 0, compressedSize = 0, offset = 0, encrypted = false) {
+    async flashDeflBegin(size = 0, compressedSize = 0, offset = 0) {
         // Start downloading compressed data to Flash (performs an erase)
         // Returns number of blocks to write.
-        let flashWriteSize = this.getFlashWriteSize();
-        let numBlocks = Math.floor((compressedSize + flashWriteSize - 1) / flashWriteSize);
-        let eraseBlocks = Math.floor((size + flashWriteSize - 1) / flashWriteSize);
+        const flashWriteSize = this.getFlashWriteSize();
+        const numBlocks = Math.floor((compressedSize + flashWriteSize - 1) / flashWriteSize);
+        const eraseBlocks = Math.floor((size + flashWriteSize - 1) / flashWriteSize);
         let writeSize = 0;
         let timeout = 0;
-        let buffer;
         if (this.IS_STUB) {
             writeSize = size; // stub expects number of bytes here, manages erasing internally
             timeout = timeoutPerMb(ERASE_REGION_TIMEOUT_PER_MB, writeSize); // ROM performs the erase up front
@@ -875,26 +892,26 @@ export class ESPLoader extends EventTarget {
             writeSize = eraseBlocks * flashWriteSize; // ROM expects rounded up to erase block size
             timeout = DEFAULT_TIMEOUT;
         }
-        buffer = pack("<IIII", writeSize, numBlocks, flashWriteSize, offset);
+        const buffer = pack("<IIII", writeSize, numBlocks, flashWriteSize, offset);
         await this.checkCommand(ESP_FLASH_DEFL_BEGIN, buffer, 0, timeout);
         return timeout;
     }
     async flashFinish() {
-        let buffer = pack("<I", 1);
+        const buffer = pack("<I", 1);
         await this.checkCommand(ESP_FLASH_END, buffer);
     }
     async flashDeflFinish() {
-        let buffer = pack("<I", 1);
+        const buffer = pack("<I", 1);
         await this.checkCommand(ESP_FLASH_DEFL_END, buffer);
     }
     getBootloaderOffset() {
-        let bootFlashOffs = getSpiFlashAddresses(this.getChipFamily());
-        let BootldrFlashOffs = bootFlashOffs.flashOffs;
+        const bootFlashOffs = getSpiFlashAddresses(this.getChipFamily());
+        const BootldrFlashOffs = bootFlashOffs.flashOffs;
         return BootldrFlashOffs;
     }
     async flashId() {
-        let SPIFLASH_RDID = 0x9f;
-        let result = await this.runSpiFlashCommand(SPIFLASH_RDID, [], 24);
+        const SPIFLASH_RDID = 0x9f;
+        const result = await this.runSpiFlashCommand(SPIFLASH_RDID, [], 24);
         return result;
     }
     getChipFamily() {
@@ -904,15 +921,15 @@ export class ESPLoader extends EventTarget {
         let buffer = pack("<IIII", address, value, mask, delayUs);
         if (delayAfterUs > 0) {
             // add a dummy write to a date register as an excuse to have a delay
-            buffer.concat(pack("<IIII", getSpiFlashAddresses(this.getChipFamily()).uartDateReg, 0, 0, delayAfterUs));
+            buffer = buffer.concat(pack("<IIII", getSpiFlashAddresses(this.getChipFamily()).uartDateReg, 0, 0, delayAfterUs));
         }
         await this.checkCommand(ESP_WRITE_REG, buffer);
     }
     async setDataLengths(spiAddresses, mosiBits, misoBits) {
         if (spiAddresses.mosiDlenOffs != -1) {
-            // ESP32/32S2/32S3/32C3 has a more sophisticated way to set up "user" commands
-            let SPI_MOSI_DLEN_REG = spiAddresses.regBase + spiAddresses.mosiDlenOffs;
-            let SPI_MISO_DLEN_REG = spiAddresses.regBase + spiAddresses.misoDlenOffs;
+            // Actual MCUs have a more sophisticated way to set up "user" commands
+            const SPI_MOSI_DLEN_REG = spiAddresses.regBase + spiAddresses.mosiDlenOffs;
+            const SPI_MISO_DLEN_REG = spiAddresses.regBase + spiAddresses.misoDlenOffs;
             if (mosiBits > 0) {
                 await this.writeRegister(SPI_MOSI_DLEN_REG, mosiBits - 1);
             }
@@ -921,18 +938,18 @@ export class ESPLoader extends EventTarget {
             }
         }
         else {
-            let SPI_DATA_LEN_REG = spiAddresses.regBase + spiAddresses.usr1Offs;
-            let SPI_MOSI_BITLEN_S = 17;
-            let SPI_MISO_BITLEN_S = 8;
-            let mosiMask = mosiBits == 0 ? 0 : mosiBits - 1;
-            let misoMask = misoBits == 0 ? 0 : misoBits - 1;
-            let value = (misoMask << SPI_MISO_BITLEN_S) | (mosiMask << SPI_MOSI_BITLEN_S);
+            const SPI_DATA_LEN_REG = spiAddresses.regBase + spiAddresses.usr1Offs;
+            const SPI_MOSI_BITLEN_S = 17;
+            const SPI_MISO_BITLEN_S = 8;
+            const mosiMask = mosiBits == 0 ? 0 : mosiBits - 1;
+            const misoMask = misoBits == 0 ? 0 : misoBits - 1;
+            const value = (misoMask << SPI_MISO_BITLEN_S) | (mosiMask << SPI_MOSI_BITLEN_S);
             await this.writeRegister(SPI_DATA_LEN_REG, value);
         }
     }
     async waitDone(spiCmdReg, spiCmdUsr) {
         for (let i = 0; i < 10; i++) {
-            let cmdValue = await this.readRegister(spiCmdReg);
+            const cmdValue = await this.readRegister(spiCmdReg);
             if ((cmdValue & spiCmdUsr) == 0) {
                 return;
             }
@@ -948,29 +965,29 @@ export class ESPLoader extends EventTarget {
         // After writing command byte, writes 'data' to MOSI and then
         // reads back 'read_bits' of reply on MISO. Result is a number.
         // SPI_USR register flags
-        let SPI_USR_COMMAND = 1 << 31;
-        let SPI_USR_MISO = 1 << 28;
-        let SPI_USR_MOSI = 1 << 27;
-        // SPI registers, base address differs ESP32* vs 8266
-        let spiAddresses = getSpiFlashAddresses(this.getChipFamily());
-        let base = spiAddresses.regBase;
-        let SPI_CMD_REG = base;
-        let SPI_USR_REG = base + spiAddresses.usrOffs;
-        let SPI_USR2_REG = base + spiAddresses.usr2Offs;
-        let SPI_W0_REG = base + spiAddresses.w0Offs;
+        const SPI_USR_COMMAND = 1 << 31;
+        const SPI_USR_MISO = 1 << 28;
+        const SPI_USR_MOSI = 1 << 27;
+        // SPI registers, base address differs
+        const spiAddresses = getSpiFlashAddresses(this.getChipFamily());
+        const base = spiAddresses.regBase;
+        const SPI_CMD_REG = base;
+        const SPI_USR_REG = base + spiAddresses.usrOffs;
+        const SPI_USR2_REG = base + spiAddresses.usr2Offs;
+        const SPI_W0_REG = base + spiAddresses.w0Offs;
         // SPI peripheral "command" bitmasks for SPI_CMD_REG
-        let SPI_CMD_USR = 1 << 18;
+        const SPI_CMD_USR = 1 << 18;
         // shift values
-        let SPI_USR2_COMMAND_LEN_SHIFT = 28;
+        const SPI_USR2_COMMAND_LEN_SHIFT = 28;
         if (readBits > 32) {
             throw new Error("Reading more than 32 bits back from a SPI flash operation is unsupported");
         }
         if (data.length > 64) {
             throw new Error("Writing more than 64 bytes of data with one SPI command is unsupported");
         }
-        let dataBits = data.length * 8;
-        let oldSpiUsr = await this.readRegister(SPI_USR_REG);
-        let oldSpiUsr2 = await this.readRegister(SPI_USR2_REG);
+        const dataBits = data.length * 8;
+        const oldSpiUsr = await this.readRegister(SPI_USR_REG);
+        const oldSpiUsr2 = await this.readRegister(SPI_USR2_REG);
         let flags = SPI_USR_COMMAND;
         if (readBits > 0) {
             flags |= SPI_USR_MISO;
@@ -985,8 +1002,9 @@ export class ESPLoader extends EventTarget {
             await this.writeRegister(SPI_W0_REG, 0); // clear data register before we read it
         }
         else {
-            data.concat(new Array(data.length % 4).fill(0x00)); // pad to 32-bit multiple
-            let words = unpack("I".repeat(Math.floor(data.length / 4)), data);
+            const padLen = (4 - (data.length % 4)) % 4;
+            data = data.concat(new Array(padLen).fill(0x00)); // pad to 32-bit multiple
+            const words = unpack("I".repeat(Math.floor(data.length / 4)), data);
             let nextReg = SPI_W0_REG;
             this.logger.debug(`Words Length: ${words.length}`);
             for (const word of words) {
@@ -997,7 +1015,7 @@ export class ESPLoader extends EventTarget {
         }
         await this.writeRegister(SPI_CMD_REG, SPI_CMD_USR);
         await this.waitDone(SPI_CMD_REG, SPI_CMD_USR);
-        let status = await this.readRegister(SPI_W0_REG);
+        const status = await this.readRegister(SPI_W0_REG);
         // restore some SPI controller registers
         await this.writeRegister(SPI_USR_REG, oldSpiUsr);
         await this.writeRegister(SPI_USR2_REG, oldSpiUsr2);
@@ -1005,9 +1023,9 @@ export class ESPLoader extends EventTarget {
     }
     async detectFlashSize() {
         this.logger.log("Detecting Flash Size");
-        let flashId = await this.flashId();
-        let manufacturer = flashId & 0xff;
-        let flashIdLowbyte = (flashId >> 16) & 0xff;
+        const flashId = await this.flashId();
+        const manufacturer = flashId & 0xff;
+        const flashIdLowbyte = (flashId >> 16) & 0xff;
         this.logger.log(`FlashId: ${toHex(flashId)}`);
         this.logger.log(`Flash Manufacturer: ${manufacturer.toString(16)}`);
         this.logger.log(`Flash Device: ${((flashId >> 8) & 0xff).toString(16)}${flashIdLowbyte.toString(16)}`);
@@ -1020,10 +1038,10 @@ export class ESPLoader extends EventTarget {
      *   Provides a workaround for the bootloader erase bug on ESP8266.
      */
     getEraseSize(offset, size) {
-        let sectorsPerBlock = 16;
-        let sectorSize = FLASH_SECTOR_SIZE;
-        let numSectors = Math.floor((size + sectorSize - 1) / sectorSize);
-        let startSector = Math.floor(offset / sectorSize);
+        const sectorsPerBlock = 16;
+        const sectorSize = FLASH_SECTOR_SIZE;
+        const numSectors = Math.floor((size + sectorSize - 1) / sectorSize);
+        const startSector = Math.floor(offset / sectorSize);
         let headSectors = sectorsPerBlock - (startSector % sectorsPerBlock);
         if (numSectors < headSectors) {
             headSectors = numSectors;
@@ -1057,8 +1075,8 @@ export class ESPLoader extends EventTarget {
      * ignore errors.
      */
     async memFinish(entrypoint = 0) {
-        let timeout = this.IS_STUB ? DEFAULT_TIMEOUT : MEM_END_ROM_TIMEOUT;
-        let data = pack("<II", entrypoint == 0 ? 1 : 0, entrypoint);
+        const timeout = this.IS_STUB ? DEFAULT_TIMEOUT : MEM_END_ROM_TIMEOUT;
+        const data = pack("<II", entrypoint == 0 ? 1 : 0, entrypoint);
         return await this.checkCommand(ESP_MEM_END, data, 0, timeout);
     }
     async runStub(skipFlashDetection = false) {
@@ -1069,29 +1087,27 @@ export class ESPLoader extends EventTarget {
             return this;
         }
         // We're transferring over USB, right?
-        let ramBlock = USB_RAM_BLOCK;
+        const ramBlock = USB_RAM_BLOCK;
         // Upload
         this.logger.log("Uploading stub...");
-        for (let field of ["text", "data"]) {
-            if (Object.keys(stub).includes(field)) {
-                let offset = stub[field + "_start"];
-                let length = stub[field].length;
-                let blocks = Math.floor((length + ramBlock - 1) / ramBlock);
-                await this.memBegin(length, blocks, ramBlock, offset);
-                for (let seq of Array(blocks).keys()) {
-                    let fromOffs = seq * ramBlock;
-                    let toOffs = fromOffs + ramBlock;
-                    if (toOffs > length) {
-                        toOffs = length;
-                    }
-                    await this.memBlock(stub[field].slice(fromOffs, toOffs), seq);
+        for (const field of ["text", "data"]) {
+            const fieldData = stub[field];
+            const offset = stub[`${field}_start`];
+            const length = fieldData.length;
+            const blocks = Math.floor((length + ramBlock - 1) / ramBlock);
+            await this.memBegin(length, blocks, ramBlock, offset);
+            for (const seq of Array(blocks).keys()) {
+                const fromOffs = seq * ramBlock;
+                let toOffs = fromOffs + ramBlock;
+                if (toOffs > length) {
+                    toOffs = length;
                 }
+                await this.memBlock(fieldData.slice(fromOffs, toOffs), seq);
             }
         }
-        await this.memFinish(stub["entry"]);
-        let pChar;
+        await this.memFinish(stub.entry);
         const p = await this.readPacket(500);
-        pChar = String.fromCharCode(...p);
+        const pChar = String.fromCharCode(...p);
         if (pChar != "OHAI") {
             throw new Error("Failed to start stub. Unexpected response: " + pChar);
         }
@@ -1104,13 +1120,17 @@ export class ESPLoader extends EventTarget {
         return espStubLoader;
     }
     async writeToStream(data) {
+        if (!this.port.writable) {
+            this.logger.debug("Port writable stream not available, skipping write");
+            return;
+        }
         const writer = this.port.writable.getWriter();
         await writer.write(new Uint8Array(data));
         try {
             writer.releaseLock();
         }
         catch (err) {
-            console.error("Ignoring release lock error", err);
+            this.logger.error(`Ignoring release lock error: ${err}`);
         }
     }
     async disconnect() {
@@ -1118,6 +1138,10 @@ export class ESPLoader extends EventTarget {
             await this._parent.disconnect();
             return;
         }
+        if (!this.port.writable) {
+            this.logger.debug("Port already closed, skipping disconnect");
+            return;
+        }
         await this.port.writable.getWriter().close();
         await new Promise((resolve) => {
             if (!this._reader) {
@@ -1150,7 +1174,6 @@ export class ESPLoader extends EventTarget {
             }
             this._reader = undefined;
         }
-        await sleep(SYNC_TIMEOUT);
         // Close port
         try {
             await this.port.close();
@@ -1159,8 +1182,6 @@ export class ESPLoader extends EventTarget {
         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 {
@@ -1170,8 +1191,6 @@ export class ESPLoader extends EventTarget {
         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})`);
@@ -1182,7 +1201,7 @@ export class ESPLoader extends EventTarget {
         const savedChipRevision = this.chipRevision;
         const savedChipVariant = this.chipVariant;
         const savedFlashSize = this.flashSize;
-        // Reinitialize without chip detection
+        // Reinitialize
         await this.hardReset(true);
         if (!this._parent) {
             this.__inputBuffer = [];
@@ -1191,7 +1210,7 @@ export class ESPLoader extends EventTarget {
         }
         await this.flushSerialBuffers();
         await this.sync();
-        // Restore chip info (skip detection)
+        // Restore chip info
         this.chipFamily = savedChipFamily;
         this.chipName = savedChipName;
         this.chipRevision = savedChipRevision;
@@ -1202,14 +1221,12 @@ export class ESPLoader extends EventTarget {
         if (!this.port.writable || !this.port.readable) {
             throw new Error("Port not ready after reconnect");
         }
-        // Load stub (skip flash detection)
+        // Load stub
         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})`);
@@ -1227,18 +1244,12 @@ export class ESPLoader extends EventTarget {
      * This clears both the application RX buffer and waits for hardware buffers to drain
      */
     async flushSerialBuffers() {
-        // Clear application RX buffer
+        // Clear application buffer
         if (!this._parent) {
             this.__inputBuffer = [];
         }
-        // Wait for any pending TX operations and in-flight RX data
+        // Wait for any pending 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 = [];
@@ -1257,20 +1268,6 @@ export class ESPLoader extends EventTarget {
         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)}...`);
@@ -1279,16 +1276,6 @@ export class ESPLoader extends EventTarget {
         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;
@@ -1298,8 +1285,8 @@ export class ESPLoader extends EventTarget {
                 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);
+                    const 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);
                     }
@@ -1371,7 +1358,7 @@ export class ESPLoader extends EventTarget {
             }
             currentAddr += chunkSize;
             remainingSize -= chunkSize;
-            this.logger.debug(`Total progress: 0x${allData.length.toString(16)}/0x${size.toString(16)} bytes`);
+            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;
@@ -1390,17 +1377,17 @@ class EspStubLoader extends ESPLoader {
      * @name memBegin (592)
      * Start downloading an application image to RAM
      */
-    async memBegin(size, blocks, blocksize, offset) {
-        let stub = await getStubCode(this.chipFamily, this.chipRevision);
+    async memBegin(size, _blocks, _blocksize, offset) {
+        const stub = await getStubCode(this.chipFamily, this.chipRevision);
         // Stub may be null for chips without stub support
         if (stub === null) {
-            return;
+            return [0, []];
         }
-        let load_start = offset;
-        let load_end = offset + size;
-        console.log(load_start, load_end);
-        console.log(stub.data_start, stub.data.length, stub.text_start, stub.text.length);
-        for (let [start, end] of [
+        const load_start = offset;
+        const load_end = offset + size;
+        this.logger.debug(`Load range: ${toHex(load_start, 8)}-${toHex(load_end, 8)}`);
+        this.logger.debug(`Stub data: ${toHex(stub.data_start, 8)}, len: ${stub.data.length}, text: ${toHex(stub.text_start, 8)}, len: ${stub.text.length}`);
+        for (const [start, end] of [
             [stub.data_start, stub.data_start + stub.data.length],
             [stub.text_start, stub.text_start + stub.text.length],
         ]) {
@@ -1418,6 +1405,7 @@ class EspStubLoader extends ESPLoader {
                     "Try changing the binary loading address.");
             }
         }
+        return [0, []];
     }
     /**
      * @name getEraseSize