tasmota-webserial-esptool 9.1.4 → 9.1.6

package/dist/esp_loader.d.ts

@@ -3,10 +3,10 @@ export declare class ESPLoader extends EventTarget {
     port: SerialPort;
     logger: Logger;
     private _parent?;
-    chipFamily: ChipFamily;
-    chipName: string | null;
-    chipRevision: number | null;
-    chipVariant: string | null;
+    __chipFamily?: ChipFamily;
+    __chipName: string | null;
+    __chipRevision: number | null;
+    __chipVariant: string | null;
     _efuses: any[];
     _flashsize: number;
     debug: boolean;
@@ -30,6 +30,14 @@ export declare class ESPLoader extends EventTarget {
     private __lastAdaptiveAdjustment;
     private __isCDCDevice;
     constructor(port: SerialPort, logger: Logger, _parent?: ESPLoader | undefined);
+    get chipFamily(): ChipFamily;
+    set chipFamily(value: ChipFamily);
+    get chipName(): string | null;
+    set chipName(value: string | null);
+    get chipRevision(): number | null;
+    set chipRevision(value: number | null);
+    get chipVariant(): string | null;
+    set chipVariant(value: string | null);
     private get _inputBuffer();
     private get _inputBufferReadIndex();
     private set _inputBufferReadIndex(value);
@@ -75,6 +83,10 @@ export declare class ESPLoader extends EventTarget {
         chipId: number;
         apiVersion: number;
     }>;
+    /**
+     * Get MAC address from efuses
+     */
+    getMacAddress(): Promise<string>;
     /**
      * @name readLoop
      * Reads data from the input stream and places it in the inputBuffer
@@ -333,9 +345,14 @@ declare class EspStubLoader extends ESPLoader {
      */
     memBegin(size: number, _blocks: number, _blocksize: number, offset: number): Promise<[number, number[]]>;
     /**
-     * @name getEraseSize
-     * depending on flash chip model the erase may take this long (maybe longer!)
+     * @name eraseFlash
+     * Erase entire flash chip
      */
     eraseFlash(): Promise<void>;
+    /**
+     * @name eraseRegion
+     * Erase a specific region of flash
+     */
+    eraseRegion(offset: number, size: number): Promise<void>;
 }
 export {};

package/dist/esp_loader.js

@@ -1,5 +1,5 @@
 /// <reference types="@types/w3c-web-serial" />
-import { CHIP_FAMILY_ESP32, CHIP_FAMILY_ESP32S2, CHIP_FAMILY_ESP32S3, CHIP_FAMILY_ESP32C2, CHIP_FAMILY_ESP32C3, CHIP_FAMILY_ESP32C5, CHIP_FAMILY_ESP32C6, CHIP_FAMILY_ESP32C61, CHIP_FAMILY_ESP32H2, CHIP_FAMILY_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 { 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_ERASE_REGION, 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";
 import { deflate } from "pako";
@@ -10,9 +10,9 @@ export class ESPLoader extends EventTarget {
         this.port = port;
         this.logger = logger;
         this._parent = _parent;
-        this.chipName = null;
-        this.chipRevision = null;
-        this.chipVariant = null;
+        this.__chipName = null;
+        this.__chipRevision = null;
+        this.__chipVariant = null;
         this._efuses = new Array(4).fill(0);
         this._flashsize = 4 * 1024 * 1024;
         this.debug = false;
@@ -35,6 +35,51 @@ export class ESPLoader extends EventTarget {
         this.state_DTR = false;
         this.__writeChain = Promise.resolve();
     }
+    // Chip properties with parent delegation
+    get chipFamily() {
+        return this._parent ? this._parent.chipFamily : this.__chipFamily;
+    }
+    set chipFamily(value) {
+        if (this._parent) {
+            this._parent.chipFamily = value;
+        }
+        else {
+            this.__chipFamily = value;
+        }
+    }
+    get chipName() {
+        return this._parent ? this._parent.chipName : this.__chipName;
+    }
+    set chipName(value) {
+        if (this._parent) {
+            this._parent.chipName = value;
+        }
+        else {
+            this.__chipName = value;
+        }
+    }
+    get chipRevision() {
+        return this._parent ? this._parent.chipRevision : this.__chipRevision;
+    }
+    set chipRevision(value) {
+        if (this._parent) {
+            this._parent.chipRevision = value;
+        }
+        else {
+            this.__chipRevision = value;
+        }
+    }
+    get chipVariant() {
+        return this._parent ? this._parent.chipVariant : this.__chipVariant;
+    }
+    set chipVariant(value) {
+        if (this._parent) {
+            this._parent.chipVariant = value;
+        }
+        else {
+            this.__chipVariant = value;
+        }
+    }
     get _inputBuffer() {
         return this._parent ? this._parent._inputBuffer : this.__inputBuffer;
     }
@@ -390,6 +435,18 @@ export class ESPLoader extends EventTarget {
             apiVersion,
         };
     }
+    /**
+     * Get MAC address from efuses
+     */
+    async getMacAddress() {
+        if (!this._initializationSucceeded) {
+            throw new Error("getMacAddress() requires initialize() to have completed successfully");
+        }
+        const macBytes = this.macAddr(); // chip-family-aware
+        return macBytes
+            .map((b) => b.toString(16).padStart(2, "0").toUpperCase())
+            .join(":");
+    }
     /**
      * @name readLoop
      * Reads data from the input stream and places it in the inputBuffer
@@ -422,6 +479,12 @@ export class ESPLoader extends EventTarget {
         catch {
             this.logger.error("Read loop got disconnected");
         }
+        finally {
+            // Always reset reconfiguring flag when read loop ends
+            // This prevents "Cannot write during port reconfiguration" errors
+            // when the read loop dies unexpectedly
+            this._isReconfiguring = false;
+        }
         // Disconnected!
         this.connected = false;
         // Check if this is ESP32-S2 Native USB that needs port reselection
@@ -2064,52 +2127,45 @@ export class ESPLoader extends EventTarget {
             this.logger.debug("Port already closed, skipping disconnect");
             return;
         }
+        // Wait for pending writes to complete
         try {
-            // Wait for pending writes to complete
+            await this._writeChain;
+        }
+        catch (err) {
+            this.logger.debug(`Pending write error during disconnect: ${err}`);
+        }
+        // Release persistent writer before closing
+        if (this._writer) {
             try {
-                await this._writeChain;
+                await this._writer.close();
+                this._writer.releaseLock();
             }
             catch (err) {
-                this.logger.debug(`Pending write error during disconnect: ${err}`);
+                this.logger.debug(`Writer close/release error: ${err}`);
             }
-            // Block new writes during disconnect
-            this._isReconfiguring = true;
-            // Release persistent writer before closing
-            if (this._writer) {
-                try {
-                    await this._writer.close();
-                    this._writer.releaseLock();
-                }
-                catch (err) {
-                    this.logger.debug(`Writer close/release error: ${err}`);
-                }
-                this._writer = undefined;
+            this._writer = undefined;
+        }
+        else {
+            // No persistent writer exists, close stream directly
+            // This path is taken when no writes have been queued
+            try {
+                const writer = this.port.writable.getWriter();
+                await writer.close();
+                writer.releaseLock();
             }
-            else {
-                // No persistent writer exists, close stream directly
-                // This path is taken when no writes have been queued
-                try {
-                    const writer = this.port.writable.getWriter();
-                    await writer.close();
-                    writer.releaseLock();
-                }
-                catch (err) {
-                    this.logger.debug(`Direct writer close error: ${err}`);
-                }
+            catch (err) {
+                this.logger.debug(`Direct writer close error: ${err}`);
             }
-            await new Promise((resolve) => {
-                if (!this._reader) {
-                    resolve(undefined);
-                    return;
-                }
-                this.addEventListener("disconnect", resolve, { once: true });
-                this._reader.cancel();
-            });
-            this.connected = false;
-        }
-        finally {
-            this._isReconfiguring = false;
         }
+        await new Promise((resolve) => {
+            if (!this._reader) {
+                resolve(undefined);
+                return;
+            }
+            this.addEventListener("disconnect", resolve, { once: true });
+            this._reader.cancel();
+        });
+        this.connected = false;
     }
     /**
      * @name reconnectAndResume
@@ -2412,8 +2468,9 @@ export class ESPLoader extends EventTarget {
                             newResp.set(resp);
                             newResp.set(packetData, resp.length);
                             resp = newResp;
-                            // Send acknowledgment after receiving maxInFlight bytes
-                            // This unblocks the stub to send the next batch of packets
+                            // Send acknowledgment when we've received maxInFlight bytes
+                            // The stub sends packets until (num_sent - num_acked) >= max_in_flight
+                            // We MUST wait for all packets before sending ACK
                             const shouldAck = resp.length >= chunkSize || // End of chunk
                                 resp.length >= lastAckedLength + maxInFlight; // Received all packets
                             if (shouldAck) {
@@ -2589,10 +2646,46 @@ class EspStubLoader extends ESPLoader {
         return [0, []];
     }
     /**
-     * @name getEraseSize
-     * depending on flash chip model the erase may take this long (maybe longer!)
+     * @name eraseFlash
+     * Erase entire flash chip
      */
     async eraseFlash() {
         await this.checkCommand(ESP_ERASE_FLASH, [], 0, CHIP_ERASE_TIMEOUT);
     }
+    /**
+     * @name eraseRegion
+     * Erase a specific region of flash
+     */
+    async eraseRegion(offset, size) {
+        // Validate inputs
+        if (offset < 0) {
+            throw new Error(`Invalid offset: ${offset} (must be non-negative)`);
+        }
+        if (size < 0) {
+            throw new Error(`Invalid size: ${size} (must be non-negative)`);
+        }
+        // No-op for zero size
+        if (size === 0) {
+            this.logger.log("eraseRegion: size is 0, skipping erase");
+            return;
+        }
+        // Check for sector alignment
+        if (offset % FLASH_SECTOR_SIZE !== 0) {
+            throw new Error(`Offset ${offset} (0x${offset.toString(16)}) is not aligned to flash sector size ${FLASH_SECTOR_SIZE} (0x${FLASH_SECTOR_SIZE.toString(16)})`);
+        }
+        if (size % FLASH_SECTOR_SIZE !== 0) {
+            throw new Error(`Size ${size} (0x${size.toString(16)}) is not aligned to flash sector size ${FLASH_SECTOR_SIZE} (0x${FLASH_SECTOR_SIZE.toString(16)})`);
+        }
+        // Check for reasonable bounds (prevent wrapping in pack)
+        const maxValue = 0xffffffff; // 32-bit unsigned max
+        if (offset > maxValue) {
+            throw new Error(`Offset ${offset} exceeds maximum value ${maxValue}`);
+        }
+        if (size > maxValue) {
+            throw new Error(`Size ${size} exceeds maximum value ${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);
+    }
 }