esp32tool 1.3.2 → 1.3.4

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_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, ESP32S2_RTC_CNTL_WDTWPROTECT_REG, ESP32S2_RTC_CNTL_WDTCONFIG0_REG, ESP32S2_RTC_CNTL_WDTCONFIG1_REG, ESP32S2_RTC_CNTL_WDT_WKEY, ESP32S2_GPIO_STRAP_REG, ESP32S2_GPIO_STRAP_SPI_BOOT_MASK, ESP32S2_RTC_CNTL_OPTION1_REG, ESP32S2_RTC_CNTL_FORCE_DOWNLOAD_BOOT_MASK, ESP32S3_RTC_CNTL_WDTWPROTECT_REG, ESP32S3_RTC_CNTL_WDTCONFIG0_REG, ESP32S3_RTC_CNTL_WDTCONFIG1_REG, ESP32S3_RTC_CNTL_WDT_WKEY, ESP32S3_GPIO_STRAP_REG, ESP32S3_GPIO_STRAP_SPI_BOOT_MASK, ESP32S3_RTC_CNTL_OPTION1_REG, ESP32S3_RTC_CNTL_FORCE_DOWNLOAD_BOOT_MASK, ESP32S2_UARTDEV_BUF_NO, ESP32S2_UARTDEV_BUF_NO_USB_OTG, ESP32S3_UARTDEV_BUF_NO, ESP32S3_UARTDEV_BUF_NO_USB_OTG, ESP32S3_UARTDEV_BUF_NO_USB_JTAG_SERIAL, ESP32C3_UARTDEV_BUF_NO_USB_JTAG_SERIAL, ESP32C3_BUF_UART_NO_OFFSET, ESP32C3_EFUSE_RD_MAC_SPI_SYS_3_REG, ESP32C3_EFUSE_RD_MAC_SPI_SYS_5_REG, ESP32C3_RTC_CNTL_WDTWPROTECT_REG, ESP32C3_RTC_CNTL_WDTCONFIG0_REG, ESP32C3_RTC_CNTL_WDTCONFIG1_REG, ESP32C3_RTC_CNTL_WDT_WKEY, ESP32C5_C6_RTC_CNTL_WDTWPROTECT_REG, ESP32C5_C6_RTC_CNTL_WDTCONFIG0_REG, ESP32C5_C6_RTC_CNTL_WDTCONFIG1_REG, ESP32C5_C6_RTC_CNTL_WDT_WKEY, ESP32C5_UARTDEV_BUF_NO, ESP32C5_UARTDEV_BUF_NO_USB_JTAG_SERIAL, ESP32C6_UARTDEV_BUF_NO, ESP32C6_UARTDEV_BUF_NO_USB_JTAG_SERIAL, ESP32P4_RTC_CNTL_WDTWPROTECT_REG, ESP32P4_RTC_CNTL_WDTCONFIG0_REG, ESP32P4_RTC_CNTL_WDTCONFIG1_REG, ESP32P4_RTC_CNTL_WDT_WKEY, ESP32P4_UARTDEV_BUF_NO_REV0, ESP32P4_UARTDEV_BUF_NO_REV300, ESP32P4_UARTDEV_BUF_NO_USB_OTG, ESP32P4_UARTDEV_BUF_NO_USB_JTAG_SERIAL, ESP32P4_RTC_CNTL_OPTION1_REG, ESP32P4_RTC_CNTL_FORCE_DOWNLOAD_BOOT_MASK, ESP32H2_UARTDEV_BUF_NO, ESP32H2_UARTDEV_BUF_NO_USB_JTAG_SERIAL, } 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, ESP32S2_RTC_CNTL_WDTWPROTECT_REG, ESP32S2_RTC_CNTL_WDTCONFIG0_REG, ESP32S2_RTC_CNTL_WDTCONFIG1_REG, ESP32S2_RTC_CNTL_WDT_WKEY, ESP32S2_RTC_CNTL_OPTION1_REG, ESP32S2_RTC_CNTL_FORCE_DOWNLOAD_BOOT_MASK, ESP32S3_RTC_CNTL_WDTWPROTECT_REG, ESP32S3_RTC_CNTL_WDTCONFIG0_REG, ESP32S3_RTC_CNTL_WDTCONFIG1_REG, ESP32S3_RTC_CNTL_WDT_WKEY, ESP32S3_RTC_CNTL_OPTION1_REG, ESP32S3_RTC_CNTL_FORCE_DOWNLOAD_BOOT_MASK, ESP32C3_EFUSE_RD_MAC_SPI_SYS_3_REG, ESP32C3_EFUSE_RD_MAC_SPI_SYS_5_REG, ESP32C3_RTC_CNTL_WDTWPROTECT_REG, ESP32C3_RTC_CNTL_WDTCONFIG0_REG, ESP32C3_RTC_CNTL_WDTCONFIG1_REG, ESP32C3_RTC_CNTL_WDT_WKEY, ESP32C5_C6_RTC_CNTL_WDTWPROTECT_REG, ESP32C5_C6_RTC_CNTL_WDTCONFIG0_REG, ESP32C5_C6_RTC_CNTL_WDTCONFIG1_REG, ESP32C5_C6_RTC_CNTL_WDT_WKEY, ESP32P4_RTC_CNTL_WDTWPROTECT_REG, ESP32P4_RTC_CNTL_WDTCONFIG0_REG, ESP32P4_RTC_CNTL_WDTCONFIG1_REG, ESP32P4_RTC_CNTL_WDT_WKEY, ESP32P4_RTC_CNTL_OPTION1_REG, ESP32P4_RTC_CNTL_FORCE_DOWNLOAD_BOOT_MASK, } from "./const";
 import { getStubCode } from "./stubs";
 import { hexFormatter, sleep, slipEncode, toHex } from "./util";
 import { deflate } from "pako";
@@ -27,6 +27,10 @@ export class ESPLoader extends EventTarget {
         this.connected = true;
         this.flashSize = null;
         this.currentBaudRate = ESP_ROM_BAUD;
+        this.SLIP_END = 0xc0;
+        this.SLIP_ESC = 0xdb;
+        this.SLIP_ESC_END = 0xdc;
+        this.SLIP_ESC_ESC = 0xdd;
         this._isESP32S2NativeUSB = false;
         this._initializationSucceeded = false;
         this.__commandLock = Promise.resolve([0, []]);
@@ -297,10 +301,8 @@ export class ESPLoader extends EventTarget {
             0x303a: {
                 // Espressif (native USB)
                 0x2: { name: "ESP32-S2 Native USB", maxBaudrate: 2000000 },
+                0x12: { name: "ESP32-P4 Native USB", maxBaudrate: 2000000 },
                 0x1001: { name: "ESP32 Native USB", maxBaudrate: 2000000 },
-                0x1002: { name: "ESP32 Native USB", maxBaudrate: 2000000 },
-                0x4002: { name: "ESP32 Native USB", maxBaudrate: 2000000 },
-                0x1000: { name: "ESP32 Native USB", maxBaudrate: 2000000 },
             },
         };
         const vendor = chips[vendorId];
@@ -1170,102 +1172,6 @@ export class ESPLoader extends EventTarget {
     async watchdogReset() {
         await this.rtcWdtResetChipSpecific();
     }
-    /**
-     * Check if current chip is using USB-OTG
-     * Supports ESP32-S2 and ESP32-S3
-     */
-    async usingUsbOtg() {
-        let uartDevBufNo;
-        let usbOtgValue;
-        if (this.chipFamily === CHIP_FAMILY_ESP32S2) {
-            uartDevBufNo = ESP32S2_UARTDEV_BUF_NO;
-            usbOtgValue = ESP32S2_UARTDEV_BUF_NO_USB_OTG;
-        }
-        else if (this.chipFamily === CHIP_FAMILY_ESP32S3) {
-            uartDevBufNo = ESP32S3_UARTDEV_BUF_NO;
-            usbOtgValue = ESP32S3_UARTDEV_BUF_NO_USB_OTG;
-        }
-        else if (this.chipFamily === CHIP_FAMILY_ESP32P4) {
-            // P4: UARTDEV_BUF_NO depends on chip revision
-            if (this.chipRevision === null) {
-                this.chipRevision = await this.getChipRevision();
-            }
-            if (this.chipRevision < 300) {
-                uartDevBufNo = ESP32P4_UARTDEV_BUF_NO_REV0;
-            }
-            else {
-                uartDevBufNo = ESP32P4_UARTDEV_BUF_NO_REV300;
-            }
-            usbOtgValue = ESP32P4_UARTDEV_BUF_NO_USB_OTG;
-        }
-        else {
-            return false;
-        }
-        const uartNo = (await this.readRegister(uartDevBufNo)) & 0xff;
-        return uartNo === usbOtgValue;
-    }
-    /**
-     * Check if current chip is using USB-JTAG/Serial
-     * Supports ESP32-S3 and ESP32-C3
-     */
-    async usingUsbJtagSerial() {
-        let uartDevBufNo;
-        let usbJtagSerialValue;
-        if (this.chipFamily === CHIP_FAMILY_ESP32S3) {
-            uartDevBufNo = ESP32S3_UARTDEV_BUF_NO;
-            usbJtagSerialValue = ESP32S3_UARTDEV_BUF_NO_USB_JTAG_SERIAL;
-        }
-        else if (this.chipFamily === CHIP_FAMILY_ESP32C3) {
-            // ESP32-C3: BSS_UART_DEV_ADDR depends on chip revision
-            // Revision < 101: 0x3FCDF064
-            // Revision >= 101: 0x3FCDF060
-            let bssUartDevAddr;
-            // Get chip revision if not already set
-            if (this.chipRevision === null) {
-                this.chipRevision = await this.getChipRevisionC3();
-            }
-            if (this.chipRevision < 101) {
-                bssUartDevAddr = 0x3fcdf064;
-            }
-            else {
-                bssUartDevAddr = 0x3fcdf060;
-            }
-            uartDevBufNo = bssUartDevAddr + ESP32C3_BUF_UART_NO_OFFSET;
-            usbJtagSerialValue = ESP32C3_UARTDEV_BUF_NO_USB_JTAG_SERIAL;
-        }
-        else if (this.chipFamily === CHIP_FAMILY_ESP32C5) {
-            uartDevBufNo = ESP32C5_UARTDEV_BUF_NO;
-            usbJtagSerialValue = ESP32C5_UARTDEV_BUF_NO_USB_JTAG_SERIAL;
-        }
-        else if (this.chipFamily === CHIP_FAMILY_ESP32C6) {
-            uartDevBufNo = ESP32C6_UARTDEV_BUF_NO;
-            usbJtagSerialValue = ESP32C6_UARTDEV_BUF_NO_USB_JTAG_SERIAL;
-        }
-        else if (this.chipFamily === CHIP_FAMILY_ESP32P4) {
-            // P4: UARTDEV_BUF_NO depends on chip revision
-            // Revision < 300: 0x4FF3FEC8
-            // Revision >= 300: 0x4FFBFEC8
-            if (this.chipRevision === null) {
-                this.chipRevision = await this.getChipRevision();
-            }
-            if (this.chipRevision < 300) {
-                uartDevBufNo = ESP32P4_UARTDEV_BUF_NO_REV0;
-            }
-            else {
-                uartDevBufNo = ESP32P4_UARTDEV_BUF_NO_REV300;
-            }
-            usbJtagSerialValue = ESP32P4_UARTDEV_BUF_NO_USB_JTAG_SERIAL;
-        }
-        else if (this.chipFamily === CHIP_FAMILY_ESP32H2) {
-            uartDevBufNo = ESP32H2_UARTDEV_BUF_NO;
-            usbJtagSerialValue = ESP32H2_UARTDEV_BUF_NO_USB_JTAG_SERIAL;
-        }
-        else {
-            return false;
-        }
-        const uartNo = (await this.readRegister(uartDevBufNo)) & 0xff;
-        return uartNo === usbJtagSerialValue;
-    }
     /**
      * Get chip revision for ESP32-C3
      * Reads from EFUSE registers and calculates revision
@@ -1333,35 +1239,6 @@ export class ESPLoader extends EventTarget {
         }
         // Unlock watchdog registers
         await this.writeRegister(WDTWPROTECT_REG, WDT_WKEY, undefined, 0);
-        // Clear force download boot register (if applicable) BEFORE triggering WDT reset
-        // This ensures the chip boots into firmware mode after reset
-        if (this.chipFamily === CHIP_FAMILY_ESP32S2) {
-            try {
-                await this.writeRegister(ESP32S2_RTC_CNTL_OPTION1_REG, 0, ESP32S2_RTC_CNTL_FORCE_DOWNLOAD_BOOT_MASK, 0);
-                this.logger.debug("Cleared force download boot mask");
-            }
-            catch (err) {
-                this.logger.debug(`Expected error clearing force download boot mask: ${err}`);
-            }
-        }
-        else if (this.chipFamily === CHIP_FAMILY_ESP32S3) {
-            try {
-                await this.writeRegister(ESP32S3_RTC_CNTL_OPTION1_REG, 0, ESP32S3_RTC_CNTL_FORCE_DOWNLOAD_BOOT_MASK, 0);
-                this.logger.debug("Cleared force download boot mask");
-            }
-            catch (err) {
-                this.logger.debug(`Expected error clearing force download boot mask: ${err}`);
-            }
-        }
-        else if (this.chipFamily === CHIP_FAMILY_ESP32P4) {
-            try {
-                await this.writeRegister(ESP32P4_RTC_CNTL_OPTION1_REG, 0, ESP32P4_RTC_CNTL_FORCE_DOWNLOAD_BOOT_MASK, 0);
-                this.logger.debug("Cleared force download boot mask");
-            }
-            catch (err) {
-                this.logger.debug(`Expected error clearing force download boot mask: ${err}`);
-            }
-        }
         // Set WDT timeout to 2000ms (matches Python esptool)
         await this.writeRegister(WDTCONFIG1_REG, 2000, undefined, 0);
         // Enable WDT: bit 31 = enable, bits 28-30 = stage, bit 8 = sys reset, bits 0-2 = prescaler
@@ -1373,72 +1250,29 @@ export class ESPLoader extends EventTarget {
         await this.sleep(500);
     }
     /**
-     * Helper: Check if USB-based WDT reset should be used for S2/S3
+     * Helper: USB-based WDT reset
      * Returns true if WDT reset was performed, false otherwise
      */
-    async tryUsbWdtReset(chipName, GPIO_STRAP_REG, GPIO_STRAP_SPI_BOOT_MASK, RTC_CNTL_OPTION1_REG, RTC_CNTL_FORCE_DOWNLOAD_BOOT_MASK) {
-        const isUsingUsbOtg = await this.usingUsbOtg();
-        const isUsingUsbJtagSerial = await this.usingUsbJtagSerial();
-        if (isUsingUsbOtg || isUsingUsbJtagSerial) {
-            const strapReg = await this.readRegister(GPIO_STRAP_REG);
-            const forceDlReg = await this.readRegister(RTC_CNTL_OPTION1_REG);
-            // Only use watchdog reset if GPIO0 is low AND force download boot mode is not set
-            if ((strapReg & GPIO_STRAP_SPI_BOOT_MASK) === 0 &&
-                (forceDlReg & RTC_CNTL_FORCE_DOWNLOAD_BOOT_MASK) === 0) {
-                await this.rtcWdtResetChipSpecific();
-                this.logger.debug(`${chipName}: RTC WDT reset (USB detected, GPIO0 low)`);
-                return true;
-            }
-        }
-        return false;
-    }
-    /**
-     * Chip-specific hard reset for ESP32-S2
-     * Checks if using USB-JTAG/Serial and uses watchdog reset if necessary
-     */
-    async hardResetS2() {
-        const isUsingUsbOtg = await this.usingUsbOtg();
+    async tryUsbWdtReset(chipName) {
+        const isUsingUsbOtg = await this.detectUsbConnectionType();
         if (isUsingUsbOtg) {
+            // Use WDT reset for USB-OTG devices
             await this.rtcWdtResetChipSpecific();
-            this.logger.debug("ESP32-S2: RTC WDT reset (USB-OTG detected)");
-        }
-        else {
-            // Use standard hardware reset
-            await this.hardResetClassic();
-            this.logger.debug("ESP32-S2: Classic reset");
-        }
-    }
-    /**
-     * Chip-specific hard reset for ESP32-S3
-     * Checks if using USB-JTAG/Serial and uses watchdog reset if necessary
-     */
-    async hardResetS3() {
-        const isUsingUsbJtagSerial = await this.usingUsbJtagSerial();
-        if (isUsingUsbJtagSerial) {
-            await this.rtcWdtResetChipSpecific();
-            this.logger.debug("ESP32-S3: RTC WDT reset (USB-JTAG/Serial detected)");
-        }
-        else {
-            // Use standard hardware reset
-            await this.hardResetClassic();
-            this.logger.debug("ESP32-S3: Classic reset");
-        }
-    }
-    /**
-     * Chip-specific hard reset for ESP32-C3
-     * Checks if using USB-JTAG/Serial and uses watchdog reset if necessary
-     */
-    async hardResetC3() {
-        const isUsingUsbJtagSerial = await this.usingUsbJtagSerial();
-        if (isUsingUsbJtagSerial) {
-            await this.rtcWdtResetChipSpecific();
-            this.logger.debug("ESP32-C3: RTC WDT reset (USB-JTAG/Serial detected)");
+            this.logger.debug(`${chipName}: RTC WDT reset (USB-JTAG/Serial or USB-OTG detected)`);
+            return true;
         }
         else {
-            // Use standard hardware reset
-            await this.hardResetClassic();
-            this.logger.debug("ESP32-C3: Classic reset");
+            // Use classic reset for non-USB devices
+            if (this.isWebUSB()) {
+                await this.hardResetClassicWebUSB();
+                this.logger.debug("Classic reset (WebUSB/Android).");
+            }
+            else {
+                await this.hardResetClassic();
+                this.logger.debug("Classic reset.");
+            }
         }
+        return false;
     }
     async hardReset(bootloader = false) {
         // In console mode, only allow simple hardware reset (no bootloader entry)
@@ -1478,15 +1312,35 @@ export class ESPLoader extends EventTarget {
         }
         else {
             // just reset (no bootloader mode)
-            // For ESP32-S2/S3 with USB-OTG or USB-JTAG/Serial, check if watchdog reset is needed
-            if (this.chipFamily === CHIP_FAMILY_ESP32S2 && !this._consoleMode) {
-                const wdtResetUsed = await this.tryUsbWdtReset("ESP32-S2", ESP32S2_GPIO_STRAP_REG, ESP32S2_GPIO_STRAP_SPI_BOOT_MASK, ESP32S2_RTC_CNTL_OPTION1_REG, ESP32S2_RTC_CNTL_FORCE_DOWNLOAD_BOOT_MASK);
+            // For ESP32-S2/S3/P4 with USB-OTG or USB-JTAG/Serial, check if watchdog reset is needed
+            this.logger.debug("*** Performing WDT reset strategy ***");
+            if (this.chipFamily === CHIP_FAMILY_ESP32S2) {
+                const wdtResetUsed = await this.tryUsbWdtReset("ESP32-S2");
+                if (wdtResetUsed)
+                    return;
+            }
+            else if (this.chipFamily === CHIP_FAMILY_ESP32S3) {
+                const wdtResetUsed = await this.tryUsbWdtReset("ESP32-S3");
                 if (wdtResetUsed)
                     return;
             }
-            else if (this.chipFamily === CHIP_FAMILY_ESP32S3 &&
-                !this._consoleMode) {
-                const wdtResetUsed = await this.tryUsbWdtReset("ESP32-S3", ESP32S3_GPIO_STRAP_REG, ESP32S3_GPIO_STRAP_SPI_BOOT_MASK, ESP32S3_RTC_CNTL_OPTION1_REG, ESP32S3_RTC_CNTL_FORCE_DOWNLOAD_BOOT_MASK);
+            else if (this.chipFamily === CHIP_FAMILY_ESP32P4) {
+                const wdtResetUsed = await this.tryUsbWdtReset("ESP32-P4");
+                if (wdtResetUsed)
+                    return;
+            }
+            else if (this.chipFamily === CHIP_FAMILY_ESP32C3) {
+                const wdtResetUsed = await this.tryUsbWdtReset("ESP32-C3");
+                if (wdtResetUsed)
+                    return;
+            }
+            else if (this.chipFamily === CHIP_FAMILY_ESP32C5) {
+                const wdtResetUsed = await this.tryUsbWdtReset("ESP32-C5");
+                if (wdtResetUsed)
+                    return;
+            }
+            else if (this.chipFamily === CHIP_FAMILY_ESP32C6) {
+                const wdtResetUsed = await this.tryUsbWdtReset("ESP32-C6");
                 if (wdtResetUsed)
                     return;
             }
@@ -1720,44 +1574,44 @@ export class ESPLoader extends EventTarget {
                         const waitingFor = partialPacket === null ? "header" : "content";
                         throw new SlipReadError("Timed out waiting for packet " + waitingFor);
                     }
-                    const b = this._readByte();
+                    const byte = this._readByte();
                     if (partialPacket === null) {
                         // waiting for packet header
-                        if (b == 0xc0) {
+                        if (byte == this.SLIP_END) {
                             partialPacket = [];
                         }
                         else {
                             if (this.debug) {
-                                this.logger.debug("Read invalid data: " + toHex(b));
+                                this.logger.debug("Read invalid data: " + toHex(byte));
                                 this.logger.debug("Remaining data in serial buffer: " +
                                     hexFormatter(this._inputBuffer));
                             }
-                            throw new SlipReadError("Invalid head of packet (" + toHex(b) + ")");
+                            throw new SlipReadError("Invalid head of packet (" + toHex(byte) + ")");
                         }
                     }
                     else if (inEscape) {
                         // part-way through escape sequence
                         inEscape = false;
-                        if (b == 0xdc) {
-                            partialPacket.push(0xc0);
+                        if (byte == this.SLIP_ESC_END) {
+                            partialPacket.push(this.SLIP_END);
                         }
-                        else if (b == 0xdd) {
-                            partialPacket.push(0xdb);
+                        else if (byte == this.SLIP_ESC_ESC) {
+                            partialPacket.push(this.SLIP_ESC);
                         }
                         else {
                             if (this.debug) {
-                                this.logger.debug("Read invalid data: " + toHex(b));
+                                this.logger.debug("Read invalid data: " + toHex(byte));
                                 this.logger.debug("Remaining data in serial buffer: " +
                                     hexFormatter(this._inputBuffer));
                             }
-                            throw new SlipReadError("Invalid SLIP escape (0xdb, " + toHex(b) + ")");
+                            throw new SlipReadError("Invalid SLIP escape (0xdb, " + toHex(byte) + ")");
                         }
                     }
-                    else if (b == 0xdb) {
+                    else if (byte == this.SLIP_ESC) {
                         // start of escape sequence
                         inEscape = true;
                     }
-                    else if (b == 0xc0) {
+                    else if (byte == this.SLIP_END) {
                         // end of packet
                         if (this.debug)
                             this.logger.debug("Received full packet: " + hexFormatter(partialPacket));
@@ -1767,7 +1621,7 @@ export class ESPLoader extends EventTarget {
                     }
                     else {
                         // normal byte in packet
-                        partialPacket.push(b);
+                        partialPacket.push(byte);
                     }
                 }
             }
@@ -1798,44 +1652,44 @@ export class ESPLoader extends EventTarget {
                 }
                 if (this.debug)
                     this.logger.debug("Read " + readBytes.length + " bytes: " + hexFormatter(readBytes));
-                for (const b of readBytes) {
+                for (const byte of readBytes) {
                     if (partialPacket === null) {
                         // waiting for packet header
-                        if (b == 0xc0) {
+                        if (byte == this.SLIP_END) {
                             partialPacket = [];
                         }
                         else {
                             if (this.debug) {
-                                this.logger.debug("Read invalid data: " + toHex(b));
+                                this.logger.debug("Read invalid data: " + toHex(byte));
                                 this.logger.debug("Remaining data in serial buffer: " +
                                     hexFormatter(this._inputBuffer));
                             }
-                            throw new SlipReadError("Invalid head of packet (" + toHex(b) + ")");
+                            throw new SlipReadError("Invalid head of packet (" + toHex(byte) + ")");
                         }
                     }
                     else if (inEscape) {
                         // part-way through escape sequence
                         inEscape = false;
-                        if (b == 0xdc) {
-                            partialPacket.push(0xc0);
+                        if (byte == this.SLIP_ESC_END) {
+                            partialPacket.push(this.SLIP_END);
                         }
-                        else if (b == 0xdd) {
-                            partialPacket.push(0xdb);
+                        else if (byte == this.SLIP_ESC_ESC) {
+                            partialPacket.push(this.SLIP_ESC);
                         }
                         else {
                             if (this.debug) {
-                                this.logger.debug("Read invalid data: " + toHex(b));
+                                this.logger.debug("Read invalid data: " + toHex(byte));
                                 this.logger.debug("Remaining data in serial buffer: " +
                                     hexFormatter(this._inputBuffer));
                             }
-                            throw new SlipReadError("Invalid SLIP escape (0xdb, " + toHex(b) + ")");
+                            throw new SlipReadError("Invalid SLIP escape (0xdb, " + toHex(byte) + ")");
                         }
                     }
-                    else if (b == 0xdb) {
+                    else if (byte == this.SLIP_ESC) {
                         // start of escape sequence
                         inEscape = true;
                     }
-                    else if (b == 0xc0) {
+                    else if (byte == this.SLIP_END) {
                         // end of packet
                         if (this.debug)
                             this.logger.debug("Received full packet: " + hexFormatter(partialPacket));
@@ -1845,7 +1699,7 @@ export class ESPLoader extends EventTarget {
                     }
                     else {
                         // normal byte in packet
-                        partialPacket.push(b);
+                        partialPacket.push(byte);
                     }
                 }
             }
@@ -2629,7 +2483,6 @@ export class ESPLoader extends EventTarget {
                 this._reader.cancel();
             }
             catch (err) {
-                //        this.logger.debug(`Reader cancel error: ${err}`);
                 // Reader already released, resolve immediately
                 clearTimeout(timeout);
                 resolve(undefined);
@@ -2655,12 +2508,6 @@ export class ESPLoader extends EventTarget {
             await this._parent.releaseReaderWriter();
             return;
         }
-        // Check if device is in JTAG mode and needs reset to boot into firmware
-        const didReconnect = await this._resetToFirmwareIfNeeded();
-        // If we reconnected for console, the reader/writer are already released and restarted
-        if (didReconnect) {
-            return;
-        }
         // Wait for pending writes to complete
         try {
             await this._writeChain;
@@ -2716,35 +2563,29 @@ export class ESPLoader extends EventTarget {
     /**
      * @name detectUsbConnectionType
      * Detect if device is using USB-JTAG/Serial or USB-OTG (not external serial chip)
-     * This helper extracts the detection logic from initialize() for reuse
+     * Uses USB PID (Product ID) for reliable detection - does NOT require chipFamily
      * @returns true if USB-JTAG or USB-OTG, false if external serial chip
-     * @throws Error if detection fails and chipFamily is not set
      */
     async detectUsbConnectionType() {
-        if (!this.chipFamily) {
-            throw new Error("Cannot detect USB connection type: chipFamily not set");
-        }
-        if (this.chipFamily === CHIP_FAMILY_ESP32S2 ||
-            this.chipFamily === CHIP_FAMILY_ESP32S3) {
-            const isUsingUsbOtg = await this.usingUsbOtg();
-            const isUsingUsbJtagSerial = await this.usingUsbJtagSerial();
-            return isUsingUsbOtg || isUsingUsbJtagSerial;
-        }
-        else if (this.chipFamily === CHIP_FAMILY_ESP32C3 ||
-            this.chipFamily === CHIP_FAMILY_ESP32C5 ||
-            this.chipFamily === CHIP_FAMILY_ESP32C6) {
-            const isUsingUsbJtagSerial = await this.usingUsbJtagSerial();
-            return isUsingUsbJtagSerial;
-        }
-        else if (this.chipFamily === CHIP_FAMILY_ESP32P4) {
-            const isUsingUsbOtg = await this.usingUsbOtg();
-            const isUsingUsbJtagSerial = await this.usingUsbJtagSerial();
-            return isUsingUsbOtg || isUsingUsbJtagSerial;
-        }
-        else {
-            // Other chips don't have USB-JTAG/OTG
+        // Use PID-based detection
+        const portInfo = this.port.getInfo();
+        const pid = portInfo.usbProductId;
+        const vid = portInfo.usbVendorId;
+        // Check if this is an Espressif device
+        const isEspressif = vid === 0x303a;
+        if (!isEspressif) {
+            this.logger.debug("Not Espressif VID - external serial chip");
             return false;
         }
+        // ESP32-S2/S3/C3/C5/C6/C61/H2/P4 USB-JTAG/OTG PIDs
+        // According to official Espressif documentation:
+        // https://docs.espressif.com/projects/esp-iot-solution/en/latest/usb/usb_overview/usb_device_const_COM.html
+        // 0x0002 = ESP32-S2 USB-OTG, 0x0012 = ESP32-P4 USB-Serial-JTAG
+        // 0x1001 = ESP32-S3, C3, C5, C6, C61, H2 USB-Serial-JTAG
+        const usbJtagPids = [0x0002, 0x0012, 0x1001];
+        const isUsbJtag = usbJtagPids.includes(pid || 0);
+        this.logger.debug(`USB-JTAG/OTG detection: ${isUsbJtag ? "YES" : "NO"} (PID=0x${pid === null || pid === void 0 ? void 0 : pid.toString(16)})`);
+        return isUsbJtag;
     }
     /**
      * @name enterConsoleMode
@@ -2753,23 +2594,33 @@ export class ESPLoader extends EventTarget {
      * @returns true if port was closed (USB-JTAG), false if port stays open (serial chip)
      */
     async enterConsoleMode() {
-        // Set console mode flag
-        this._consoleMode = true;
+        // Check if port is open - if not, we need a new port selection
+        if (!this.port.writable || !this.port.readable) {
+            this.logger.debug("Port is not open - port selection needed");
+            // Return true to signal that port selection is needed
+            // The caller should handle port selection and try again
+            return true;
+        }
         // Re-detect USB connection type to ensure we have a definitive value
-        // This handles cases where isUsbJtagOrOtg might be undefined
         let isUsbJtag;
         try {
             isUsbJtag = await this.detectUsbConnectionType();
             this.logger.debug(`USB connection type detected: ${isUsbJtag ? "USB-JTAG/OTG" : "External Serial Chip"}`);
+            // CRITICAL: Set the cached value so _resetToFirmwareIfNeeded() can use it
+            this._isUsbJtagOrOtg = isUsbJtag;
         }
         catch (err) {
             // If detection fails, fall back to cached value or fail-fast
             if (this.isUsbJtagOrOtg === undefined) {
                 throw new Error(`Cannot enter console mode: USB connection type unknown and detection failed: ${err}`);
             }
+            // Set console mode flag
+            this._consoleMode = false;
             this.logger.debug(`USB detection failed, using cached value: ${this.isUsbJtagOrOtg}`);
             isUsbJtag = this.isUsbJtagOrOtg;
         }
+        // Release reader/writer so console can create new ones
+        // This is needed for Desktop (Web Serial) to unlock streams
         if (isUsbJtag) {
             // USB-JTAG/OTG devices: Use watchdog reset which closes port
             const wasReset = await this._resetToFirmwareIfNeeded();
@@ -2792,6 +2643,22 @@ export class ESPLoader extends EventTarget {
             catch (err) {
                 this.logger.debug(`Could not reset device: ${err}`);
             }
+            // For WebUSB (Android), recreate streams after hardware reset
+            if (this.isWebUSB()) {
+                try {
+                    // Use the public recreateStreams() method to safely recreate streams
+                    // without closing the port (important after hardware reset)
+                    await this.port.recreateStreams();
+                    this.logger.debug("WebUSB streams recreated for console mode");
+                }
+                catch (err) {
+                    // Set console mode flag
+                    this._consoleMode = false;
+                    this.logger.debug(`Failed to recreate WebUSB streams: ${err}`);
+                }
+            }
+            // Set console mode flag
+            this._consoleMode = true;
             return false; // Port stays open
         }
     }
@@ -2801,57 +2668,146 @@ export class ESPLoader extends EventTarget {
      * Detects USB-JTAG/Serial and USB-OTG devices and performs appropriate reset
      * @returns true if reconnect was performed, false otherwise
      */
+    /**
+     * @name _clearForceDownloadBootIfNeeded
+     * Read and clear the force download boot flag if it is set
+     * This should ONLY be called when on ROM (not stub) and before WDT reset
+     * Clearing it on every connect causes issues with flash operations
+     * Returns true if the flag was cleared, false if it was already clear
+     */
+    async _clearForceDownloadBootIfNeeded() {
+        try {
+            let regAddr;
+            let mask;
+            let chipName;
+            // Get register address and mask for this chip
+            if (this.chipFamily === CHIP_FAMILY_ESP32S2) {
+                regAddr = ESP32S2_RTC_CNTL_OPTION1_REG;
+                mask = ESP32S2_RTC_CNTL_FORCE_DOWNLOAD_BOOT_MASK;
+                chipName = "ESP32-S2";
+            }
+            else if (this.chipFamily === CHIP_FAMILY_ESP32S3) {
+                regAddr = ESP32S3_RTC_CNTL_OPTION1_REG;
+                mask = ESP32S3_RTC_CNTL_FORCE_DOWNLOAD_BOOT_MASK;
+                chipName = "ESP32-S3";
+            }
+            else if (this.chipFamily === CHIP_FAMILY_ESP32P4) {
+                regAddr = ESP32P4_RTC_CNTL_OPTION1_REG;
+                mask = ESP32P4_RTC_CNTL_FORCE_DOWNLOAD_BOOT_MASK;
+                chipName = "ESP32-P4";
+            }
+            else {
+                // Not a chip that needs this
+                return false;
+            }
+            // Read current register value
+            const currentValue = await this.readRegister(regAddr);
+            this.logger.debug(`${chipName} force download boot register: 0x${currentValue.toString(16)} (mask: 0x${mask.toString(16)})`);
+            // Check if the flag is set
+            const isFlagSet = (currentValue & mask) !== 0;
+            if (isFlagSet) {
+                this.logger.debug(`${chipName} force download boot flag is SET - clearing it`);
+                // Clear the flag by writing 0 to the masked bits
+                await this.writeRegister(regAddr, 0, mask, 0);
+                this.logger.debug(`${chipName} force download boot flag cleared`);
+                return true;
+            }
+            else {
+                this.logger.debug(`${chipName} force download boot flag is already CLEAR - no action needed`);
+                return false;
+            }
+        }
+        catch (err) {
+            this.logger.debug(`Error checking/clearing force download flag: ${err}`);
+            return false;
+        }
+    }
     async _resetToFirmwareIfNeeded() {
         try {
-            // Check if device is using USB-JTAG/Serial or USB-OTG
-            // Value should already be set during main() connection
-            // Use getter to access parent's value if this is a stub
-            const needsReset = this.isUsbJtagOrOtg === true;
-            if (needsReset) {
-                const resetMethod = this.chipFamily === CHIP_FAMILY_ESP32S2 ||
-                    this.chipFamily === CHIP_FAMILY_ESP32S3
-                    ? "USB-JTAG/Serial or USB-OTG"
-                    : "USB-JTAG/Serial";
-                this.logger.log(`Resetting ${this.chipName || "device"} (${resetMethod}) to boot into firmware...`);
-                // Set console mode flag before reset to prevent subsequent hardReset calls
-                this._consoleMode = true;
-                // For S2/S3: Clear force download boot mask before WDT reset
-                if (this.chipFamily === CHIP_FAMILY_ESP32S2 ||
-                    this.chipFamily === CHIP_FAMILY_ESP32S3) {
-                    const OPTION1_REG = this.chipFamily === CHIP_FAMILY_ESP32S2
-                        ? ESP32S2_RTC_CNTL_OPTION1_REG
-                        : ESP32S3_RTC_CNTL_OPTION1_REG;
-                    const FORCE_DOWNLOAD_BOOT_MASK = this.chipFamily === CHIP_FAMILY_ESP32S2
-                        ? ESP32S2_RTC_CNTL_FORCE_DOWNLOAD_BOOT_MASK
-                        : ESP32S3_RTC_CNTL_FORCE_DOWNLOAD_BOOT_MASK;
+            // Check if port is open - if not, assume device is already in firmware mode
+            if (!this.port.writable || !this.port.readable) {
+                this.logger.debug("Port is not open - assuming device is already in firmware mode");
+                return false;
+            }
+            const isUsingUsbOtg = await this.detectUsbConnectionType();
+            if (isUsingUsbOtg) {
+                // For USB-OTG devices, we need to check if force download flag is set
+                // Only if it's set, we need WDT reset (which causes port change)
+                // If it's clear, we can use normal reset (no port change)
+                if (this.IS_STUB) {
+                    this.logger.debug("On stub - need to get back to ROM to check flag");
+                    // If we're running at higher baudrate, we need to change back to ROM baudrate
+                    if (this.currentBaudRate !== ESP_ROM_BAUD) {
+                        this.logger.debug(`Changing baudrate from ${this.currentBaudRate} to ${ESP_ROM_BAUD} for ROM`);
+                        try {
+                            await this.reconfigurePort(ESP_ROM_BAUD);
+                            this.currentBaudRate = ESP_ROM_BAUD;
+                        }
+                        catch (err) {
+                            this.logger.debug(`Baudrate change failed: ${err}`);
+                            // Continue anyway
+                        }
+                    }
+                    this.logger.debug("Resetting to bootloader (ROM)...");
+                    // Reset to bootloader - this will clear the stub from RAM
                     try {
-                        // Clear force download boot mode to avoid chip being stuck in download mode
-                        await this.writeRegister(OPTION1_REG, 0, FORCE_DOWNLOAD_BOOT_MASK, 0);
-                        this.logger.debug("Cleared force download boot mask");
+                        await this.hardReset(true);
+                        // Wait for reset to complete
+                        await sleep(200);
+                        // Sync with ROM
+                        await this.sync();
+                        this.logger.debug("Now on ROM after reset");
+                        // Mark that we're no longer on stub
+                        this.IS_STUB = false;
                     }
-                    catch (err) {
-                        this.logger.debug(`Expected error clearing force download boot mask: ${err}`);
+                    catch (resetErr) {
+                        this.logger.debug(`Reset to ROM failed: ${resetErr}`);
+                        // If reset fails, we might already be in firmware mode
+                        // In this case, we don't need to do anything - just use normal reset
+                        this.logger.debug("Assuming device is already in firmware mode");
+                        // Release reader/writer before returning
+                        await this.releaseReaderWriter();
+                        return false; // No port change needed
                     }
                 }
-                // Perform watchdog reset to reboot into firmware
-                try {
-                    await this.rtcWdtResetChipSpecific();
-                    this.logger.debug("Watchdog reset triggered successfully");
+                else {
+                    this.logger.debug("Already on ROM - checking force download flag");
+                }
+                // Now check if force download flag is set and clear it if needed
+                const flagWasCleared = await this._clearForceDownloadBootIfNeeded();
+                if (flagWasCleared) {
+                    this.logger.debug("Force download flag was cleared - device will boot to firmware after reset");
+                }
+                else {
+                    this.logger.debug("Force download flag already clear - device will boot to firmware after reset");
+                }
+                // Perform WDT reset BEFORE releasing reader/writer (needs communication)
+                // After WDT reset, the device will reboot into firmware mode
+                await this.hardReset(false);
+                // For USB-OTG devices (ESP32-S2, ESP32-P4), the port will change after WDT reset
+                const portWillChange = (this.chipFamily === CHIP_FAMILY_ESP32S2 && isUsingUsbOtg) ||
+                    (this.chipFamily === CHIP_FAMILY_ESP32P4 && isUsingUsbOtg);
+                if (portWillChange) {
+                    // Port will change - release reader/writer and let the port become invalid
+                    await this.releaseReaderWriter();
+                    this.logger.log(`${this.chipName} USB-OTG: Port will change after WDT reset`);
+                    this.logger.log("Please select the new port for console mode");
+                    // Dispatch event to signal port change
+                    this.dispatchEvent(new CustomEvent("usb-otg-port-change", {
+                        detail: {
+                            chipName: this.chipName,
+                            message: `${this.chipName} USB port changed after reset. Please select the new port.`,
+                            reason: "wdt-reset-to-firmware",
+                        },
+                    }));
+                    // Return true to indicate port selection is needed
+                    return true;
+                }
+                else {
+                    // Port stays the same - release reader/writer so console can use the stream
+                    await this.releaseReaderWriter();
+                    return false;
                 }
-                catch (err) {
-                    // Error is expected - device resets before responding
-                    this.logger.debug(`Watchdog reset initiated (connection lost as expected: ${err})`);
-                }
-                // Wait for device to fully boot into firmware
-                this.logger.log("Waiting for device to boot into firmware...");
-                await this.sleep(1000);
-                // After WDT reset, streams are dead/locked - don't try to manipulate them
-                // Just mark everything as disconnected and let browser clean up
-                this.connected = false;
-                this._writer = undefined;
-                this._reader = undefined;
-                this.logger.debug("Device reset to firmware mode (port closed)");
-                return true;
             }
         }
         catch (err) {
@@ -3087,31 +3043,50 @@ export class ESPLoader extends EventTarget {
         }
         // Clear console mode flag
         this._consoleMode = false;
-        // Check if this is ESP32-S2 with USB-JTAG/OTG
-        const isESP32S2 = this.chipFamily === CHIP_FAMILY_ESP32S2;
-        // For ESP32-S2: if _isUsbJtagOrOtg is undefined, try to detect it
+        // Check if this is a USB-OTG device (ESP32-S2 or ESP32-P4)
+        const isUsbOtgChip = this.chipFamily === CHIP_FAMILY_ESP32S2 ||
+            this.chipFamily === CHIP_FAMILY_ESP32P4;
+        // For USB-OTG chips: if _isUsbJtagOrOtg is undefined, try to detect it
         // If detection fails or is undefined, assume USB-JTAG/OTG (conservative/safe path)
         let isUsbJtagOrOtg = this._isUsbJtagOrOtg;
-        if (isESP32S2 && isUsbJtagOrOtg === undefined) {
+        if (isUsbOtgChip && isUsbJtagOrOtg === undefined) {
             try {
                 isUsbJtagOrOtg = await this.detectUsbConnectionType();
             }
             catch (err) {
-                this.logger.debug(`USB detection failed, assuming USB-JTAG/OTG for ESP32-S2: ${err}`);
-                isUsbJtagOrOtg = true; // Conservative fallback for ESP32-S2
+                this.logger.debug(`USB detection failed, assuming USB-JTAG/OTG for ${this.chipName}: ${err}`);
+                isUsbJtagOrOtg = true; // Conservative fallback
             }
         }
-        if (isESP32S2 && isUsbJtagOrOtg) {
-            // ESP32-S2 USB: Use reconnectToBootloader which handles the mode switch
-            // This will close the port and the device will reboot to bootloader
-            this.logger.log("ESP32-S2 USB detected - reconnecting to bootloader");
+        if (isUsbOtgChip && isUsbJtagOrOtg) {
+            // USB-OTG devices: Need to reset to bootloader, which will cause port change
+            this.logger.log(`${this.chipName} USB: Resetting to bootloader mode`);
+            // Perform hardware reset to bootloader (GPIO0=LOW)
+            // This will cause the port to change from CDC (firmware) to JTAG (bootloader)
             try {
-                await this.reconnectToBootloader();
+                if (this.isWebUSB()) {
+                    await this.hardResetClassicWebUSB();
+                }
+                else {
+                    await this.hardResetClassic();
+                }
+                this.logger.debug("Reset to bootloader initiated");
             }
             catch (err) {
-                this.logger.debug(`Reconnect error (expected for ESP32-S2): ${err}`);
-            }
-            // For ESP32-S2, port will change, so return true to indicate manual reconnection needed
+                this.logger.debug(`Reset error: ${err}`);
+            }
+            // Wait for reset to complete and port to change
+            await sleep(500);
+            this.logger.log(`${this.chipName}: Port changed. Please select the bootloader port.`);
+            // Dispatch event to signal port change
+            this.dispatchEvent(new CustomEvent("usb-otg-port-change", {
+                detail: {
+                    chipName: this.chipName,
+                    message: `${this.chipName}: Port changed. Please select the bootloader port.`,
+                    reason: "exit-console-to-bootloader",
+                },
+            }));
+            // Port will change, so return true to indicate manual reconnection needed
             return true;
         }
         // For other devices, use standard reconnectToBootloader
@@ -3181,7 +3156,7 @@ export class ESPLoader extends EventTarget {
         // Wait for the buffer to fill
         await sleep(bufferingTime);
         // Unsupported command response is sent 8 times and has
-        // 14 bytes length including delimiter 0xC0 bytes.
+        // 14 bytes length including delimiter SLIP_END (0xC0) bytes.
         // At least part of it is read as a command response,
         // but to be safe, read it all.
         const bytesToDrain = 14 * 8;
@@ -3345,7 +3320,7 @@ export class ESPLoader extends EventTarget {
                                 // The stub expects 4 bytes (ACK), if we send less it will break out
                                 try {
                                     // Send SLIP frame with no data (just delimiters)
-                                    const abortFrame = [0xc0, 0xc0]; // Empty SLIP frame
+                                    const abortFrame = [this.SLIP_END, this.SLIP_END]; // Empty SLIP frame
                                     await this.writeToStream(abortFrame);
                                     this.logger.debug(`Sent abort frame to stub`);
                                     // Give stub time to process abort