@microbit/microbit-connection 0.9.0-apps.alpha.15 → 0.9.0-apps.alpha.17

package/build/esm/async-util.test.d.ts

@@ -0,0 +1 @@
+export {};

package/build/esm/async-util.test.js

@@ -0,0 +1,18 @@
+/**
+ * (c) 2021, Micro:bit Educational Foundation and contributors
+ *
+ * SPDX-License-Identifier: MIT
+ */
+import { describe, expect, it } from "vitest";
+import { TimeoutError, withTimeout } from "./async-util.js";
+describe("withTimeout", () => {
+    it("times out", async () => {
+        const neverResolves = new Promise(() => { });
+        await expect(() => withTimeout(neverResolves, 0)).rejects.toThrowError(TimeoutError);
+    });
+    it("returns the value", async () => {
+        const resolvesWithValue = async () => "foo";
+        expect(await withTimeout(resolvesWithValue(), 10)).toEqual("foo");
+    });
+});
+//# sourceMappingURL=async-util.test.js.map

package/build/esm/async-util.test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"async-util.test.js","sourceRoot":"","sources":["../../src/async-util.test.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,QAAQ,CAAC;AAC9C,OAAO,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAE5D,QAAQ,CAAC,aAAa,EAAE,GAAG,EAAE;IAC3B,EAAE,CAAC,WAAW,EAAE,KAAK,IAAI,EAAE;QACzB,MAAM,aAAa,GAAG,IAAI,OAAO,CAAC,GAAG,EAAE,GAAE,CAAC,CAAC,CAAC;QAC5C,MAAM,MAAM,CAAC,GAAG,EAAE,CAAC,WAAW,CAAC,aAAa,EAAE,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,YAAY,CACpE,YAAY,CACb,CAAC;IACJ,CAAC,CAAC,CAAC;IACH,EAAE,CAAC,mBAAmB,EAAE,KAAK,IAAI,EAAE;QACjC,MAAM,iBAAiB,GAAG,KAAK,IAAI,EAAE,CAAC,KAAK,CAAC;QAC5C,MAAM,CAAC,MAAM,WAAW,CAAC,iBAAiB,EAAE,EAAE,EAAE,CAAC,CAAC,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;IACpE,CAAC,CAAC,CAAC;AACL,CAAC,CAAC,CAAC"}

package/build/esm/availability.js.map

@@ -1 +1 @@
-{"version":3,"file":"availability.js","sourceRoot":"","sources":["../../lib/availability.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,OAAO,EAAgC,WAAW,EAAE,MAAM,aAAa,CAAC;AAExE;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAG,CAChC,MAAoC,EAC9B,EAAE;IACR,QAAQ,MAAM,EAAE,CAAC;QACf,KAAK,WAAW;YACd,OAAO;QACT,KAAK,aAAa;YAChB,MAAM,IAAI,WAAW,CAAC;gBACpB,IAAI,EAAE,aAAa;gBACnB,OAAO,EAAE,+BAA+B;aACzC,CAAC,CAAC;QACL,KAAK,UAAU;YACb,MAAM,IAAI,WAAW,CAAC;gBACpB,IAAI,EAAE,UAAU;gBAChB,OAAO,EAAE,wBAAwB;aAClC,CAAC,CAAC;QACL,KAAK,mBAAmB;YACtB,MAAM,IAAI,WAAW,CAAC;gBACpB,IAAI,EAAE,mBAAmB;gBACzB,OAAO,EAAE,mBAAmB;aAC7B,CAAC,CAAC;QACL,KAAK,mBAAmB;YACtB,MAAM,IAAI,WAAW,CAAC;gBACpB,IAAI,EAAE,mBAAmB;gBACzB,OAAO,EAAE,4BAA4B;aACtC,CAAC,CAAC;IACP,CAAC;AACH,CAAC,CAAC"}
+{"version":3,"file":"availability.js","sourceRoot":"","sources":["../../src/availability.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,OAAO,EAAgC,WAAW,EAAE,MAAM,aAAa,CAAC;AAExE;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAG,CAChC,MAAoC,EAC9B,EAAE;IACR,QAAQ,MAAM,EAAE,CAAC;QACf,KAAK,WAAW;YACd,OAAO;QACT,KAAK,aAAa;YAChB,MAAM,IAAI,WAAW,CAAC;gBACpB,IAAI,EAAE,aAAa;gBACnB,OAAO,EAAE,+BAA+B;aACzC,CAAC,CAAC;QACL,KAAK,UAAU;YACb,MAAM,IAAI,WAAW,CAAC;gBACpB,IAAI,EAAE,UAAU;gBAChB,OAAO,EAAE,wBAAwB;aAClC,CAAC,CAAC;QACL,KAAK,mBAAmB;YACtB,MAAM,IAAI,WAAW,CAAC;gBACpB,IAAI,EAAE,mBAAmB;gBACzB,OAAO,EAAE,mBAAmB;aAC7B,CAAC,CAAC;QACL,KAAK,mBAAmB;YACtB,MAAM,IAAI,WAAW,CAAC;gBACpB,IAAI,EAAE,mBAAmB;gBACzB,OAAO,EAAE,4BAA4B;aACtC,CAAC,CAAC;IACP,CAAC;AACH,CAAC,CAAC"}

package/build/{cjs/bluetooth.d.ts → esm/bluetooth/connection.d.ts}

@@ -1,15 +1,12 @@
-import { AccelerometerData } from "./accelerometer.js";
-import { DeviceConnection, FlashDataSource, FlashOptions } from "./device.js";
-import { LedMatrix } from "./led.js";
-import { Logging } from "./logging.js";
-import { MagnetometerData } from "./magnetometer.js";
-import { ServiceConnectionEventMap } from "./service-events.js";
+import { DeviceConnection, FlashDataSource, FlashOptions } from "../device.js";
+import { Logging } from "../logging.js";
+import { AccelerometerData, LedMatrix, MagnetometerData, ServiceConnectionEventMap } from "../service-events.js";
 import { DeviceBondState } from "./device-bond-state.js";
-export interface MicrobitWebBluetoothConnectionOptions {
+export interface MicrobitBluetoothConnectionOptions {
     logging?: Logging;
     deviceBondState?: DeviceBondState;
 }
-export interface MicrobitWebBluetoothConnection extends DeviceConnection<ServiceConnectionEventMap> {
+export interface MicrobitBluetoothConnection extends DeviceConnection<ServiceConnectionEventMap> {
     /**
      * Sets micro:bit name filter for device requesting.
      *
@@ -19,96 +16,103 @@ export interface MicrobitWebBluetoothConnection extends DeviceConnection<Service
     /**
      * Gets micro:bit accelerometer data.
      *
-     * @returns accelerometer data or undefined if there is no connection.
+     * @returns accelerometer data.
+     * @throws {DeviceError} with code `not-connected` if there is no connection.
      */
-    getAccelerometerData(): Promise<AccelerometerData | undefined>;
+    getAccelerometerData(): Promise<AccelerometerData>;
     /**
      * Gets micro:bit accelerometer period.
      *
-     * @returns accelerometer period or undefined if there is no connection.
+     * @returns accelerometer period.
+     * @throws {DeviceError} with code `not-connected` if there is no connection.
      */
-    getAccelerometerPeriod(): Promise<number | undefined>;
+    getAccelerometerPeriod(): Promise<number>;
     /**
      * Sets micro:bit accelerometer period.
      *
      * @param value The accelerometer period.
+     * @throws {DeviceError} with code `not-connected` if there is no connection.
      */
     setAccelerometerPeriod(value: number): Promise<void>;
     /**
      * Sets micro:bit LED text.
      *
      * @param text The text displayed on micro:bit LED.
+     * @throws {DeviceError} with code `not-connected` if there is no connection.
      */
     setLedText(text: string): Promise<void>;
     /**
      * Gets micro:bit LED scrolling delay.
      *
      * @returns LED scrolling delay in milliseconds.
+     * @throws {DeviceError} with code `not-connected` if there is no connection.
      */
-    getLedScrollingDelay(): Promise<number | undefined>;
+    getLedScrollingDelay(): Promise<number>;
     /**
      * Sets micro:bit LED scrolling delay.
      *
      * @param delayInMillis LED scrolling delay in milliseconds.
+     * @throws {DeviceError} with code `not-connected` if there is no connection.
      */
     setLedScrollingDelay(delayInMillis: number): Promise<void>;
     /**
      * Gets micro:bit LED matrix.
      *
      * @returns a boolean matrix representing the micro:bit LED display.
+     * @throws {DeviceError} with code `not-connected` if there is no connection.
      */
-    getLedMatrix(): Promise<LedMatrix | undefined>;
+    getLedMatrix(): Promise<LedMatrix>;
     /**
      * Sets micro:bit LED matrix.
      *
      * @param matrix an boolean matrix representing the micro:bit LED display.
+     * @throws {DeviceError} with code `not-connected` if there is no connection.
      */
     setLedMatrix(matrix: LedMatrix): Promise<void>;
     /**
      * Gets micro:bit magnetometer data.
      *
      * @returns magnetometer data.
+     * @throws {DeviceError} with code `not-connected` if there is no connection.
      */
-    getMagnetometerData(): Promise<MagnetometerData | undefined>;
+    getMagnetometerData(): Promise<MagnetometerData>;
     /**
      * Gets micro:bit magnetometer bearing.
      *
      * @returns magnetometer bearing.
+     * @throws {DeviceError} with code `not-connected` if there is no connection.
      */
-    getMagnetometerBearing(): Promise<number | undefined>;
+    getMagnetometerBearing(): Promise<number>;
     /**
      * Gets micro:bit magnetometer period.
      *
      * @returns magnetometer period.
+     * @throws {DeviceError} with code `not-connected` if there is no connection.
      */
-    getMagnetometerPeriod(): Promise<number | undefined>;
+    getMagnetometerPeriod(): Promise<number>;
     /**
      * Sets micro:bit magnetometer period.
      *
      * @param value magnetometer period.
+     * @throws {DeviceError} with code `not-connected` if there is no connection.
      */
     setMagnetometerPeriod(value: number): Promise<void>;
     /**
      * Triggers micro:bit magnetometer calibration.
+     *
+     * @throws {DeviceError} with code `not-connected` if there is no connection.
      */
     triggerMagnetometerCalibration(): Promise<void>;
     /**
      * Write UART messages.
      *
      * @param data UART message.
+     * @throws {DeviceError} with code `not-connected` if there is no connection.
      */
     uartWrite(data: Uint8Array): Promise<void>;
-    /**
-     * Flash the micro:bit.
-     *
-     * @param dataSource The data to use.
-     * @param options Flash options and progress callback.
-     * @throws {DeviceError} On flash failure. The error.code property indicates the failure type.
-     * @throws {FlashDataError} If data preparation fails.
-     */
     flash(dataSource: FlashDataSource, options: FlashOptions): Promise<void>;
 }
 /**
  * A Bluetooth connection factory.
  */
-export declare const createWebBluetoothConnection: (options?: MicrobitWebBluetoothConnectionOptions) => MicrobitWebBluetoothConnection;
+export declare const createBluetoothConnection: (options?: MicrobitBluetoothConnectionOptions) => MicrobitBluetoothConnection;

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

@@ -6,38 +6,39 @@
 import { BleClient } from "@capacitor-community/bluetooth-le";
 import { Capacitor } from "@capacitor/core";
 import MemoryMap from "nrf-intel-hex";
-import { BluetoothDeviceWrapper, isAndroid, scanningTimeoutInMs, } from "./bluetooth-device-wrapper.js";
-import { profile } from "./bluetooth-profile.js";
-import { AfterRequestDevice, BeforeRequestDevice, ConnectionStatus, ConnectionStatusEvent, DeviceError, FlashDataError, ProgressStage, } from "./device.js";
-import { TypedEventTarget } from "./events.js";
-import { ConsoleLogging } from "./logging.js";
+import { BluetoothDeviceWrapper, isAndroid, scanningTimeoutInMs, } from "./device-wrapper.js";
+import { profile } from "./profile.js";
+import { ConnectionStatus, DeviceError, FlashDataError, assertConnected, ProgressStage, } from "../device.js";
+import { TypedEventTarget } from "../events.js";
+import { ConsoleLogging } from "../logging.js";
 import { fullFlash } from "./flashing/flashing-full.js";
 import partialFlash, { PartialFlashResult, } from "./flashing/flashing-partial.js";
-import { throwIfUnavailable } from "./availability.js";
-import { truncateHexAfterEof } from "./hex-flash-data-source.js";
+import { throwIfUnavailable } from "../availability.js";
+import { truncateHexAfterEof } from "../hex-util.js";
 import { DefaultDeviceBondState, } from "./device-bond-state.js";
+import { TimeoutError } from "../async-util.js";
 let bleClientInitialized = false;
 /**
  * A Bluetooth connection factory.
  */
-export const createWebBluetoothConnection = (options) => new MicrobitWebBluetoothConnectionImpl(options);
+export const createBluetoothConnection = (options) => new MicrobitBluetoothConnectionImpl(options);
 /**
  * A Bluetooth connection to a micro:bit device.
  */
-class MicrobitWebBluetoothConnectionImpl extends TypedEventTarget {
+class MicrobitBluetoothConnectionImpl extends TypedEventTarget {
     constructor(options = {}) {
         super();
         Object.defineProperty(this, "status", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: ConnectionStatus.NO_AUTHORIZED_DEVICE
+            value: ConnectionStatus.NoAuthorizedDevice
         });
         /**
-         * The USB device we last connected to.
+         * The BLE device we last connected to.
          * Cleared if it is disconnected.
          */
-        Object.defineProperty(this, "device", {
+        Object.defineProperty(this, "bleDevice", {
             enumerable: true,
             configurable: true,
             writable: true,
@@ -55,7 +56,19 @@ class MicrobitWebBluetoothConnectionImpl extends TypedEventTarget {
             writable: true,
             value: void 0
         });
-        Object.defineProperty(this, "connection", {
+        /**
+         * Device-specific state. Created on connect, cleared on disconnect.
+         */
+        Object.defineProperty(this, "device", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /**
+         * Cached device property that persists across reconnections until clearDevice.
+         */
+        Object.defineProperty(this, "cachedBoardVersion", {
             enumerable: true,
             configurable: true,
             writable: true,
@@ -73,15 +86,21 @@ class MicrobitWebBluetoothConnectionImpl extends TypedEventTarget {
             writable: true,
             value: void 0
         });
+        Object.defineProperty(this, "waitForPostFlashDisconnectPromise", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         this.logging = options.logging || new ConsoleLogging();
         this.deviceBondState =
             options.deviceBondState || new DefaultDeviceBondState();
     }
     eventActivated(type) {
-        this.connection?.startNotifications(type);
+        this.device?.startNotifications(type);
     }
     eventDeactivated(type) {
-        this.connection?.stopNotifications(type);
+        this.device?.stopNotifications(type);
     }
     log(v) {
         this.logging.log(v);
@@ -149,7 +168,8 @@ class MicrobitWebBluetoothConnectionImpl extends TypedEventTarget {
         }
     }
     getBoardVersion() {
-        return this.connection?.boardVersion;
+        assertConnected(this.cachedBoardVersion);
+        return this.cachedBoardVersion;
     }
     async connect(options) {
         const progress = options?.progress ?? (() => { });
@@ -157,21 +177,26 @@ class MicrobitWebBluetoothConnectionImpl extends TypedEventTarget {
         // because on Android/iOS that's the appropriate time to ask for permissions.
         progress(ProgressStage.Initializing);
         throwIfUnavailable(await this.checkAvailability());
-        if (!this.device || !this.connection) {
+        // After partial flashing, we will need to wait for connection to fully
+        // disconnect before attempting to connect.
+        this.waitForPostFlashDisconnectPromise &&
+            (await this.waitForPostFlashDisconnectPromise);
+        if (!this.bleDevice || !this.device) {
             progress(ProgressStage.FindingDevice);
             const device = await this.requestDevice(options?.signal);
-            this.connection = new BluetoothDeviceWrapper(device, this.logging, this.deviceBondState, this.dispatchTypedEvent.bind(this), () => this.getActiveEvents(), {
-                onConnecting: () => this.setStatus(ConnectionStatus.CONNECTING),
-                onSuccess: () => this.setStatus(ConnectionStatus.CONNECTED),
-                onDisconnect: () => this.setStatus(ConnectionStatus.DISCONNECTED),
+            this.device = new BluetoothDeviceWrapper(device, this.logging, this.deviceBondState, this.dispatchEvent.bind(this), () => this.getActiveEvents(), {
+                onConnecting: () => this.setStatus(ConnectionStatus.Connecting),
+                onSuccess: () => this.setStatus(ConnectionStatus.Connected),
+                onDisconnect: () => this.setStatus(ConnectionStatus.Disconnected),
             });
         }
-        await this.connection.connect(options);
+        await this.device.connect(options);
+        this.cachedBoardVersion = this.device.boardVersion;
     }
     async disconnect() {
         try {
-            if (this.connection) {
-                await this.connection.disconnect();
+            if (this.device) {
+                await this.device.disconnect();
             }
         }
         catch (e) {
@@ -181,7 +206,7 @@ class MicrobitWebBluetoothConnectionImpl extends TypedEventTarget {
             });
         }
         finally {
-            this.setStatus(ConnectionStatus.DISCONNECTED);
+            this.setStatus(ConnectionStatus.Disconnected);
             this.logging.event({
                 type: "Bluetooth-info",
                 message: "disconnected",
@@ -193,105 +218,118 @@ class MicrobitWebBluetoothConnectionImpl extends TypedEventTarget {
         this.status = newStatus;
         this.log("Bluetooth connection status " + newStatus);
         if (this.deferredUpdatesPreviousStatus === undefined) {
-            this.dispatchTypedEvent("status", new ConnectionStatusEvent(newStatus, previousStatus));
-        }
-    }
-    serialWrite(data) {
-        if (this.connection) {
-            // TODO
+            this.dispatchEvent("status", {
+                status: newStatus,
+                previousStatus,
+            });
         }
-        return Promise.resolve();
     }
     async clearDevice() {
         await this.disconnect();
-        this.device = undefined;
-        this.setStatus(ConnectionStatus.NO_AUTHORIZED_DEVICE);
+        this.bleDevice = undefined;
+        this.cachedBoardVersion = undefined;
+        this.setStatus(ConnectionStatus.NoAuthorizedDevice);
     }
     setNameFilter(name) {
         this.nameFilter = name;
     }
     async requestDevice(signal) {
-        // TODO: is this possible to reinstate?
+        // Support both the default "BBC micro:bit" name and the shorter "uBit"
+        // name used by some MakeCode extensions (e.g. bsiever/microbit-pxt-blehid).
         // See https://github.com/bsiever/microbit-pxt-blehid/issues/31
-        // namePrefix: this.nameFilter
-        //   ? `uBit [${this.nameFilter}]`
-        //   : "uBit",
-        const namePrefix = this.nameFilter
-            ? `BBC micro:bit [${this.nameFilter}]`
-            : "BBC micro:bit";
+        const namePrefixes = this.nameFilter
+            ? [`BBC micro:bit [${this.nameFilter}]`, `uBit [${this.nameFilter}]`]
+            : ["BBC micro:bit", "uBit"];
         // If we have a cached device, check if it still matches the current filter.
         // If not, clear it so we find a new device.
-        if (this.device) {
-            if (this.device.name?.startsWith(namePrefix)) {
-                return this.device;
+        if (this.bleDevice) {
+            if (namePrefixes.some((p) => this.bleDevice.name?.startsWith(p))) {
+                return this.bleDevice;
             }
-            this.log(`Cached device "${this.device.name}" doesn't match filter "${namePrefix}", clearing`);
+            this.log(`Cached device "${this.bleDevice.name}" doesn't match filters "${namePrefixes.join(", ")}", clearing`);
             await this.clearDevice();
         }
-        this.dispatchTypedEvent("beforerequestdevice", new BeforeRequestDevice());
+        this.dispatchEvent("beforerequestdevice");
         try {
-            this.device = Capacitor.isNativePlatform()
-                ? await this.requestDeviceNative(namePrefix, signal)
-                : await this.requestDeviceWeb(namePrefix);
-            if (!this.device) {
-                this.setStatus(ConnectionStatus.NO_AUTHORIZED_DEVICE);
+            this.bleDevice = Capacitor.isNativePlatform()
+                ? await this.requestDeviceNative(namePrefixes, signal)
+                : await this.requestDeviceWeb(namePrefixes);
+            if (!this.bleDevice) {
+                this.setStatus(ConnectionStatus.NoAuthorizedDevice);
                 throw new DeviceError({
                     code: "no-device-selected",
                     message: "No device selected",
                 });
             }
-            return this.device;
+            return this.bleDevice;
         }
         finally {
-            this.dispatchTypedEvent("afterrequestdevice", new AfterRequestDevice());
+            this.dispatchEvent("afterrequestdevice");
         }
     }
     async getAccelerometerData() {
-        return this.connection?.accelerometer.getData();
+        assertConnected(this.device);
+        return this.device.accelerometer.getData();
     }
     async getAccelerometerPeriod() {
-        return this.connection?.accelerometer.getPeriod();
+        assertConnected(this.device);
+        return this.device.accelerometer.getPeriod();
     }
     async setAccelerometerPeriod(value) {
-        return this.connection?.accelerometer.setPeriod(value);
+        assertConnected(this.device);
+        return this.device.accelerometer.setPeriod(value);
     }
     async setLedText(text) {
-        return this.connection?.led.setText(text);
+        assertConnected(this.device);
+        return this.device.led.setText(text);
     }
     async getLedScrollingDelay() {
-        return this.connection?.led.getScrollingDelay();
+        assertConnected(this.device);
+        return this.device.led.getScrollingDelay();
     }
     async setLedScrollingDelay(delayInMillis) {
-        await this.connection?.led.setScrollingDelay(delayInMillis);
+        assertConnected(this.device);
+        await this.device.led.setScrollingDelay(delayInMillis);
     }
     async getLedMatrix() {
-        return await this.connection?.led.getLedMatrix();
+        assertConnected(this.device);
+        return await this.device.led.getLedMatrix();
     }
     async setLedMatrix(matrix) {
-        await this.connection?.led.setLedMatrix(matrix);
+        assertConnected(this.device);
+        await this.device.led.setLedMatrix(matrix);
     }
     async getMagnetometerData() {
-        return this.connection?.magnetometer.getData();
+        assertConnected(this.device);
+        return this.device.magnetometer.getData();
     }
     async getMagnetometerPeriod() {
-        return this.connection?.magnetometer.getPeriod();
+        assertConnected(this.device);
+        return this.device.magnetometer.getPeriod();
     }
     async setMagnetometerPeriod(value) {
-        return this.connection?.magnetometer.setPeriod(value);
+        assertConnected(this.device);
+        return this.device.magnetometer.setPeriod(value);
     }
     async getMagnetometerBearing() {
-        return this.connection?.magnetometer.getBearing();
+        assertConnected(this.device);
+        return this.device.magnetometer.getBearing();
     }
     async triggerMagnetometerCalibration() {
-        await this.connection?.magnetometer.triggerCalibration();
+        assertConnected(this.device);
+        await this.device.magnetometer.triggerCalibration();
     }
     async uartWrite(data) {
-        await this.connection?.uart.writeData(data);
+        assertConnected(this.device);
+        await this.device.uart.writeData(data);
     }
     /**
      * Flash the micro:bit.
      *
-     * Note that this will always leave the connection disconnected.
+     * Always leaves the connection in {@link ConnectionStatus.Disconnected} state.
+     * Bluetooth connects directly to the application processor, which reboots
+     * after flashing, so the connection is necessarily lost. Call {@link connect}
+     * again after flashing to reconnect.
      *
      * @param dataSource The data to use.
      * @param options Flash options and progress callback.
@@ -301,10 +339,10 @@ class MicrobitWebBluetoothConnectionImpl extends TypedEventTarget {
         try {
             // We'll disconnect/reconnect multiple times due to device resets, but reporting this is unhelpful.
             this.deferredUpdatesPreviousStatus = this.status;
-            if (this.status !== ConnectionStatus.CONNECTED) {
+            if (this.status !== ConnectionStatus.Connected) {
                 await this.connect({ progress, signal: options.signal });
             }
-            const connection = this.connection;
+            const connection = this.device;
             try {
                 const boardVersion = connection.boardVersion;
                 if (!boardVersion) {
@@ -317,7 +355,7 @@ class MicrobitWebBluetoothConnectionImpl extends TypedEventTarget {
                 if (!memoryMap) {
                     throw new FlashDataError("Could not convert hex to memory map");
                 }
-                if (!this.device) {
+                if (!this.bleDevice) {
                     throw new DeviceError({
                         code: "device-disconnected",
                         message: "No device",
@@ -328,10 +366,32 @@ class MicrobitWebBluetoothConnectionImpl extends TypedEventTarget {
                 if (partialFlashResult === PartialFlashResult.AttemptFullFlash) {
                     await fullFlash(connection, boardVersion, memoryMap, progress);
                 }
-                else if (partialFlashResult === PartialFlashResult.Success) {
-                    if (connection.connected) {
-                        await connection.waitForDisconnect(10_000);
-                    }
+                this.dispatchEvent("flash");
+                if (partialFlashResult === PartialFlashResult.AlreadyUpToDate ||
+                    partialFlashResult === PartialFlashResult.Success) {
+                    this.waitForPostFlashDisconnectPromise = (async () => {
+                        try {
+                            if (connection.connected) {
+                                this.log("Wait for post partial flash disconnect...");
+                                await connection.waitForDisconnect(10_000);
+                            }
+                        }
+                        catch (e) {
+                            if (e instanceof TimeoutError) {
+                                this.log("Wait for post partial flash disconnect timed out.");
+                            }
+                            else {
+                                this.error("Error waiting for post partial flash disconnect", e);
+                            }
+                        }
+                        finally {
+                            this.waitForPostFlashDisconnectPromise = undefined;
+                            if (connection.connected) {
+                                await this.disconnect();
+                            }
+                        }
+                    })();
+                    this.setStatus(ConnectionStatus.Disconnected);
                 }
             }
             catch (e) {
@@ -339,13 +399,18 @@ class MicrobitWebBluetoothConnectionImpl extends TypedEventTarget {
                 throw e;
             }
             finally {
-                await this.disconnect();
+                if (!this.waitForPostFlashDisconnectPromise) {
+                    await this.disconnect();
+                }
             }
         }
         finally {
             const previousStatus = this.deferredUpdatesPreviousStatus;
             this.deferredUpdatesPreviousStatus = undefined;
-            this.dispatchTypedEvent("status", new ConnectionStatusEvent(this.status, previousStatus));
+            this.dispatchEvent("status", {
+                status: this.status,
+                previousStatus,
+            });
         }
     }
     /**
@@ -353,22 +418,33 @@ class MicrobitWebBluetoothConnectionImpl extends TypedEventTarget {
      *
      * @returns device or undefined if user cancels.
      */
-    async requestDeviceWeb(namePrefix) {
+    async requestDeviceWeb(namePrefixes) {
+        const optionalServices = [
+            profile.accelerometer.id,
+            profile.button.id,
+            profile.deviceInformation.id,
+            profile.dfuControl.id,
+            profile.event.id,
+            profile.ioPin.id,
+            profile.led.id,
+            profile.magnetometer.id,
+            profile.temperature.id,
+            profile.uart.id,
+        ];
+        // Temporarily patch navigator.bluetooth.requestDevice to support multiple
+        // name prefix filters. The capacitor-ble plugin only supports a single
+        // namePrefix, but the Web Bluetooth API supports a filters array.
+        // By patching at this level the plugin's internal deviceMap is populated
+        // naturally when its own requestDevice completes.
+        const orig = navigator.bluetooth.requestDevice.bind(navigator.bluetooth);
         try {
+            navigator.bluetooth.requestDevice = (options) => orig({
+                ...options,
+                filters: namePrefixes.map((namePrefix) => ({ namePrefix })),
+            });
             return await BleClient.requestDevice({
-                namePrefix,
-                optionalServices: [
-                    profile.accelerometer.id,
-                    profile.button.id,
-                    profile.deviceInformation.id,
-                    profile.dfuControl.id,
-                    profile.event.id,
-                    profile.ioPin.id,
-                    profile.led.id,
-                    profile.magnetometer.id,
-                    profile.temperature.id,
-                    profile.uart.id,
-                ],
+                namePrefix: namePrefixes[0],
+                optionalServices,
             });
         }
         catch (e) {
@@ -377,6 +453,9 @@ class MicrobitWebBluetoothConnectionImpl extends TypedEventTarget {
             }
             throw e;
         }
+        finally {
+            navigator.bluetooth.requestDevice = orig;
+        }
     }
     /**
      * Finds device with specified name prefix.
@@ -384,19 +463,17 @@ class MicrobitWebBluetoothConnectionImpl extends TypedEventTarget {
      * @returns device or undefined if none can be found.
      * @throws DeviceError with code "aborted" if signal is aborted.
      */
-    async requestDeviceNative(namePrefix, signal) {
+    async requestDeviceNative(namePrefixes, signal) {
         if (signal?.aborted) {
             throw new DeviceError({ code: "aborted", message: "Connection aborted" });
         }
+        const matchesAnyPrefix = (name) => !!name && namePrefixes.some((p) => name.startsWith(p));
         // Check for existing bonded devices.
-        const bonded = await this.checkBondedDevices((device) => {
-            const name = device.name;
-            return !!name && name.startsWith(namePrefix);
-        });
+        const bonded = await this.checkBondedDevices((device) => matchesAnyPrefix(device.name));
         if (bonded) {
             return bonded;
         }
-        this.log(`Scanning for device - ${namePrefix}`);
+        this.log(`Scanning for device - ${namePrefixes.join(", ")}`);
         let found = false;
         let aborted = false;
         const scanPromise = new Promise((resolve) => 
@@ -406,8 +483,8 @@ class MicrobitWebBluetoothConnectionImpl extends TypedEventTarget {
             // isn't matched by the name filter but the advertising name is in the
             // localName on the device. So we filter here instead.  This happens on
             // iOS if DFU fails / is interrupted.
-            if (result.device.name?.startsWith(namePrefix) ||
-                result.localName?.startsWith(namePrefix)) {
+            if (matchesAnyPrefix(result.device.name) ||
+                matchesAnyPrefix(result.localName)) {
                 found = true;
                 await BleClient.stopLEScan();
                 resolve(result.device);
@@ -452,4 +529,4 @@ const convertDataToMemoryMap = (data) => {
     }
     return MemoryMap.fromHex(truncateHexAfterEof(data));
 };
-//# sourceMappingURL=bluetooth.js.map
+//# sourceMappingURL=connection.js.map