tasmota-webserial-esptool 9.1.7 → 9.1.9

package/dist/esp_loader.d.ts

@@ -94,6 +94,7 @@ export declare class ESPLoader extends EventTarget {
     readLoop(): Promise<void>;
     sleep(ms?: number): Promise<unknown>;
     state_DTR: boolean;
+    state_RTS: boolean;
     setRTS(state: boolean): Promise<void>;
     setDTR(state: boolean): Promise<void>;
     /**

package/dist/esp_loader.js

@@ -25,17 +25,18 @@ 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;
         this.__lastAdaptiveAdjustment = 0;
         this.__isCDCDevice = false;
         this.state_DTR = false;
+        this.state_RTS = false;
         this.__writeChain = Promise.resolve();
     }
     // Chip properties with parent delegation
+    // chipFamily accessed before initialization as designed
     get chipFamily() {
         return this._parent ? this._parent.chipFamily : this.__chipFamily;
     }
@@ -81,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
@@ -553,6 +560,7 @@ export class ESPLoader extends EventTarget {
     // WebUSB (Android) - DTR/RTS Signal Handling & Reset Strategies
     // ============================================================================
     async setRTSWebUSB(state) {
+        this.state_RTS = state;
         // Always specify both signals to avoid flipping the other line
         // The WebUSB setSignals() now preserves unspecified signals, but being explicit is safer
         await this.port.setSignals({
@@ -565,11 +573,12 @@ export class ESPLoader extends EventTarget {
         // Always specify both signals to avoid flipping the other line
         await this.port.setSignals({
             dataTerminalReady: state,
-            requestToSend: undefined, // Let setSignals preserve current RTS state
+            requestToSend: this.state_RTS, // Explicitly preserve current RTS state
         });
     }
     async setDTRandRTSWebUSB(dtr, rts) {
         this.state_DTR = dtr;
+        this.state_RTS = rts;
         await this.port.setSignals({
             dataTerminalReady: dtr,
             requestToSend: rts,
@@ -753,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();
                         },
                     });
@@ -783,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();
                         },
                     });
@@ -807,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();
                         },
                     });
@@ -841,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();
                         },
                     });
@@ -874,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();
                         },
                     });
@@ -948,7 +957,6 @@ export class ESPLoader extends EventTarget {
             }
         }
         else {
-            // Web Serial (Desktop) strategies
             // Strategy: USB-JTAG/Serial reset
             if (isUSBJTAGSerial || isEspressifUSB) {
                 resetStrategies.push({
@@ -1043,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).");
             }
@@ -1265,6 +1273,11 @@ export class ESPLoader extends EventTarget {
                 // Process all available bytes without going back to outer loop
                 // This is critical for handling high-speed burst transfers
                 while (this._inputBufferAvailable > 0) {
+                    // Periodic timeout check to prevent hang on slow data
+                    if (Date.now() - startTime > timeout) {
+                        const waitingFor = partialPacket === null ? "header" : "content";
+                        throw new SlipReadError("Timed out waiting for packet " + waitingFor);
+                    }
                     const b = this._readByte();
                     if (partialPacket === null) {
                         // waiting for packet header
@@ -2163,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();
@@ -2171,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
@@ -2693,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);
 };