tasmota-webserial-esptool 9.1.8 → 9.1.9

package/dist/esp_loader.js

@@ -25,8 +25,7 @@ export class ESPLoader extends EventTarget {
         this.__commandLock = Promise.resolve([0, []]);
         this.__isReconfiguring = false;
         this.__abandonCurrentOperation = false;
-        // Adaptive speed adjustment for flash read operations - DISABLED
-        // Using fixed conservative values that work reliably
+        // Adaptive speed adjustment for flash read operations
         this.__adaptiveBlockMultiplier = 1;
         this.__adaptiveMaxInFlightMultiplier = 1;
         this.__consecutiveSuccessfulChunks = 0;
@@ -37,6 +36,7 @@ export class ESPLoader extends EventTarget {
         this.__writeChain = Promise.resolve();
     }
     // Chip properties with parent delegation
+    // chipFamily accessed before initialization as designed
     get chipFamily() {
         return this._parent ? this._parent.chipFamily : this.__chipFamily;
     }
@@ -82,7 +82,13 @@ export class ESPLoader extends EventTarget {
         }
     }
     get _inputBuffer() {
-        return this._parent ? this._parent._inputBuffer : this.__inputBuffer;
+        if (this._parent) {
+            return this._parent._inputBuffer;
+        }
+        if (this.__inputBuffer === undefined) {
+            throw new Error("_inputBuffer accessed before initialization");
+        }
+        return this.__inputBuffer;
     }
     get _inputBufferReadIndex() {
         return this._parent
@@ -756,28 +762,28 @@ export class ESPLoader extends EventTarget {
                     // Strategy 1: USB-JTAG/Serial (works in CDC mode on Desktop)
                     resetStrategies.push({
                         name: "USB-JTAG/Serial (WebUSB) - ESP32-S2",
-                        fn: async function () {
+                        fn: async () => {
                             return await self.hardResetUSBJTAGSerialWebUSB();
                         },
                     });
                     // Strategy 2: USB-JTAG/Serial Inverted DTR (works in JTAG mode)
                     resetStrategies.push({
                         name: "USB-JTAG/Serial Inverted DTR (WebUSB) - ESP32-S2",
-                        fn: async function () {
+                        fn: async () => {
                             return await self.hardResetUSBJTAGSerialInvertedDTRWebUSB();
                         },
                     });
                     // Strategy 3: UnixTight (CDC fallback)
                     resetStrategies.push({
                         name: "UnixTight (WebUSB) - ESP32-S2 CDC",
-                        fn: async function () {
+                        fn: async () => {
                             return await self.hardResetUnixTightWebUSB();
                         },
                     });
                     // Strategy 4: Classic reset (CDC fallback)
                     resetStrategies.push({
                         name: "Classic (WebUSB) - ESP32-S2 CDC",
-                        fn: async function () {
+                        fn: async () => {
                             return await self.hardResetClassicWebUSB();
                         },
                     });
@@ -786,19 +792,19 @@ export class ESPLoader extends EventTarget {
                     // Other USB-JTAG chips: Try Inverted DTR first - works best for ESP32-H2 and other JTAG chips
                     resetStrategies.push({
                         name: "USB-JTAG/Serial Inverted DTR (WebUSB)",
-                        fn: async function () {
+                        fn: async () => {
                             return await self.hardResetUSBJTAGSerialInvertedDTRWebUSB();
                         },
                     });
                     resetStrategies.push({
                         name: "USB-JTAG/Serial (WebUSB)",
-                        fn: async function () {
+                        fn: async () => {
                             return await self.hardResetUSBJTAGSerialWebUSB();
                         },
                     });
                     resetStrategies.push({
                         name: "Inverted DTR Classic (WebUSB)",
-                        fn: async function () {
+                        fn: async () => {
                             return await self.hardResetInvertedDTRWebUSB();
                         },
                     });
@@ -810,31 +816,31 @@ export class ESPLoader extends EventTarget {
                     // CH340/CH343: UnixTight works best (like CP2102)
                     resetStrategies.push({
                         name: "UnixTight (WebUSB) - CH34x",
-                        fn: async function () {
+                        fn: async () => {
                             return await self.hardResetUnixTightWebUSB();
                         },
                     });
                     resetStrategies.push({
                         name: "Classic (WebUSB) - CH34x",
-                        fn: async function () {
+                        fn: async () => {
                             return await self.hardResetClassicWebUSB();
                         },
                     });
                     resetStrategies.push({
                         name: "Inverted Both (WebUSB) - CH34x",
-                        fn: async function () {
+                        fn: async () => {
                             return await self.hardResetInvertedWebUSB();
                         },
                     });
                     resetStrategies.push({
                         name: "Inverted RTS (WebUSB) - CH34x",
-                        fn: async function () {
+                        fn: async () => {
                             return await self.hardResetInvertedRTSWebUSB();
                         },
                     });
                     resetStrategies.push({
                         name: "Inverted DTR (WebUSB) - CH34x",
-                        fn: async function () {
+                        fn: async () => {
                             return await self.hardResetInvertedDTRWebUSB();
                         },
                     });
@@ -844,31 +850,31 @@ export class ESPLoader extends EventTarget {
                     // Try it first, then fallback to other strategies
                     resetStrategies.push({
                         name: "UnixTight (WebUSB) - CP2102",
-                        fn: async function () {
+                        fn: async () => {
                             return await self.hardResetUnixTightWebUSB();
                         },
                     });
                     resetStrategies.push({
                         name: "Classic (WebUSB) - CP2102",
-                        fn: async function () {
+                        fn: async () => {
                             return await self.hardResetClassicWebUSB();
                         },
                     });
                     resetStrategies.push({
                         name: "Inverted Both (WebUSB) - CP2102",
-                        fn: async function () {
+                        fn: async () => {
                             return await self.hardResetInvertedWebUSB();
                         },
                     });
                     resetStrategies.push({
                         name: "Inverted RTS (WebUSB) - CP2102",
-                        fn: async function () {
+                        fn: async () => {
                             return await self.hardResetInvertedRTSWebUSB();
                         },
                     });
                     resetStrategies.push({
                         name: "Inverted DTR (WebUSB) - CP2102",
-                        fn: async function () {
+                        fn: async () => {
                             return await self.hardResetInvertedDTRWebUSB();
                         },
                     });
@@ -877,7 +883,7 @@ export class ESPLoader extends EventTarget {
                     // For other USB-Serial chips, try UnixTight first, then multiple strategies
                     resetStrategies.push({
                         name: "UnixTight (WebUSB)",
-                        fn: async function () {
+                        fn: async () => {
                             return await self.hardResetUnixTightWebUSB();
                         },
                     });
@@ -951,7 +957,6 @@ export class ESPLoader extends EventTarget {
             }
         }
         else {
-            // Web Serial (Desktop) strategies
             // Strategy: USB-JTAG/Serial reset
             if (isUSBJTAGSerial || isEspressifUSB) {
                 resetStrategies.push({
@@ -1046,9 +1051,9 @@ export class ESPLoader extends EventTarget {
             // just reset (no bootloader mode)
             if (this.isWebUSB()) {
                 // WebUSB: Use longer delays for better compatibility
-                await this.setRTS(true); // EN->LOW
+                await this.setRTSWebUSB(true); // EN->LOW
                 await this.sleep(200);
-                await this.setRTS(false);
+                await this.setRTSWebUSB(false);
                 await this.sleep(200);
                 this.logger.log("Hard reset (WebUSB).");
             }
@@ -2171,7 +2176,15 @@ export class ESPLoader extends EventTarget {
                 resolve(undefined);
                 return;
             }
-            this.addEventListener("disconnect", resolve, { once: true });
+            // Set a timeout to prevent hanging (important for node-usb)
+            const timeout = setTimeout(() => {
+                this.logger.debug("Disconnect timeout - forcing resolution");
+                resolve(undefined);
+            }, 1000);
+            this.addEventListener("disconnect", () => {
+                clearTimeout(timeout);
+                resolve(undefined);
+            }, { once: true });
             // Only cancel if reader is still active
             try {
                 this._reader.cancel();
@@ -2179,10 +2192,19 @@ export class ESPLoader extends EventTarget {
             catch (err) {
                 this.logger.debug(`Reader cancel error: ${err}`);
                 // Reader already released, resolve immediately
+                clearTimeout(timeout);
                 resolve(undefined);
             }
         });
         this.connected = false;
+        // Close the port (important for node-usb adapter)
+        try {
+            await this.port.close();
+            this.logger.debug("Port closed successfully");
+        }
+        catch (err) {
+            this.logger.debug(`Port close error: ${err}`);
+        }
     }
     /**
      * @name reconnectAndResume
@@ -2701,6 +2723,10 @@ class EspStubLoader extends ESPLoader {
         if (size > maxValue) {
             throw new Error(`Size ${size} exceeds maximum value ${maxValue}`);
         }
+        // Check for wrap-around
+        if (offset + size > maxValue) {
+            throw new Error(`Region end (offset + size = ${offset + size}) exceeds maximum addressable range ${maxValue}`);
+        }
         const timeout = timeoutPerMb(ERASE_REGION_TIMEOUT_PER_MB, size);
         const buffer = pack("<II", offset, size);
         await this.checkCommand(ESP_ERASE_REGION, buffer, 0, timeout);

package/dist/index.d.ts

@@ -2,6 +2,6 @@ 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_ESP32H4, CHIP_FAMILY_ESP32H21, CHIP_FAMILY_ESP32P4, CHIP_FAMILY_ESP32S31, } 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, ESP_FLASH_BEGIN, ESP_FLASH_DATA, ESP_FLASH_END, ESP_MEM_BEGIN, ESP_MEM_END, ESP_MEM_DATA, ESP_SYNC, ESP_WRITE_REG, ESP_READ_REG, ESP_ERASE_FLASH, ESP_ERASE_REGION, ESP_READ_FLASH, ESP_SPI_SET_PARAMS, ESP_SPI_ATTACH, ESP_CHANGE_BAUDRATE, ESP_SPI_FLASH_MD5, ESP_GET_SECURITY_INFO, ESP_CHECKSUM_MAGIC, ESP_FLASH_DEFL_BEGIN, ESP_FLASH_DEFL_DATA, ESP_FLASH_DEFL_END, ROM_INVALID_RECV_MSG, USB_RAM_BLOCK, ESP_RAM_BLOCK, DEFAULT_TIMEOUT, CHIP_ERASE_TIMEOUT, MAX_TIMEOUT, SYNC_TIMEOUT, ERASE_REGION_TIMEOUT_PER_MB, MEM_END_ROM_TIMEOUT, FLASH_READ_TIMEOUT, } from "./const";
 export declare const connect: (logger: Logger) => Promise<ESPLoader>;
 export declare const connectWithPort: (port: SerialPort, logger: Logger) => Promise<ESPLoader>;

package/dist/index.js

@@ -2,30 +2,34 @@
 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_ESP32H4, CHIP_FAMILY_ESP32H21, CHIP_FAMILY_ESP32P4, CHIP_FAMILY_ESP32S31, } 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, 
+// Command constants
+ESP_FLASH_BEGIN, ESP_FLASH_DATA, ESP_FLASH_END, ESP_MEM_BEGIN, ESP_MEM_END, ESP_MEM_DATA, ESP_SYNC, ESP_WRITE_REG, ESP_READ_REG, ESP_ERASE_FLASH, ESP_ERASE_REGION, ESP_READ_FLASH, ESP_SPI_SET_PARAMS, ESP_SPI_ATTACH, ESP_CHANGE_BAUDRATE, ESP_SPI_FLASH_MD5, ESP_GET_SECURITY_INFO, ESP_CHECKSUM_MAGIC, ESP_FLASH_DEFL_BEGIN, ESP_FLASH_DEFL_DATA, ESP_FLASH_DEFL_END, ROM_INVALID_RECV_MSG, 
+// Block size constants
+USB_RAM_BLOCK, ESP_RAM_BLOCK, 
+// Timeout constants
+DEFAULT_TIMEOUT, CHIP_ERASE_TIMEOUT, MAX_TIMEOUT, SYNC_TIMEOUT, ERASE_REGION_TIMEOUT_PER_MB, MEM_END_ROM_TIMEOUT, FLASH_READ_TIMEOUT, } from "./const";
 export const connect = async (logger) => {
+    // - Request a port and open a connection.
+    // Try to use requestSerialPort if available (supports WebUSB for Android)
     let port;
-    // Check if a custom requestSerialPort function is available (e.g., from WebUSB wrapper)
     const customRequestPort = globalThis.requestSerialPort;
     if (typeof customRequestPort === "function") {
-        // Use custom port request function (handles Android/WebUSB automatically)
-        logger.log("Using custom port request function");
         port = await customRequestPort();
     }
     else {
-        // Fallback to standard Web Serial API
+        // Check if Web Serial API is available
         if (!navigator.serial) {
             throw new Error("Web Serial API is not supported in this browser. " +
-                "Please use Chrome 89+, Edge 89+, or Opera on desktop, or Chrome 61+ on Android with USB OTG. " +
+                "Please use Chrome, Edge, or Opera on desktop, or Chrome on Android. " +
                 "Note: The page must be served over HTTPS or localhost.");
         }
         port = await navigator.serial.requestPort();
     }
-    // Only open if not already open (WebUSB may return an opened port)
+    // Only open if not already open (requestSerialPort may return an opened port)
     if (!port.readable || !port.writable) {
         await port.open({ baudRate: ESP_ROM_BAUD });
     }
-    logger.log("Connected successfully.");
     return new ESPLoader(port, logger);
 };
 export const connectWithPort = async (port, logger) => {
@@ -33,10 +37,9 @@ export const connectWithPort = async (port, logger) => {
     if (!port) {
         throw new Error("Port is required");
     }
-    // Only open if not already open
+    // Check if port is already open, if not open it
     if (!port.readable || !port.writable) {
         await port.open({ baudRate: ESP_ROM_BAUD });
     }
-    logger.log("Connected successfully.");
     return new ESPLoader(port, logger);
 };