ota-hub-reactjs 0.0.18 → 0.1.1

package/dist/base/device-whisperer.d.ts

@@ -31,12 +31,13 @@ export type DeviceConnectionState = {
 export declare function createDefaultInitialDeviceState<T extends DeviceConnectionState>(uuid: string, props?: any): T;
 export type DeviceWhispererProps<T extends DeviceConnectionState> = {
     createInitialConnectionState?: (uuid: string) => Partial<T>;
+    setFocussedConnectionOnAddConnection?: boolean;
 };
-export declare function MultiDeviceWhisperer<T extends DeviceConnectionState>({ createInitialConnectionState, }?: DeviceWhispererProps<T>): {
+export declare function useMultiDeviceWhisperer<T extends DeviceConnectionState>({ createInitialConnectionState, setFocussedConnectionOnAddConnection, }?: DeviceWhispererProps<T>): {
     focussedConnection: string | undefined;
     setFocussedConnection: import("react").Dispatch<import("react").SetStateAction<string | undefined>>;
     connections: T[];
-    addConnection: ({ uuid, propCreator }: AddConnectionProps<T>) => Promise<string>;
+    addConnection: ({ uuid, propCreator, }: AddConnectionProps<T>) => Promise<string>;
     removeConnection: (uuid: string) => void;
     connect: (_uuid: string) => void;
     disconnect: (_uuid: string) => void;

package/dist/base/device-whisperer.js

@@ -1,6 +1,5 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 import { useEffect, useRef, useState } from "react";
-;
 // Initial, generic state for the generic device
 export function createDefaultInitialDeviceState(uuid, props) {
     return {
@@ -11,13 +10,13 @@ export function createDefaultInitialDeviceState(uuid, props) {
         logs: [],
         readBufferLeftover: "",
         readBufferLeftoverAsBytes: new Uint8Array([]),
-        ...props
+        ...props,
     };
 }
 /* One Device Whisperer is used for all like-devices, such as all Serial with Protobuf.
    Any e.g. Serial without Protobuf, or LoRaWAN etc. devices would be handled via a separate device whisperer
 */
-export function MultiDeviceWhisperer({ createInitialConnectionState = createDefaultInitialDeviceState, } = {}) {
+export function useMultiDeviceWhisperer({ createInitialConnectionState = createDefaultInitialDeviceState, setFocussedConnectionOnAddConnection, } = {}) {
     const [connections, setConnections] = useState([]);
     const connectionsRef = useRef(new Map());
     const [isReady, setIsReady] = useState(false);
@@ -45,16 +44,19 @@ export function MultiDeviceWhisperer({ createInitialConnectionState = createDefa
         }));
     };
     // ---------- ADD ----------
-    const addConnection = async ({ uuid, propCreator }) => {
+    const addConnection = async ({ uuid, propCreator, }) => {
         uuid = uuid ?? `unnamed_device_${connectionsRef.current.size}`;
         const props = propCreator?.(uuid);
         const newConnection = {
             ...createDefaultInitialDeviceState(uuid),
             ...createInitialConnectionState(uuid),
-            ...props
+            ...props,
         };
         connectionsRef.current.set(uuid, newConnection);
         setConnections(Array.from(connectionsRef.current.values()));
+        // Automatically set to the latest connection
+        if (!!setFocussedConnectionOnAddConnection)
+            setFocussedConnection(uuid);
         return uuid;
     };
     // ---------- REMOVE ----------
@@ -82,6 +84,6 @@ export function MultiDeviceWhisperer({ createInitialConnectionState = createDefa
         appendLog,
         isReady,
         setIsReady,
-        createInitialConnectionState
+        createInitialConnectionState,
     };
 }

package/dist/message_layers/protobuf-wrapper.d.ts

@@ -1,13 +1,13 @@
-import { AddConnectionProps, DeviceConnectionState, MultiDeviceWhisperer } from "../base/device-whisperer.js";
+import { AddConnectionProps, DeviceConnectionState, useMultiDeviceWhisperer } from "../base/device-whisperer.js";
 export type TopicHandlerContext<AppLayer extends DeviceConnectionState> = {
-    base: ReturnType<typeof MultiDeviceWhisperer<AppLayer>>;
+    base: ReturnType<typeof useMultiDeviceWhisperer<AppLayer>>;
     uuid: string;
 };
 export type TopicHandlerMap<AppLayer extends DeviceConnectionState, Topic extends string | number, Message = any> = {
     [K in Topic]?: (message: Message, context: TopicHandlerContext<AppLayer>) => void;
 };
 export type ProtobufDeviceWhispererProps<AppLayer extends DeviceConnectionState, Topic extends string | number, MessageRX = any, MessageTX = any> = {
-    transportLayer: ReturnType<typeof MultiDeviceWhisperer<AppLayer>>;
+    transportLayer: ReturnType<typeof useMultiDeviceWhisperer<AppLayer>>;
     encodeRX: (message: MessageTX) => Uint8Array;
     decodeTX: (bytes: Uint8Array) => MessageRX;
     messageTypeField: keyof MessageRX;
@@ -15,8 +15,8 @@ export type ProtobufDeviceWhispererProps<AppLayer extends DeviceConnectionState,
     HEADER?: Uint8Array;
     expectLength?: boolean;
 };
-export declare function ProtobufMultiDeviceWhisperer<AppLayer extends DeviceConnectionState, Topic extends string | number, MessageRX = any, MessageTX = any>({ transportLayer, encodeRX, decodeTX, messageTypeField, rxTopicHandlerMap, HEADER, }: ProtobufDeviceWhispererProps<AppLayer, Topic, MessageRX, MessageTX>): {
-    addConnection: ({ uuid, propCreator }: AddConnectionProps<AppLayer>) => Promise<string>;
+export declare function useProtobufMultiDeviceWhisperer<AppLayer extends DeviceConnectionState, Topic extends string | number, MessageRX = any, MessageTX = any>({ transportLayer, encodeRX, decodeTX, messageTypeField, rxTopicHandlerMap, HEADER, }: ProtobufDeviceWhispererProps<AppLayer, Topic, MessageRX, MessageTX>): {
+    addConnection: ({ uuid, propCreator, }: AddConnectionProps<AppLayer>) => Promise<string>;
     sendProtobuf: (uuid: string, message: MessageTX) => void;
     protoBufOnReceiveHandler: (uuid: string, data: string | Uint8Array) => void;
     focussedConnection: string | undefined;

package/dist/message_layers/protobuf-wrapper.js

@@ -1,4 +1,4 @@
-export function ProtobufMultiDeviceWhisperer({ transportLayer, encodeRX, decodeTX, messageTypeField, rxTopicHandlerMap, HEADER = new Uint8Array([]), }) {
+export function useProtobufMultiDeviceWhisperer({ transportLayer, encodeRX, decodeTX, messageTypeField, rxTopicHandlerMap, HEADER = new Uint8Array([]), }) {
     // --- Utils ---
     const concatUint8Arrays = (a, b) => {
         const result = new Uint8Array(a.length + b.length);
@@ -10,7 +10,7 @@ export function ProtobufMultiDeviceWhisperer({ transportLayer, encodeRX, decodeT
         const length = payload.length;
         const header = new Uint8Array([
             (length >> 8) & 0xff, // Most significant byte first
-            length & 0xff // Least significant byte second
+            length & 0xff, // Least significant byte second
         ]);
         return concatUint8Arrays(header, payload);
     };
@@ -55,9 +55,7 @@ export function ProtobufMultiDeviceWhisperer({ transportLayer, encodeRX, decodeT
     // --- Inbound buffering ---
     const buffers = {};
     const protoBufOnReceiveHandler = (uuid, data) => {
-        const bytes = typeof data === "string"
-            ? new TextEncoder().encode(data)
-            : data;
+        const bytes = typeof data === "string" ? new TextEncoder().encode(data) : data;
         buffers[uuid] = concatUint8Arrays(buffers[uuid] || new Uint8Array(), bytes);
         let buffer = buffers[uuid];
         while (buffer.length > 0) {
@@ -73,14 +71,14 @@ export function ProtobufMultiDeviceWhisperer({ transportLayer, encodeRX, decodeT
                     catch (err) {
                         transportLayer.appendLog(uuid, {
                             level: 0,
-                            message: `[!] Error in handler for topic "${topic}": ${err}`
+                            message: `[!] Error in handler for topic "${topic}": ${err}`,
                         });
                     }
                 }
                 else {
                     transportLayer.appendLog(uuid, {
                         level: 1,
-                        message: `[!] Unknown Protobuf topic: "${topic}"`
+                        message: `[!] Unknown Protobuf topic: "${topic}"`,
                     });
                 }
                 buffer = buffers[uuid];
@@ -97,7 +95,7 @@ export function ProtobufMultiDeviceWhisperer({ transportLayer, encodeRX, decodeT
                 if (text) {
                     transportLayer.appendLog(uuid, {
                         level: 2,
-                        message: text
+                        message: text,
                     });
                 }
                 continue;
@@ -108,11 +106,11 @@ export function ProtobufMultiDeviceWhisperer({ transportLayer, encodeRX, decodeT
                 buffers[uuid] = buffer;
                 const preview = Array.from(garbage)
                     .slice(0, 16)
-                    .map(b => b.toString(16).padStart(2, '0'))
-                    .join(' ');
+                    .map((b) => b.toString(16).padStart(2, "0"))
+                    .join(" ");
                 transportLayer.appendLog(uuid, {
                     level: 1,
-                    message: `[!] Skipped invalid bytes before Protobuf header: ${preview}... (${garbage.length} bytes)`
+                    message: `[!] Skipped invalid bytes before Protobuf header: ${preview}... (${garbage.length} bytes)`,
                 });
                 continue;
             }
@@ -121,22 +119,22 @@ export function ProtobufMultiDeviceWhisperer({ transportLayer, encodeRX, decodeT
         buffers[uuid] = buffer;
     };
     // --- Override addConnection to wrap onReceive ---
-    const addConnection = async ({ uuid, propCreator }) => {
+    const addConnection = async ({ uuid, propCreator, }) => {
         return await transportLayer.addConnection({
             uuid,
             propCreator: (id) => {
                 const props = propCreator?.(id);
                 return {
                     onReceive: (data) => protoBufOnReceiveHandler(id, data),
-                    ...props
+                    ...props,
                 };
-            }
+            },
         });
     };
     return {
         ...transportLayer,
         addConnection,
         sendProtobuf,
-        protoBufOnReceiveHandler
+        protoBufOnReceiveHandler,
     };
 }

package/dist/transport_layers/esp32-device-whisperer.d.ts

@@ -5,6 +5,7 @@ export type ESP32ConnectionState = DeviceConnectionState & {
     baudrate?: number;
     transport?: Transport;
     esp?: ESPLoader;
+    reader?: AsyncGenerator<Uint8Array>;
     slipReadWrite?: boolean;
     isFlashing: boolean;
     flashProgress: number;
@@ -15,10 +16,10 @@ export type FlashFirmwareProps = {
     firmwareBlob?: Blob;
     fileArray?: FlashOptions["fileArray"];
 };
-export declare function ESP32MultiDeviceWhisperer<AppOrMessageLayer extends ESP32ConnectionState>({ releasePortByDefault, ...props }?: {
+export declare function useESP32MultiDeviceWhisperer<AppOrMessageLayer extends ESP32ConnectionState>({ releasePortByDefault, ...props }?: {
     releasePortByDefault: boolean;
 } & DeviceWhispererProps<AppOrMessageLayer>): {
-    addConnection: ({ uuid, propCreator }: AddConnectionProps<AppOrMessageLayer>) => Promise<string>;
+    addConnection: ({ uuid, propCreator, }: AddConnectionProps<AppOrMessageLayer>) => Promise<string>;
     removeConnection: (uuid: string) => Promise<void>;
     connect: (uuid: string, baudrate?: number, restart_on_connect?: boolean) => Promise<void>;
     disconnect: (uuid: string, timeout?: number) => Promise<void>;

package/dist/transport_layers/esp32-device-whisperer.js

@@ -1,12 +1,10 @@
 import { useEffect } from "react";
 import { ESPLoader, Transport } from "esptool-js";
-import { MultiDeviceWhisperer } from "../base/device-whisperer.js";
-export function ESP32MultiDeviceWhisperer({ releasePortByDefault, ...props } = { releasePortByDefault: true }) {
-    const base = MultiDeviceWhisperer(props);
+import { useMultiDeviceWhisperer, } from "../base/device-whisperer.js";
+export function useESP32MultiDeviceWhisperer({ releasePortByDefault, ...props } = { releasePortByDefault: true }) {
+    const base = useMultiDeviceWhisperer(props);
     const defaultOnReceive = (uuid, data) => {
-        const text = typeof data === "string"
-            ? data
-            : new TextDecoder().decode(data);
+        const text = typeof data === "string" ? data : new TextDecoder().decode(data);
         const trimmed = text.trim();
         if (!trimmed)
             return;
@@ -37,15 +35,15 @@ export function ESP32MultiDeviceWhisperer({ releasePortByDefault, ...props } = {
         let slipBuffer = []; // accumulate SLIP frames
         let inSlipFrame = false; // are we inside a SLIP frame?
         let escapeNext = false;
+        const reader = transport.rawRead();
+        base.updateConnection(uuid, (c) => ({ ...c, reader }));
         try {
-            const reader = transport.rawRead();
             while (true) {
                 const conn = base.getConnection(uuid);
                 if (!conn) {
                     console.log("Kack!");
                     return;
                 }
-                ;
                 const { value, done } = await reader.next();
                 if (done || !value)
                     break;
@@ -54,7 +52,7 @@ export function ESP32MultiDeviceWhisperer({ releasePortByDefault, ...props } = {
                     const b = bytes[i];
                     if (inSlipFrame) {
                         // SLIP decoding
-                        if (b === 0xC0) {
+                        if (b === 0xc0) {
                             if (slipBuffer.length > 0) {
                                 // complete SLIP frame received
                                 const payload = new Uint8Array(slipBuffer);
@@ -75,10 +73,10 @@ export function ESP32MultiDeviceWhisperer({ releasePortByDefault, ...props } = {
                             escapeNext = false;
                         }
                         else if (escapeNext) {
-                            if (b === 0xDC)
-                                slipBuffer.push(0xC0);
-                            else if (b === 0xDD)
-                                slipBuffer.push(0xDB);
+                            if (b === 0xdc)
+                                slipBuffer.push(0xc0);
+                            else if (b === 0xdd)
+                                slipBuffer.push(0xdb);
                             else {
                                 // protocol violation: discard frame
                                 slipBuffer = [];
@@ -86,7 +84,7 @@ export function ESP32MultiDeviceWhisperer({ releasePortByDefault, ...props } = {
                             }
                             escapeNext = false;
                         }
-                        else if (b === 0xDB) {
+                        else if (b === 0xdb) {
                             escapeNext = true;
                         }
                         else {
@@ -94,7 +92,7 @@ export function ESP32MultiDeviceWhisperer({ releasePortByDefault, ...props } = {
                         }
                         continue;
                     }
-                    if (b === 0xC0 && conn.slipReadWrite) {
+                    if (b === 0xc0 && conn.slipReadWrite) {
                         // start of a SLIP frame
                         inSlipFrame = true;
                         slipBuffer = [];
@@ -102,7 +100,9 @@ export function ESP32MultiDeviceWhisperer({ releasePortByDefault, ...props } = {
                         continue;
                     }
                     // treat as normal text (correctly)
-                    readBuffer += textDecoder.decode(new Uint8Array([b]), { stream: true });
+                    readBuffer += textDecoder.decode(new Uint8Array([b]), {
+                        stream: true,
+                    });
                     // check for newline
                     let newlineIndex;
                     while ((newlineIndex = readBuffer.indexOf("\n")) >= 0) {
@@ -122,6 +122,8 @@ export function ESP32MultiDeviceWhisperer({ releasePortByDefault, ...props } = {
             });
         }
         finally {
+            // Clear reader state so it's fresh for next connect
+            base.updateConnection(uuid, (c) => ({ ...c, reader: undefined }));
             base.appendLog(uuid, {
                 level: 0,
                 message: "[!] Serial disconnected",
@@ -149,11 +151,25 @@ export function ESP32MultiDeviceWhisperer({ releasePortByDefault, ...props } = {
         let port = conn?.port;
         if (!port) {
             port = await navigator.serial.requestPort({
-                filters: [{ usbVendorId: 0x303a }]
+                filters: [{ usbVendorId: 0x303a }],
             });
             base.updateConnection(uuid, (c) => ({ ...c, port }));
         }
-        ;
+        else {
+            try {
+                const oldInfo = port.getInfo();
+                const authorizedPorts = await navigator.serial.getPorts();
+                const freshPort = authorizedPorts.find((p) => p.getInfo().usbVendorId === oldInfo.usbVendorId &&
+                    p.getInfo().usbProductId === oldInfo.usbProductId);
+                if (freshPort) {
+                    port = freshPort; // Swap out the dead pointer
+                    base.updateConnection(uuid, (c) => ({ ...c, port }));
+                }
+            }
+            catch (e) {
+                console.warn(`[${uuid}] Failed to silently heal port reference:`, e);
+            }
+        }
         base.updateConnection(uuid, (c) => ({ ...c, isConnecting: true }));
         const use_baudrate = baudrate ?? conn.baudrate ?? 115200;
         const transport = new Transport(port, false, false);
@@ -161,7 +177,7 @@ export function ESP32MultiDeviceWhisperer({ releasePortByDefault, ...props } = {
             const esploader = new ESPLoader({
                 transport,
                 baudrate: use_baudrate,
-                enableTracing: false
+                enableTracing: false,
             });
             try {
                 await esploader.main();
@@ -170,7 +186,6 @@ export function ESP32MultiDeviceWhisperer({ releasePortByDefault, ...props } = {
                 console.log("failed to esploader.main()", e);
                 return;
             }
-            ;
             try {
                 const mac = await esploader.chip.readMac(esploader);
                 console.log("Mac from device:", mac);
@@ -182,36 +197,50 @@ export function ESP32MultiDeviceWhisperer({ releasePortByDefault, ...props } = {
             if (restart_on_connect) {
                 await restartDevice(uuid, transport);
             }
-            ;
             base.updateConnection(uuid, (c) => ({
                 ...c,
                 transport,
+                esp: esploader,
                 baudrate: use_baudrate,
                 isConnected: true,
                 isConnecting: false,
             }));
             base.appendLog(uuid, {
                 level: 2,
-                message: "[✓] Serial connected"
+                message: "[✓] Serial connected",
             });
             await conn.onConnect?.();
-            await readLoop(uuid, transport);
+            // FIRE AND FORGET
+            // We initiate the read loop but DO NOT await it, returning control immediately.
+            readLoop(uuid, transport).catch((e) => console.error(`[${uuid}] Background read loop failed:`, e));
         }
         catch (err) {
             base.updateConnection(uuid, (c) => ({
                 ...c,
                 isConnected: false,
-                isConnecting: false
+                isConnecting: false,
             }));
             base.appendLog(uuid, {
                 level: 0,
-                message: `[x] Serial connection error: ${err?.message || "Unknown error"}`
+                message: `[x] Serial connection error: ${err?.message || "Unknown error"}`,
             });
             await disconnect(uuid);
         }
     };
     const disconnect = async (uuid, timeout = 2000) => {
         const conn = base.getConnection(uuid);
+        // 1. POLITELY KILL THE READER
+        // If we have an active reader generator in state, call return() to
+        // gracefully resolve the pending reader.next() in the background loop
+        if (conn?.reader && typeof conn.reader.return === "function") {
+            try {
+                // @ts-ignore - The underlying AsyncGenerator handles return gracefully
+                await conn.reader.return();
+            }
+            catch (e) {
+                console.warn(`[${uuid}] Error returning generator lock:`, e);
+            }
+        }
         if (conn?.transport) {
             try {
                 // Attempt disconnect, but don’t hang if the port is crashed
@@ -227,32 +256,56 @@ export function ESP32MultiDeviceWhisperer({ releasePortByDefault, ...props } = {
         // Always clear the transport and reset connection state
         base.updateConnection(uuid, (c) => ({
             ...c,
-            port: releasePortByDefault ? null : c.port,
-            transport: releasePortByDefault ? null : c.transport,
+            port: releasePortByDefault ? undefined : c.port,
+            transport: releasePortByDefault ? undefined : c.transport,
+            reader: undefined, // Guarantee reader is cleared out
             isConnected: false,
             isConnecting: false,
             autoConnect: false,
         }));
         await conn?.onDisconnect?.();
     };
-    const addConnection = async ({ uuid, propCreator }) => {
+    const addConnection = async ({ uuid, propCreator, }) => {
         const port = await navigator.serial.requestPort({
-            filters: [{ usbVendorId: 0x303a }]
+            filters: [{ usbVendorId: 0x303a }],
         });
+        let deviceId = uuid;
+        // If no UUID provided, try to read the MAC address before registering the connection
+        if (!uuid) {
+            // 1. Interrogate the port for the MAC address BEFORE registering the connection
+            try {
+                const tempTransport = new Transport(port, false, false);
+                const tempLoader = new ESPLoader({
+                    transport: tempTransport,
+                    baudrate: 115200,
+                    enableTracing: false,
+                });
+                await tempLoader.main();
+                const mac = await tempLoader.chip.readMac(tempLoader);
+                if (mac) {
+                    deviceId = mac; // Swap 'unnamed_device_0' for the actual MAC
+                }
+                // Disconnect to release the port so connect() can start fresh
+                await tempTransport.disconnect();
+            }
+            catch (e) {
+                console.warn("Failed to pre-fetch MAC address. Falling back to default UUID.", e);
+            }
+        }
+        // 2. Register the connection using the real MAC address
         const return_uuid = await base.addConnection({
-            uuid,
+            uuid: deviceId,
             propCreator: (id) => {
                 const props = propCreator?.(id);
                 return {
                     send: (d) => defaultSend(id, d),
                     onReceive: (d) => defaultOnReceive(id, d),
                     port,
-                    // Initial connection state
                     ...base.createInitialConnectionState(id),
-                    // From props
-                    ...props
+                    deviceMac: deviceId, // Lock it in immediately
+                    ...props,
                 };
-            }
+            },
         });
         const conn = base.getConnection(return_uuid);
         if (conn?.autoConnect)
@@ -264,11 +317,10 @@ export function ESP32MultiDeviceWhisperer({ releasePortByDefault, ...props } = {
             await disconnect(uuid);
         }
         catch (e) { }
-        ;
         base.removeConnection(uuid);
     };
     const reconnectAll = async (...connectionProps) => {
-        const connectionIds = base.connections.map(c => c.uuid);
+        const connectionIds = base.connections.map((c) => c.uuid);
         await Promise.all(connectionIds.map(async (id) => {
             const c = base.getConnection(id);
             if (!c)
@@ -281,17 +333,28 @@ export function ESP32MultiDeviceWhisperer({ releasePortByDefault, ...props } = {
     // This function now handles an entire device flashing session
     const handleFlashFirmware = async (uuid, assetsToFlash) => {
         const conn = base.getConnection(uuid);
-        if (!conn || !conn.port || assetsToFlash.length === 0)
+        // 1. Bail if we don't have the required state
+        if (!conn ||
+            !conn.transport ||
+            !conn.port ||
+            !conn.esp ||
+            assetsToFlash.length === 0)
             return;
+        // Gracefully cancel reader and completely drop the transport natively
         await disconnect(uuid);
-        base.updateConnection(uuid, (c) => ({ ...c, isFlashing: true, flashProgress: 0, flashError: undefined }));
+        base.updateConnection(uuid, (c) => ({
+            ...c,
+            isFlashing: true,
+            flashProgress: 0,
+            flashError: undefined,
+        }));
         try {
             // --- Connect ONCE ---
             const transport = new Transport(conn.port, true);
             const esploader = new ESPLoader({
                 transport,
                 baudrate: 921600,
-                enableTracing: false
+                enableTracing: false,
             });
             try {
                 await esploader.main();
@@ -300,7 +363,6 @@ export function ESP32MultiDeviceWhisperer({ releasePortByDefault, ...props } = {
                 console.log("failed to esploader.main()", e);
                 return;
             }
-            ;
             // --- Prepare an ARRAY of files for the library ---
             const fileArray = await Promise.all(assetsToFlash.map(async ({ blob, address }) => {
                 const arrayBuffer = await blob.arrayBuffer();
@@ -320,7 +382,10 @@ export function ESP32MultiDeviceWhisperer({ releasePortByDefault, ...props } = {
                     // You can enhance progress reporting to show which file is being flashed
                     const progress = (written / total) * 100;
                     console.log(`Flashing file ${fileIndex + 1}/${fileArray.length}: ${progress.toFixed(1)}%`);
-                    base.updateConnection(uuid, (c) => ({ ...c, flashProgress: progress }));
+                    base.updateConnection(uuid, (c) => ({
+                        ...c,
+                        flashProgress: progress,
+                    }));
                 },
             };
             // --- Call writeFlash ONCE with all files ---
@@ -331,7 +396,6 @@ export function ESP32MultiDeviceWhisperer({ releasePortByDefault, ...props } = {
             catch (e) {
                 console.log("failed to esploader.writeFlash", e);
             }
-            ;
             // --- Disconnect ---
             await esploader.after();
             try {
@@ -343,7 +407,13 @@ export function ESP32MultiDeviceWhisperer({ releasePortByDefault, ...props } = {
                 await conn.port?.writable?.close();
                 await conn.port?.close();
             }
-            base.updateConnection(uuid, (c) => ({ ...c, isFlashing: false, flashProgress: 100 }));
+            base.updateConnection(uuid, (c) => ({
+                ...c,
+                isFlashing: false,
+                flashProgress: 100,
+            }));
+            // --- Reconnect the standard monitor ---
+            await connect(uuid);
         }
         catch (e) {
             console.error(`[${uuid}] Flashing failed:`, e);
@@ -352,6 +422,8 @@ export function ESP32MultiDeviceWhisperer({ releasePortByDefault, ...props } = {
                 isFlashing: false,
                 flashError: e?.message ?? "Unknown error",
             }));
+            // Attempt recovery
+            await connect(uuid);
         }
     };
     useEffect(() => {
@@ -364,6 +436,6 @@ export function ESP32MultiDeviceWhisperer({ releasePortByDefault, ...props } = {
         connect,
         disconnect,
         reconnectAll,
-        handleFlashFirmware
+        handleFlashFirmware,
     };
 }

package/dist/transport_layers/mqtt-device-whisperer.d.ts

@@ -13,8 +13,9 @@ export type MQTTConnectionState = DeviceConnectionState & {
     pingFunction?: (props?: any) => void;
     touchHeartbeat?: () => void;
 };
-export declare function MQTTMultiDeviceWhisperer<AppOrMessageLayer extends MQTTConnectionState>({ serverUrl, uuidFromMessage, subTopicFromUuid, pubTopicFromUuid, serverPort, clientId, username, password, serverAutoConnect, serverConnectOn, ...props }: {
-    serverUrl: string;
+export declare function useMQTTMultiDeviceWhisperer<AppOrMessageLayer extends MQTTConnectionState>({ serverUrl, serverUrlFnc, uuidFromMessage, subTopicFromUuid, pubTopicFromUuid, serverPort, clientId, username, password, serverAutoConnect, serverConnectOn, enableWatchdog, ...props }: {
+    serverUrl?: string;
+    serverUrlFnc?: () => Promise<string> | string;
     uuidFromMessage: (topic: string, payload: Buffer<ArrayBufferLike>) => string;
     subTopicFromUuid?: (uuid: string) => string;
     pubTopicFromUuid?: (uuid: string) => string;
@@ -24,13 +25,14 @@ export declare function MQTTMultiDeviceWhisperer<AppOrMessageLayer extends MQTTC
     password?: string;
     serverAutoConnect?: boolean;
     serverConnectOn?: boolean;
+    enableWatchdog?: boolean;
 } & DeviceWhispererProps<AppOrMessageLayer>): {
-    addConnection: ({ uuid, propCreator }: AddConnectionProps<AppOrMessageLayer>) => Promise<string | undefined>;
+    addConnection: ({ uuid, propCreator, }: AddConnectionProps<AppOrMessageLayer>) => Promise<string>;
     removeConnection: (uuid: string) => Promise<void>;
     connect: (uuid: string) => Promise<void>;
     disconnect: (uuid: string) => Promise<void>;
     reconnectAll: () => Promise<void>;
-    connectToMQTTServer: () => (() => void) | undefined;
+    connectToMQTTServer: () => Promise<void>;
     focussedConnection: string | undefined;
     setFocussedConnection: import("react").Dispatch<import("react").SetStateAction<string | undefined>>;
     connections: AppOrMessageLayer[];