@microbit/microbit-connection 0.9.0-apps.alpha.2 → 0.9.0-apps.alpha.20

package/build/esm/{usb.js → usb/connection.js}

@@ -3,51 +3,49 @@
  *
  * SPDX-License-Identifier: MIT
  */
-import { TimeoutError, withTimeout } from "./async-util.js";
-import { AfterRequestDevice, BeforeRequestDevice, ConnectionStatus, ConnectionStatusEvent, DeviceError, FlashDataError, ProgressStage, } from "./device.js";
-import { TypedEventTarget } from "./events.js";
-import { ConsoleLogging } from "./logging.js";
+import { withTimeout } from "../async-util.js";
+import { throwIfUnavailable } from "../availability.js";
+import { ConnectionStatus, DeviceError, FlashDataError, ProgressStage, assertConnected, } from "../device.js";
+import { TypedEventTarget } from "../events.js";
+import { ConsoleLogging } from "../logging.js";
 import { PromiseQueue } from "./promise-queue.js";
-import { FlashEvent, SerialDataEvent, SerialErrorEvent, SerialResetEvent, } from "./serial-events.js";
-import { DAPWrapper } from "./usb-device-wrapper.js";
-import { PartialFlashing } from "./usb-partial-flashing.js";
-// Temporary workaround for ChromeOS 105 bug.
-// See https://bugs.chromium.org/p/chromium/issues/detail?id=1363712&q=usb&can=2
-export const isChromeOS105 = () => {
-    const userAgent = navigator.userAgent;
-    return /CrOS/.test(userAgent) && /Chrome\/105\b/.test(userAgent);
-};
+import { USBDeviceWrapper, } from "./device-wrapper.js";
+import { PartialFlashing } from "./partial-flashing.js";
+import { saturateCdcPipeline } from "./cdc-saturation.js";
 const defaultFilters = [{ vendorId: 0x0d28, productId: 0x0204 }];
-export var DeviceSelectionMode;
-(function (DeviceSelectionMode) {
+export const DeviceSelectionMode = {
     /**
      * Attempts to connect to known device, otherwise asks which device to
      * connect to.
      */
-    DeviceSelectionMode["AlwaysAsk"] = "AlwaysAsk";
+    AlwaysAsk: "AlwaysAsk",
     /**
      * Attempts to connect to known device, otherwise attempts to connect to any
      * allowed devices. If that fails, asks which device to connect to.
      */
-    DeviceSelectionMode["UseAnyAllowed"] = "UseAnyAllowed";
-})(DeviceSelectionMode || (DeviceSelectionMode = {}));
+    UseAnyAllowed: "UseAnyAllowed",
+};
 /**
  * A WebUSB connection factory.
  */
-export const createWebUSBConnection = (options) => new MicrobitWebUSBConnectionImpl(options);
+export const createUSBConnection = (options) => new MicrobitUSBConnectionImpl(options);
 /**
  * A WebUSB connection to a micro:bit device.
  */
-class MicrobitWebUSBConnectionImpl extends TypedEventTarget {
+class MicrobitUSBConnectionImpl extends TypedEventTarget {
     constructor(options = {}) {
         super();
+        Object.defineProperty(this, "type", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "usb"
+        });
         Object.defineProperty(this, "status", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: navigator.usb && !isChromeOS105()
-                ? ConnectionStatus.NO_AUTHORIZED_DEVICE
-                : ConnectionStatus.NOT_SUPPORTED
+            value: ConnectionStatus.NoAuthorizedDevice
         });
         Object.defineProperty(this, "exclusionFilters", {
             enumerable: true,
@@ -56,9 +54,18 @@ class MicrobitWebUSBConnectionImpl extends TypedEventTarget {
             value: void 0
         });
         /**
-         * The USB device we last connected to.
+         * The raw USB device we last connected to.
          * Cleared if it is disconnected.
          */
+        Object.defineProperty(this, "usbDevice", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /**
+         * Device-specific state. Created on connect, cleared on disconnect.
+         */
         Object.defineProperty(this, "device", {
             enumerable: true,
             configurable: true,
@@ -66,14 +73,37 @@ class MicrobitWebUSBConnectionImpl extends TypedEventTarget {
             value: void 0
         });
         /**
-         * The connection to the device.
+         * Cached device properties that persist across reconnections until clearDevice.
          */
-        Object.defineProperty(this, "connection", {
+        Object.defineProperty(this, "cachedConnectionInfo", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
+        Object.defineProperty(this, "loggedBoardSerialInfo", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /**
+         * Whether CDC pipeline saturation has been performed for this physical
+         * USB connection. Once saturated, the buffers stay full until the device
+         * is physically disconnected.
+         */
+        Object.defineProperty(this, "cdcSaturated", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        /**
+         * Whether the serial read loop is running.
+         *
+         * This is false even if we have serial listeners when we're disconnected or flashing.
+         * The serial reads interfere with the flash process.
+         */
         Object.defineProperty(this, "serialState", {
             enumerable: true,
             configurable: true,
@@ -91,7 +121,7 @@ class MicrobitWebUSBConnectionImpl extends TypedEventTarget {
             configurable: true,
             writable: true,
             value: (data) => {
-                this.dispatchTypedEvent("serialdata", new SerialDataEvent(data));
+                this.dispatchEvent("serialdata", { data });
             }
         });
         Object.defineProperty(this, "flashing", {
@@ -100,13 +130,7 @@ class MicrobitWebUSBConnectionImpl extends TypedEventTarget {
             writable: true,
             value: false
         });
-        Object.defineProperty(this, "disconnectAfterFlash", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: false
-        });
-        Object.defineProperty(this, "visibilityReconnect", {
+        Object.defineProperty(this, "pauseAfterFlash", {
             enumerable: true,
             configurable: true,
             writable: true,
@@ -118,27 +142,26 @@ class MicrobitWebUSBConnectionImpl extends TypedEventTarget {
             writable: true,
             value: () => {
                 if (document.visibilityState === "visible") {
-                    if (this.visibilityReconnect &&
-                        this.status !== ConnectionStatus.CONNECTED) {
-                        this.disconnectAfterFlash = false;
-                        this.visibilityReconnect = false;
+                    // We may not have actually paused when we became hidden due to an in-progress flash.
+                    this.pauseAfterFlash = false;
+                    if (this.status === ConnectionStatus.Paused) {
                         if (!this.flashing) {
                             this.log("Reconnecting visible tab");
-                            this.connect();
+                            // withEnrichedErrors already disconnects and logs on failure.
+                            this.connect().catch(() => { });
                         }
                     }
                 }
                 else {
-                    if (!this.unloading && this.status === ConnectionStatus.CONNECTED) {
+                    if (!this.unloading && this.status === ConnectionStatus.Connected) {
                         if (!this.flashing) {
-                            this.log("Disconnecting hidden tab");
-                            this.disconnect().then(() => {
-                                this.visibilityReconnect = true;
-                            });
+                            this.log("Pausing connection for hidden tab");
+                            // Transition to PAUSED not DISCONNECTED
+                            this.disconnect(false, ConnectionStatus.Paused);
                         }
                         else {
                             this.log("Scheduling disconnect of hidden tab for after flash");
-                            this.disconnectAfterFlash = true;
+                            this.pauseAfterFlash = true;
                         }
                     }
                 }
@@ -165,9 +188,9 @@ class MicrobitWebUSBConnectionImpl extends TypedEventTarget {
                 window.addEventListener("focus", () => {
                     const assumePageIsStayingOpenDelay = 1000;
                     setTimeout(() => {
-                        if (this.status === ConnectionStatus.CONNECTED) {
+                        if (this.status === ConnectionStatus.Connected) {
                             this.unloading = false;
-                            if (this.addedListeners.serialdata) {
+                            if (this.hasSerialEventListeners()) {
                                 this.startSerialInternal();
                             }
                         }
@@ -187,29 +210,29 @@ class MicrobitWebUSBConnectionImpl extends TypedEventTarget {
             writable: true,
             value: void 0
         });
-        Object.defineProperty(this, "addedListeners", {
+        Object.defineProperty(this, "pauseOnHidden", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: {
-                serialdata: 0,
-            }
+            value: void 0
         });
         Object.defineProperty(this, "handleDisconnect", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: (event) => {
-                if (event.device === this.device) {
-                    this.connection = undefined;
+                if (event.device === this.usbDevice) {
+                    this.cdcSaturated = false;
                     this.device = undefined;
-                    this.setStatus(ConnectionStatus.NO_AUTHORIZED_DEVICE);
+                    this.usbDevice = undefined;
+                    this.setStatus(ConnectionStatus.NoAuthorizedDevice);
                 }
             }
         });
         this.logging = options.logging || new ConsoleLogging();
         this.deviceSelectionMode =
             options.deviceSelectionMode || DeviceSelectionMode.AlwaysAsk;
+        this.pauseOnHidden = options.pauseOnHidden ?? true;
     }
     log(v) {
         this.logging.log(v);
@@ -220,18 +243,24 @@ class MicrobitWebUSBConnectionImpl extends TypedEventTarget {
         }
         if (typeof window !== "undefined") {
             window.addEventListener("beforeunload", this.beforeUnloadListener);
-            if (window.document) {
+            if (this.pauseOnHidden && window.document) {
                 window.document.addEventListener("visibilitychange", this.visibilityChangeListener);
             }
         }
     }
+    async checkAvailability() {
+        if (!navigator.usb) {
+            return "unsupported";
+        }
+        return "available";
+    }
     dispose() {
         if (navigator.usb) {
             navigator.usb.removeEventListener("disconnect", this.handleDisconnect);
         }
         if (typeof window !== "undefined") {
             window.removeEventListener("beforeunload", this.beforeUnloadListener);
-            if (window.document) {
+            if (this.pauseOnHidden && window.document) {
                 window.document.removeEventListener("visibilitychange", this.visibilityChangeListener);
             }
         }
@@ -246,20 +275,22 @@ class MicrobitWebUSBConnectionImpl extends TypedEventTarget {
         });
     }
     getDeviceId() {
-        return this.connection?.deviceId;
+        assertConnected(this.cachedConnectionInfo);
+        return this.cachedConnectionInfo.deviceId;
     }
     getDevice() {
-        return this.device;
+        return this.usbDevice;
     }
     getBoardVersion() {
-        return this.connection?.boardSerialInfo?.id.toBoardVersion();
+        assertConnected(this.cachedConnectionInfo);
+        return this.cachedConnectionInfo.boardSerialInfo.id.toBoardVersion();
     }
     async flash(dataSource, options) {
         this.flashing = true;
         try {
             const startTime = new Date().getTime();
             await this.withEnrichedErrors(() => this.flashInternal(dataSource, options));
-            this.dispatchTypedEvent("flash", new FlashEvent());
+            this.dispatchEvent("flash");
             const flashTime = new Date().getTime() - startTime;
             this.logging.event({
                 type: "WebUSB-time",
@@ -280,17 +311,41 @@ class MicrobitWebUSBConnectionImpl extends TypedEventTarget {
         await this.stopSerialInternal();
         this.log("Reconnecting before flash");
         await this.connectInternal(progress);
-        if (!this.connection) {
+        if (!this.device) {
             throw new DeviceError({
-                code: "device-disconnected",
+                code: "connection-error",
                 message: "Must be connected now",
             });
         }
-        progress(ProgressStage.Initializing, undefined);
-        const boardId = this.connection.boardSerialInfo.id;
-        const boardVersion = boardId.toBoardVersion();
+        // Saturate DAPLink's CDC buffers on the first flash after physical
+        // connection, but only if someone is listening for serial data.
+        // Once saturated, the buffers stay full until physical disconnect.
+        if (!this.cdcSaturated && this.hasSerialEventListeners()) {
+            // Ensure DAPLink's UART is at 115200 before saturation.
+            // V1 DAPLink defaults to 9600 on fresh connection.
+            // setBaudrate may reset the target, so reinit SWD afterwards.
+            const currentBaud = await this.device.serial.getBaudrate();
+            if (currentBaud !== 115200) {
+                this.log(`Setting DAPLink baud from ${currentBaud} to 115200`);
+                await this.device.serial.setBaudrate(115200);
+                await this.device.adi.reinit();
+            }
+            this.log("Halting target");
+            await this.device.cortexM.halt();
+            const boardVersion = this.cachedConnectionInfo.boardSerialInfo.id.toBoardVersion();
+            await saturateCdcPipeline(this.device, boardVersion, this.logging);
+            this.cdcSaturated = true;
+            await this.device.serial.drain();
+        }
+        // Halt unconditionally — flash needs the target stopped.
+        if (!(await this.device.cortexM.isHalted())) {
+            this.log("Halting target");
+            await this.device.cortexM.halt();
+        }
+        const { boardSerialInfo, pageSize, numPages } = this.cachedConnectionInfo;
+        const boardVersion = boardSerialInfo.id.toBoardVersion();
         const data = await dataSource(boardVersion);
-        const flashing = new PartialFlashing(this.connection, this.logging, boardVersion);
+        const flashing = new PartialFlashing(this.device, this.logging, boardVersion, pageSize, numPages);
         let wasPartial = false;
         try {
             if (partial) {
@@ -302,18 +357,30 @@ class MicrobitWebUSBConnectionImpl extends TypedEventTarget {
         }
         finally {
             progress(wasPartial ? ProgressStage.PartialFlashing : ProgressStage.FullFlashing, undefined);
-            if (this.disconnectAfterFlash) {
+            if (this.pauseAfterFlash) {
                 this.log("Disconnecting after flash due to tab visibility");
-                this.disconnectAfterFlash = false;
-                await this.disconnect();
-                this.visibilityReconnect = true;
+                this.pauseAfterFlash = false;
+                await this.disconnect(false, ConnectionStatus.Paused);
             }
             else {
-                if (this.addedListeners.serialdata) {
+                await this.device.adi.reinit();
+                // Start serial before resetting so we capture startup output.
+                // For full flash FLASH_CLOSE already reset the target, so its
+                // early output accumulates in DAPLink's 512-byte serial ring
+                // buffer until the first read here.
+                if (this.hasSerialEventListeners()) {
                     this.log("Reinstating serial after flash");
-                    if (this.connection.daplink) {
-                        await this.connection.daplink.connect();
-                        await this.startSerialInternal();
+                    await this.startSerialInternal();
+                }
+                if (wasPartial) {
+                    // Partial flash writes pages via SWD without resetting.
+                    // Full flash already resets via FLASH_CLOSE.
+                    this.log("Resetting micro:bit to run new program");
+                    try {
+                        await this.device.cortexM.reset();
+                    }
+                    catch (e) {
+                        // Allow errors on resetting, user can always manually reset if necessary.
                     }
                 }
             }
@@ -321,38 +388,51 @@ class MicrobitWebUSBConnectionImpl extends TypedEventTarget {
     }
     async startSerialInternal() {
         return this.serialStateChangeQueue.add(async () => {
-            if (!this.connection || this.serialState) {
+            if (!this.device || this.serialState) {
                 return;
             }
             this.log("Starting serial");
             this.serialState = true;
-            this.connection
-                .startSerial(this.serialListener)
+            const serial = this.device.serial;
+            const currentBaud = await serial.getBaudrate();
+            if (currentBaud !== 115200) {
+                // Changing the baud rate causes a micro:bit reset, so only do it if necessary
+                await serial.setBaudrate(115200);
+            }
+            serial
+                .startPolling(this.serialListener, 1)
                 .then(() => {
                 this.log("Finished listening for serial data");
             })
                 .catch((e) => {
-                this.dispatchTypedEvent("serialerror", new SerialErrorEvent(e));
+                this.dispatchEvent("backgrounderror", {
+                    error: enrichedError(e),
+                    event: "serialdata",
+                });
             })
                 .finally(() => {
                 this.serialState = false;
+                // Don't reset when paused — the same program is still running and
+                // serial will resume when the tab becomes visible again.
+                if (this.status !== ConnectionStatus.Paused) {
+                    this.dispatchEvent("serialreset");
+                }
             });
         });
     }
     async stopSerialInternal() {
         return this.serialStateChangeQueue.add(async () => {
-            if (!this.connection || !this.serialState) {
+            if (!this.device || !this.serialState) {
                 return;
             }
-            this.connection.stopSerial(this.serialListener);
-            this.dispatchTypedEvent("serialreset", new SerialResetEvent());
+            this.device.serial.stopPolling();
         });
     }
-    async disconnect(quiet) {
+    async disconnect(quiet, finalStatus = ConnectionStatus.Disconnected) {
         try {
-            if (this.connection) {
+            if (this.device) {
                 await this.stopSerialInternal();
-                await this.connection.disconnectAsync();
+                await this.device.disconnect();
             }
         }
         catch (e) {
@@ -365,8 +445,8 @@ class MicrobitWebUSBConnectionImpl extends TypedEventTarget {
             }
         }
         finally {
-            this.connection = undefined;
-            this.setStatus(ConnectionStatus.DISCONNECTED);
+            this.device = undefined;
+            this.setStatus(finalStatus);
             if (!quiet) {
                 this.logging.log("Disconnection complete");
                 this.logging.event({
@@ -377,10 +457,30 @@ class MicrobitWebUSBConnectionImpl extends TypedEventTarget {
         }
     }
     setStatus(newStatus) {
+        const previousStatus = this.status;
         this.status = newStatus;
-        this.visibilityReconnect = false;
         this.log("USB connection status " + newStatus);
-        this.dispatchTypedEvent("status", new ConnectionStatusEvent(newStatus));
+        this.dispatchEvent("status", {
+            status: newStatus,
+            previousStatus,
+        });
+    }
+    logBoardInfo(info) {
+        this.logging.event({
+            type: "WebUSB-info",
+            message: "connected",
+        });
+        if (!this.loggedBoardSerialInfo || !this.loggedBoardSerialInfo.eq(info)) {
+            this.loggedBoardSerialInfo = info;
+            this.logging.event({
+                type: "WebUSB-info",
+                message: "board-id/" + info.id,
+            });
+            this.logging.event({
+                type: "WebUSB-info",
+                message: "board-family-hic/" + info.familyId + info.hic,
+            });
+        }
     }
     async withEnrichedErrors(f) {
         try {
@@ -414,68 +514,75 @@ class MicrobitWebUSBConnectionImpl extends TypedEventTarget {
         }
     }
     serialWrite(data) {
+        assertConnected(this.device);
+        const device = this.device;
         return this.withEnrichedErrors(async () => {
-            if (this.connection) {
-                // Using WebUSB/DAPJs we're limited to 64 byte packet size with a two byte header.
-                // https://github.com/microbit-foundation/python-editor-v3/issues/215
-                const maxSerialWrite = 62;
-                let start = 0;
-                while (start < data.length) {
-                    const end = Math.min(start + maxSerialWrite, data.length);
-                    const chunkData = data.slice(start, end);
-                    await this.connection.daplink.serialWrite(chunkData);
-                    start = end;
-                }
+            // WebUSB packets are 64 bytes with a two byte header.
+            // https://github.com/microbit-foundation/python-editor-v3/issues/215
+            const maxSerialWrite = 62;
+            let start = 0;
+            while (start < data.length) {
+                const end = Math.min(start + maxSerialWrite, data.length);
+                const chunkData = data.slice(start, end);
+                await device.serial.write(chunkData);
+                start = end;
             }
         });
     }
     async softwareReset() {
-        return this.serialStateChangeQueue.add(async () => await this.connection?.softwareReset());
+        assertConnected(this.device);
+        const device = this.device;
+        return this.serialStateChangeQueue.add(async () => await device.cortexM.softwareReset());
     }
     async clearDevice() {
         await this.disconnect();
-        this.device = undefined;
-        this.setStatus(ConnectionStatus.NO_AUTHORIZED_DEVICE);
+        this.usbDevice = undefined;
+        this.cachedConnectionInfo = undefined;
+        this.cdcSaturated = false;
+        this.setStatus(ConnectionStatus.NoAuthorizedDevice);
     }
     async connectInternal(progress) {
         const reportProgress = progress ?? (() => { });
-        if (!this.connection && this.device) {
+        reportProgress(ProgressStage.Initializing);
+        throwIfUnavailable(await this.checkAvailability());
+        if (!this.device && this.usbDevice) {
             reportProgress(ProgressStage.Connecting);
-            this.connection = new DAPWrapper(this.device, this.logging);
-            await withTimeout(this.connection.reconnectAsync(), 10_000);
+            this.device = new USBDeviceWrapper(this.usbDevice, this.logging);
+            this.cachedConnectionInfo = await withTimeout(this.device.reconnect(), 10_000);
         }
-        else if (!this.connection) {
+        else if (!this.device) {
             await this.connectWithOtherDevice(reportProgress);
         }
         else {
             reportProgress(ProgressStage.Connecting);
-            await withTimeout(this.connection.reconnectAsync(), 10_000);
+            this.cachedConnectionInfo = await withTimeout(this.device.reconnect(), 10_000);
         }
-        if (this.addedListeners.serialdata && !this.flashing) {
+        this.logBoardInfo(this.cachedConnectionInfo.boardSerialInfo);
+        if (this.hasSerialEventListeners() && !this.flashing) {
             this.startSerialInternal();
         }
-        this.setStatus(ConnectionStatus.CONNECTED);
+        this.setStatus(ConnectionStatus.Connected);
     }
     async connectWithOtherDevice(progress) {
         if (this.deviceSelectionMode === DeviceSelectionMode.UseAnyAllowed) {
             await this.attemptConnectAllowedDevices();
         }
-        if (!this.connection) {
+        if (!this.device) {
             progress(ProgressStage.FindingDevice);
-            this.device = await this.chooseDevice();
+            this.usbDevice = await this.chooseDevice();
             progress(ProgressStage.Connecting);
-            this.connection = new DAPWrapper(this.device, this.logging);
-            await withTimeout(this.connection.reconnectAsync(), 10_000);
+            this.device = new USBDeviceWrapper(this.usbDevice, this.logging);
+            this.cachedConnectionInfo = await withTimeout(this.device.reconnect(), 10_000);
         }
     }
     // Based on: https://github.com/microsoft/pxt/blob/ab97a2422879824c730f009b15d4bf446b0e8547/pxtlib/webusb.ts#L361
     async attemptConnectAllowedDevices() {
         const pairedDevices = await this.getFilteredAllowedDevices();
-        for (const device of pairedDevices) {
-            const connection = await this.attemptDeviceConnection(device);
-            if (connection) {
+        for (const usbDevice of pairedDevices) {
+            const device = await this.attemptDeviceConnection(usbDevice);
+            if (device) {
+                this.usbDevice = usbDevice;
                 this.device = device;
-                this.connection = connection;
                 return;
             }
         }
@@ -490,34 +597,33 @@ class MicrobitWebUSBConnectionImpl extends TypedEventTarget {
         const filteredDevices = devices.filter((device) => applyDeviceFilters(device, defaultFilters, this.exclusionFilters ?? []));
         return filteredDevices;
     }
-    async attemptDeviceConnection(device) {
-        this.log(`Attempting connection to: ${device.manufacturerName} ${device.productName}`);
-        this.log(`Serial number: ${device.serialNumber}`);
-        const connection = new DAPWrapper(device, this.logging);
-        await withTimeout(connection.reconnectAsync(), 10_000);
-        return connection;
+    async attemptDeviceConnection(usbDevice) {
+        this.log(`Attempting connection to: ${usbDevice.manufacturerName} ${usbDevice.productName}`);
+        this.log(`Serial number: ${usbDevice.serialNumber}`);
+        const device = new USBDeviceWrapper(usbDevice, this.logging);
+        this.cachedConnectionInfo = await withTimeout(device.reconnect(), 10_000);
+        return device;
     }
     async chooseDevice() {
-        this.dispatchTypedEvent("beforerequestdevice", new BeforeRequestDevice());
+        this.dispatchEvent("beforerequestdevice");
         try {
-            this.device = await navigator.usb.requestDevice({
+            this.usbDevice = await navigator.usb.requestDevice({
                 exclusionFilters: this.exclusionFilters,
                 filters: defaultFilters,
             });
         }
         finally {
-            this.dispatchTypedEvent("afterrequestdevice", new AfterRequestDevice());
+            this.dispatchEvent("afterrequestdevice");
         }
-        return this.device;
+        return this.usbDevice;
     }
     eventActivated(type) {
         switch (type) {
             case "serialdata": {
-                // Prevent starting serial if already started and when flashing.
-                if (!this.addedListeners.serialdata && !this.flashing) {
+                // Prevent starting serial when flashing. We'll reinstate later.
+                if (!this.flashing) {
                     this.startSerialInternal();
                 }
-                this.addedListeners.serialdata++;
                 break;
             }
         }
@@ -525,14 +631,14 @@ class MicrobitWebUSBConnectionImpl extends TypedEventTarget {
     async eventDeactivated(type) {
         switch (type) {
             case "serialdata": {
-                this.addedListeners.serialdata--;
-                if (!this.addedListeners.serialdata) {
-                    this.stopSerialInternal();
-                }
+                this.stopSerialInternal();
                 break;
             }
         }
     }
+    hasSerialEventListeners() {
+        return this.getActiveEvents().includes("serialdata");
+    }
 }
 /**
  * Applying WebUSB device filter. Exported for testing.
@@ -577,66 +683,42 @@ const hasMatchingInterface = (device, filter) => {
         });
     });
 };
-const genericErrorSuggestingReconnect = (e) => new DeviceError({
-    code: "reconnect-microbit",
-    message: e.message,
-});
-// tslint:disable-next-line: no-any
 const enrichedError = (err) => {
     if (err instanceof DeviceError) {
         return err;
     }
-    if (err instanceof TimeoutError) {
-        return new DeviceError({
-            code: "timeout-error",
-            message: err.message,
-        });
-    }
-    switch (typeof err) {
-        case "object":
-            // We might get Error objects as Promise rejection arguments
-            if (!err.message && err.promise && err.reason) {
-                err = err.reason;
-            }
-            // This is somewhat fragile but worth it for scenario specific errors.
-            // These messages changed to be prefixed in 2023 so we've relaxed the checks.
-            if (/No valid interfaces found/.test(err.message)) {
-                // This comes from DAPjs's WebUSB open.
-                return new DeviceError({
-                    code: "update-req",
-                    message: err.message,
-                });
-            }
-            else if (/No device selected/.test(err.message)) {
-                return new DeviceError({
-                    code: "no-device-selected",
-                    message: err.message,
-                });
-            }
-            else if (/Unable to claim interface/.test(err.message)) {
-                return new DeviceError({
-                    code: "clear-connect",
-                    message: err.message,
-                });
-            }
-            else if (err.name === "device-disconnected") {
-                return new DeviceError({
-                    code: "device-disconnected",
-                    message: err.message,
-                });
-            }
-            else {
-                // Unhandled error. User will need to reconnect their micro:bit
-                return genericErrorSuggestingReconnect(err);
-            }
-        case "string": {
-            // Caught a string. Example case: "Flash error" from DAPjs
-            return genericErrorSuggestingReconnect(err);
+    if (err instanceof Error) {
+        // Match Chromium WebUSB DOMException messages for user-friendly error codes.
+        // These are hardcoded English strings in Chromium (not localized).
+        // https://chromium.googlesource.com/chromium/src/+/main/third_party/blink/renderer/modules/webusb/usb.cc
+        if (/No device selected/.test(err.message)) {
+            return new DeviceError({
+                code: "no-device-selected",
+                message: err.message,
+                cause: err,
+            });
         }
-        default: {
-            return genericErrorSuggestingReconnect(err);
+        // https://chromium.googlesource.com/chromium/src/+/main/third_party/blink/renderer/modules/webusb/usb_device.cc
+        if (/Unable to claim interface/.test(err.message)) {
+            return new DeviceError({
+                code: "device-in-use",
+                message: err.message,
+                cause: err,
+            });
+        }
+        if (/The device was disconnected/.test(err.message)) {
+            return new DeviceError({
+                code: "device-disconnected",
+                message: err.message,
+                cause: err,
+            });
         }
     }
+    return new DeviceError({
+        code: "connection-error",
+        message: err.message,
+        cause: err,
+    });
 };
 const rateLimitProgress = (minimumProgressIncrement, callback) => {
     let lastCallValue = -1;
@@ -653,4 +735,4 @@ const rateLimitProgress = (minimumProgressIncrement, callback) => {
         }
     };
 };
-//# sourceMappingURL=usb.js.map
+//# sourceMappingURL=connection.js.map