tasmota-webserial-esptool 7.0.1 → 7.2.0

package/src/esp_loader.ts

@@ -62,7 +62,7 @@ import {
 } 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";
 
@@ -83,6 +83,8 @@ export class ESPLoader extends EventTarget {
   private _currentBaudRate: number = ESP_ROM_BAUD;
   private _maxUSBSerialBaudrate?: number;
   private _reader?: ReadableStreamDefaultReader<Uint8Array>;
+  private _isESP32S2NativeUSB: boolean = false;
+  private _initializationSucceeded: boolean = false;
 
   constructor(
     public port: SerialPort,
@@ -121,8 +123,13 @@ export class ESPLoader extends EventTarget {
     > = {
       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
@@ -179,6 +186,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.
@@ -193,8 +204,8 @@ export class ESPLoader extends EventTarget {
     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);
     }
@@ -202,6 +213,9 @@ export class ESPLoader extends EventTarget {
     this.logger.debug(
       `Bootloader flash offset: 0x${FlAddr.flashOffs.toString(16)}`,
     );
+
+    // Mark initialization as successful
+    this._initializationSucceeded = true;
   }
 
   /**
@@ -241,10 +255,10 @@ 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}`,
+        `GET_SECURITY_INFO failed, using magic value detection: ${error}`,
       );
 
       // Clear input buffer and re-sync to recover from failed command
@@ -261,9 +275,9 @@ export class ESPLoader extends EventTarget {
       }
     }
 
-    // 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(
@@ -275,7 +289,6 @@ export class ESPLoader extends EventTarget {
     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}`);
@@ -325,7 +338,7 @@ export class ESPLoader extends EventTarget {
     chipId: number;
     apiVersion: number;
   }> {
-    const [_, responseData] = await this.checkCommand(
+    const [, responseData] = await this.checkCommand(
       ESP_GET_SECURITY_INFO,
       [],
       0,
@@ -377,10 +390,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) {
@@ -395,11 +410,25 @@ export class ESPLoader extends EventTarget {
         // Track total bytes read from serial port
         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");
   }
@@ -474,11 +503,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) {
@@ -534,9 +563,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;
   }
 
@@ -554,12 +583,13 @@ export class ESPLoader extends EventTarget {
   ): Promise<[number, number[]]> {
     timeout = Math.min(timeout, MAX_TIMEOUT);
     await this.sendCommand(opcode, buffer, checksum);
-    let [value, data] = await this.getResponse(opcode, timeout);
+    const [value, responseData] = await this.getResponse(opcode, timeout);
 
-    if (data === null) {
+    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) {
@@ -595,7 +625,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);
@@ -619,7 +649,7 @@ export class ESPLoader extends EventTarget {
    * does not check response
    */
   async sendCommand(opcode: number, buffer: number[], checksum = 0) {
-    let packet = slipEncode([
+    const packet = slipEncode([
       ...pack("<BBHI", 0x00, opcode, buffer.length, checksum),
       ...buffer,
     ]);
@@ -643,7 +673,7 @@ export class ESPLoader extends EventTarget {
     let inEscape = false;
     let readBytes: number[] = [];
     while (true) {
-      let stamp = Date.now();
+      const stamp = Date.now();
       readBytes = [];
       while (Date.now() - stamp < timeout) {
         if (this._inputBuffer.length > 0) {
@@ -655,14 +685,14 @@ 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) {
@@ -738,7 +768,7 @@ export class ESPLoader extends EventTarget {
         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;
       }
@@ -759,7 +789,7 @@ export class ESPLoader extends EventTarget {
    * Calculate checksum of a blob, as it is defined by the ROM
    */
   checksum(data: number[], state = ESP_CHECKSUM_MAGIC) {
-    for (let b of data) {
+    for (const b of data) {
       state ^= b;
     }
     return state;
@@ -772,10 +802,10 @@ 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.`,
       );
@@ -828,7 +858,7 @@ export class ESPLoader extends EventTarget {
       // Restart Readloop
       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}`);
     }
   }
@@ -841,7 +871,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;
@@ -861,11 +891,11 @@ 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.
       }
     }
@@ -898,10 +928,10 @@ export class ESPLoader extends EventTarget {
   ) {
     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(
@@ -910,7 +940,7 @@ export class ESPLoader extends EventTarget {
       );
     }
 
-    let uncompressedFilesize = binaryData.byteLength;
+    const uncompressedFilesize = binaryData.byteLength;
     let compressedFilesize = 0;
 
     let dataToFlash;
@@ -939,10 +969,10 @@ export class ESPLoader extends EventTarget {
     let seq = 0;
     let written = 0;
     let position = 0;
-    let stamp = Date.now();
-    let flashWriteSize = this.getFlashWriteSize();
+    const stamp = Date.now();
+    const flashWriteSize = this.getFlashWriteSize();
 
-    let filesize = compress ? compressedFilesize : uncompressedFilesize;
+    const filesize = compress ? compressedFilesize : uncompressedFilesize;
 
     while (filesize - position > 0) {
       if (this.debug) {
@@ -1028,8 +1058,7 @@ export class ESPLoader extends EventTarget {
     await this.flushSerialBuffers();
 
     let eraseSize;
-    let buffer;
-    let flashWriteSize = this.getFlashWriteSize();
+    const flashWriteSize = this.getFlashWriteSize();
     if (
       !this.IS_STUB &&
       [
@@ -1050,22 +1079,19 @@ export class ESPLoader extends EventTarget {
     ) {
       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);
-    }
+    const timeout = this.IS_STUB
+      ? DEFAULT_TIMEOUT
+      : timeoutPerMb(ERASE_REGION_TIMEOUT_PER_MB, size);
 
-    let stamp = Date.now();
-    buffer = pack("<IIII", eraseSize, numBlocks, flashWriteSize, offset);
+    const stamp = Date.now();
+    let buffer = pack("<IIII", eraseSize, numBlocks, flashWriteSize, offset);
     if (
       this.chipFamily == CHIP_FAMILY_ESP32 ||
       this.chipFamily == CHIP_FAMILY_ESP32S2 ||
@@ -1109,22 +1135,18 @@ export class ESPLoader extends EventTarget {
    *
    */
 
-  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(
+    const flashWriteSize = this.getFlashWriteSize();
+    const numBlocks = Math.floor(
       (compressedSize + flashWriteSize - 1) / flashWriteSize,
     );
-    let eraseBlocks = Math.floor((size + 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
@@ -1133,7 +1155,7 @@ 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);
 
@@ -1141,24 +1163,24 @@ export class ESPLoader extends EventTarget {
   }
 
   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;
   }
 
@@ -1176,7 +1198,7 @@ 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(
+      buffer = buffer.concat(
         pack(
           "<IIII",
           getSpiFlashAddresses(this.getChipFamily()).uartDateReg,
@@ -1195,9 +1217,11 @@ export class ESPLoader extends EventTarget {
     misoBits: number,
   ) {
     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);
       }
@@ -1205,19 +1229,19 @@ export class ESPLoader extends EventTarget {
         await this.writeRegister(SPI_MISO_DLEN_REG, misoBits - 1);
       }
     } 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 =
+      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: number, spiCmdUsr: number) {
     for (let i = 0; i < 10; i++) {
-      let cmdValue = await this.readRegister(spiCmdReg);
+      const cmdValue = await this.readRegister(spiCmdReg);
       if ((cmdValue & spiCmdUsr) == 0) {
         return;
       }
@@ -1241,23 +1265,23 @@ export class ESPLoader extends EventTarget {
     // 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(
@@ -1270,9 +1294,9 @@ export class ESPLoader extends EventTarget {
       );
     }
 
-    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;
 
@@ -1293,9 +1317,10 @@ export class ESPLoader extends EventTarget {
     if (dataBits == 0) {
       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
+      const padLen = (4 - (data.length % 4)) % 4;
+      data = data.concat(new Array(padLen).fill(0x00)); // pad to 32-bit multiple
 
-      let words = unpack("I".repeat(Math.floor(data.length / 4)), data);
+      const words = unpack("I".repeat(Math.floor(data.length / 4)), data);
       let nextReg = SPI_W0_REG;
 
       this.logger.debug(`Words Length: ${words.length}`);
@@ -1311,7 +1336,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);
@@ -1320,9 +1345,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)}`);
@@ -1342,10 +1367,10 @@ export class ESPLoader extends EventTarget {
    *   Provides a workaround for the bootloader erase bug on ESP8266.
    */
   getEraseSize(offset: number, size: number) {
-    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) {
@@ -1397,16 +1422,13 @@ 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): Promise<EspStubLoader> {
-    const stub: Record<string, any> | null = await getStubCode(
-      this.chipFamily,
-      this.chipRevision,
-    );
+    const stub = await getStubCode(this.chipFamily, this.chipRevision);
 
     // No stub available for this chip, return ROM loader
     if (stub === null) {
@@ -1417,32 +1439,29 @@ export class ESPLoader extends EventTarget {
     }
 
     // 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"] as const) {
+      const fieldData = stub[field];
+      const offset = stub[`${field}_start` as "text_start" | "data_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: string;
+    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);
@@ -1459,12 +1478,16 @@ export class ESPLoader extends EventTarget {
   }
 
   async writeToStream(data: number[]) {
-    const writer = this.port.writable!.getWriter();
+    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}`);
     }
   }
 
@@ -1473,7 +1496,11 @@ export class ESPLoader extends EventTarget {
       await this._parent.disconnect();
       return;
     }
-    await this.port.writable!.getWriter().close();
+    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) {
         resolve(undefined);
@@ -1509,8 +1536,6 @@ export class ESPLoader extends EventTarget {
       this._reader = undefined;
     }
 
-    await sleep(SYNC_TIMEOUT);
-
     // Close port
     try {
       await this.port.close();
@@ -1519,9 +1544,6 @@ export class ESPLoader extends EventTarget {
       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 {
@@ -1531,9 +1553,6 @@ export class ESPLoader extends EventTarget {
       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(
@@ -1548,7 +1567,7 @@ export class ESPLoader extends EventTarget {
     const savedChipVariant = this.chipVariant;
     const savedFlashSize = this.flashSize;
 
-    // Reinitialize without chip detection
+    // Reinitialize
     await this.hardReset(true);
 
     if (!this._parent) {
@@ -1560,7 +1579,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;
@@ -1574,7 +1593,7 @@ export class ESPLoader extends EventTarget {
       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");
 
@@ -1582,9 +1601,6 @@ export class ESPLoader extends EventTarget {
     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(
@@ -1606,22 +1622,14 @@ export class ESPLoader extends EventTarget {
    * This clears both the application RX buffer and waits for hardware buffers to drain
    */
   private async flushSerialBuffers(): Promise<void> {
-    // 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 = [];
@@ -1653,22 +1661,6 @@ export class ESPLoader extends EventTarget {
       );
     }
 
-    // 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();
 
@@ -1683,18 +1675,6 @@ export class ESPLoader extends EventTarget {
     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;
@@ -1708,8 +1688,8 @@ export class ESPLoader extends EventTarget {
           );
 
           // 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);
@@ -1798,7 +1778,7 @@ export class ESPLoader extends EventTarget {
       remainingSize -= chunkSize;
 
       this.logger.debug(
-        `Total progress: 0x${allData.length.toString(16)}/0x${size.toString(16)} bytes`,
+        `Total progress: 0x${allData.length.toString(16)} from 0x${size.toString(16)} bytes`,
       );
     }
 
@@ -1820,27 +1800,26 @@ class EspStubLoader extends ESPLoader {
    */
   async memBegin(
     size: number,
-    blocks: number,
-    blocksize: number,
+    _blocks: number,
+    _blocksize: number,
     offset: number,
-  ): Promise<any> {
-    let stub = await getStubCode(this.chipFamily, this.chipRevision);
+  ): Promise<[number, number[]]> {
+    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,
+    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 (let [start, end] of [
+    for (const [start, end] of [
       [stub.data_start, stub.data_start + stub.data.length],
       [stub.text_start, stub.text_start + stub.text.length],
     ]) {
@@ -1860,6 +1839,7 @@ class EspStubLoader extends ESPLoader {
         );
       }
     }
+    return [0, []];
   }
 
   /**