@robotical/webapp-types 3.17.51 → 3.18.1

package/dist-types/src/wrapper-app/WrapperAppManager.js

@@ -45,7 +45,7 @@ var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
 };
 import { WrapperSentMessage } from "../types/communication-between-apps/wrapper-communication";
 import Logger from "../services/logger/Logger";
-import { RaftConnEvent } from "@robotical/raftjs";
+import { RaftConnEvent } from "@robdobsn/raftjs";
 import { ConnManager } from "@robotical/roboticaljs";
 import ConnectorFactory from "./connectors/ConnectorFactory";
 import ColourSensorManualCalibratorMarty from "./utils/ColourSensorManualCalibratorMarty";
@@ -56,6 +56,10 @@ var WrapperAppManager = /** @class */ (function () {
     function WrapperAppManager() {
         // Connectors 
         this.connectors = {};
+        this._connectPromise = null;
+        this._disconnectOperations = {};
+        this._pendingConnManagers = new Set();
+        this._pageUnloadStarted = false;
         // Observers
         this._observers = {};
     }
@@ -74,35 +78,120 @@ var WrapperAppManager = /** @class */ (function () {
     *
     */
     WrapperAppManager.prototype.connect = function (method, uuids) {
+        var _this = this;
+        if (this._pageUnloadStarted) {
+            return Promise.resolve({ success: false, reason: "failed" });
+        }
+        if (this._connectPromise) {
+            return this._connectPromise;
+        }
+        if (Object.values(this._disconnectOperations).some(Boolean)) {
+            Logger.warn(SHOW_LOGS, TAG, "Refusing to start a connection while Bluetooth teardown is in progress");
+            return Promise.resolve({ success: false, reason: "failed" });
+        }
+        var connectPromise = this._connect(method, uuids);
+        this._connectPromise = connectPromise;
+        var clearConnectPromise = function () {
+            if (_this._connectPromise === connectPromise) {
+                _this._connectPromise = null;
+            }
+        };
+        void connectPromise.then(clearConnectPromise, clearConnectPromise);
+        return connectPromise;
+    };
+    WrapperAppManager.prototype._connect = function (method, uuids) {
         return __awaiter(this, void 0, void 0, function () {
-            var connector, connectionResults, raftSystemUtils, systemInfo, raftName;
+            var connector, pendingConnManager, committed, disconnectedBeforeCommit, ownedConnector_1, connectionResults, existingConnector, raftSystemUtils, systemInfo, raftName, error_1;
+            var _this = this;
             return __generator(this, function (_a) {
                 switch (_a.label) {
-                    case 0: return [4 /*yield*/, ConnectorFactory.connectToRaftHelper(method, uuids)];
+                    case 0:
+                        connector = null;
+                        pendingConnManager = null;
+                        committed = false;
+                        disconnectedBeforeCommit = false;
+                        _a.label = 1;
                     case 1:
+                        _a.trys.push([1, , 4, 11]);
+                        return [4 /*yield*/, ConnectorFactory.connectToRaftHelper(method, uuids, function (connManager) {
+                                pendingConnManager = connManager;
+                                _this._pendingConnManagers.add(connManager);
+                                if (_this._pageUnloadStarted) {
+                                    _this._disconnectConnManagerForPageUnload(connManager);
+                                }
+                            })];
+                    case 2:
                         connector = _a.sent();
-                        if (!connector) {
+                        if (!connector || this._pageUnloadStarted) {
                             Logger.warn(SHOW_LOGS, TAG, "Failed to connect to RAFT with method: ".concat(method));
                             return [2 /*return*/, { success: false, reason: "failed" }];
                         }
-                        return [4 /*yield*/, connector.connect()];
-                    case 2:
-                        connectionResults = _a.sent();
-                        if (connectionResults.success) {
-                            this.connectors[connector.id] = connector;
-                            raftSystemUtils = connector.connManager.getConnector().getRaftSystemUtils();
-                            systemInfo = raftSystemUtils.getCachedSystemInfo() || undefined;
-                            raftName = raftSystemUtils.getCachedRaftName() || raftSystemUtils.getFriendlyName();
-                            if (systemInfo && (raftName === null || raftName === void 0 ? void 0 : raftName.friendlyName)) {
-                                systemInfo.Friendly = raftName.friendlyName;
+                        ownedConnector_1 = connector;
+                        connector.setOnDisconnected(function () {
+                            if (!committed) {
+                                disconnectedBeforeCommit = true;
                             }
-                            connectionResults.data = { raftId: connector.id, raftType: connector.type, systemInfo: systemInfo };
+                            _this._handleDisconnectedEvent(ownedConnector_1);
+                        });
+                        if (disconnectedBeforeCommit || !connector.connManager.isConnected()) {
+                            return [2 /*return*/, { success: false, reason: "failed" }];
                         }
-                        else {
+                        return [4 /*yield*/, connector.connect()];
+                    case 3:
+                        connectionResults = _a.sent();
+                        if (!connectionResults.success) {
                             Logger.warn(SHOW_LOGS, TAG, "Failed to connect to RAFT with id: ".concat(connector.id, " and type: ").concat(connector.type));
+                            return [2 /*return*/, connectionResults];
+                        }
+                        if (this._pageUnloadStarted ||
+                            disconnectedBeforeCommit ||
+                            !connector.connManager.isConnected()) {
+                            Logger.warn(SHOW_LOGS, TAG, "RAFT disconnected before setup completed: ".concat(connector.id));
+                            return [2 /*return*/, { success: false, reason: "failed" }];
+                        }
+                        existingConnector = this.connectors[connector.id];
+                        if (existingConnector && existingConnector !== connector) {
+                            Logger.warn(SHOW_LOGS, TAG, "Refusing to replace active RAFT connector with id: ".concat(connector.id));
+                            return [2 /*return*/, { success: false, reason: "failed" }];
+                        }
+                        raftSystemUtils = connector.connManager.getConnector().getRaftSystemUtils();
+                        systemInfo = raftSystemUtils.getCachedSystemInfo() || undefined;
+                        raftName = raftSystemUtils.getCachedRaftName() || raftSystemUtils.getFriendlyName();
+                        if (systemInfo && (raftName === null || raftName === void 0 ? void 0 : raftName.friendlyName)) {
+                            systemInfo.Friendly = raftName.friendlyName;
                         }
+                        if (this._pageUnloadStarted ||
+                            disconnectedBeforeCommit ||
+                            !connector.connManager.isConnected()) {
+                            return [2 /*return*/, { success: false, reason: "failed" }];
+                        }
+                        connectionResults.data = { raftId: connector.id, raftType: connector.type, systemInfo: systemInfo };
+                        this.connectors[connector.id] = connector;
+                        committed = true;
                         Logger.info(SHOW_LOGS, TAG, "Connected to RAFT with id: ".concat(connector.id, " and type: ").concat(connector.type));
                         return [2 /*return*/, connectionResults];
+                    case 4:
+                        _a.trys.push([4, , 9, 10]);
+                        if (!(connector && !committed)) return [3 /*break*/, 8];
+                        _a.label = 5;
+                    case 5:
+                        _a.trys.push([5, 7, , 8]);
+                        return [4 /*yield*/, connector.disconnect()];
+                    case 6:
+                        _a.sent();
+                        return [3 /*break*/, 8];
+                    case 7:
+                        error_1 = _a.sent();
+                        Logger.warn(SHOW_LOGS, TAG, "Failed to clean up uncommitted connector ".concat(connector.id, ": ").concat(error_1));
+                        return [3 /*break*/, 8];
+                    case 8: return [3 /*break*/, 10];
+                    case 9:
+                        if (pendingConnManager) {
+                            this._pendingConnManagers.delete(pendingConnManager);
+                        }
+                        return [7 /*endfinally*/];
+                    case 10: return [7 /*endfinally*/];
+                    case 11: return [2 /*return*/];
                 }
             });
         });
@@ -273,17 +362,75 @@ var WrapperAppManager = /** @class */ (function () {
      * Stop verifying RAFT
      */
     WrapperAppManager.prototype.stopVerifyingRaft = function (isCorrectRIC, raftId) {
-        if (!isCorrectRIC) {
-            this._removeRICConnector(raftId, 3000);
-        }
-        return this.connectors[raftId].stopVerifyingRaft(isCorrectRIC);
+        var _a, _b;
+        return (_b = (_a = this.connectors[raftId]) === null || _a === void 0 ? void 0 : _a.stopVerifyingRaft(isCorrectRIC)) !== null && _b !== void 0 ? _b : Promise.resolve(false);
     };
     /**
      * Disconnect from a RAFT
      */
     WrapperAppManager.prototype.disconnect = function (raftId) {
-        this._removeRICConnector(raftId, 3000);
-        return this.connectors[raftId].disconnect();
+        var _this = this;
+        var connector = this.connectors[raftId];
+        if (!connector) {
+            return Promise.resolve(true);
+        }
+        var inFlightDisconnect = this._disconnectOperations[raftId];
+        if ((inFlightDisconnect === null || inFlightDisconnect === void 0 ? void 0 : inFlightDisconnect.connector) === connector) {
+            return inFlightDisconnect.promise;
+        }
+        var operation = Promise.resolve().then(function () { return connector.disconnect(); });
+        var disconnectPromise;
+        disconnectPromise = operation.finally(function () {
+            _this._removeConnectorIfCurrent(connector);
+            var trackedOperation = _this._disconnectOperations[raftId];
+            if ((trackedOperation === null || trackedOperation === void 0 ? void 0 : trackedOperation.connector) === connector &&
+                trackedOperation.promise === disconnectPromise) {
+                delete _this._disconnectOperations[raftId];
+            }
+        });
+        // Register ownership before connector code runs. A connector may emit a
+        // terminal event synchronously while disconnect() is being invoked.
+        this._disconnectOperations[raftId] = { connector: connector, promise: disconnectPromise };
+        return disconnectPromise;
+    };
+    /**
+     * Best-effort terminal cleanup. Page lifecycle events cannot reliably await
+     * async Bluetooth work, so each connector forwards to RaftJS synchronously.
+     */
+    WrapperAppManager.prototype.disconnectAllForPageUnload = function () {
+        this._pageUnloadStarted = true;
+        var pendingConnManagers = Array.from(this._pendingConnManagers);
+        for (var _i = 0, pendingConnManagers_1 = pendingConnManagers; _i < pendingConnManagers_1.length; _i++) {
+            var connManager = pendingConnManagers_1[_i];
+            this._disconnectConnManagerForPageUnload(connManager);
+        }
+        var connectors = Object.values(this.connectors);
+        for (var _a = 0, connectors_1 = connectors; _a < connectors_1.length; _a++) {
+            var connector = connectors_1[_a];
+            try {
+                connector.disconnectForPageUnload();
+            }
+            catch (error) {
+                Logger.warn(SHOW_LOGS, TAG, "Failed page-unload cleanup for connector ".concat(connector.id, ": ").concat(error));
+            }
+        }
+    };
+    WrapperAppManager.prototype._disconnectConnManagerForPageUnload = function (connManager) {
+        var connManagerWithPageUnload = connManager;
+        try {
+            if (typeof connManagerWithPageUnload.disconnectForPageUnload === "function") {
+                connManagerWithPageUnload.disconnectForPageUnload();
+                return;
+            }
+            connManager.getConnector().disconnectForPageUnload();
+        }
+        catch (error) {
+            Logger.warn(SHOW_LOGS, TAG, "Failed pending page-unload cleanup: ".concat(error));
+        }
+    };
+    WrapperAppManager.prototype.isConnected = function (raftId) {
+        var _a, _b;
+        return (_b = (_a = this.connectors[raftId]) === null || _a === void 0 ? void 0 : _a.connManager.isConnected()) !== null && _b !== void 0 ? _b : false;
     };
     /**
      * Audio streaming
@@ -314,16 +461,18 @@ var WrapperAppManager = /** @class */ (function () {
             });
         });
     };
-    /**
-     * Removes marty after a certain time
-     * Removes from the martys list after x seconds so that we can still get the last event
-     */
-    WrapperAppManager.prototype._removeRICConnector = function (connectorId, timeout) {
-        var _this = this;
-        var martyRemovalTimeout = setTimeout(function () {
-            delete _this.connectors[connectorId];
-            clearTimeout(martyRemovalTimeout);
-        }, timeout);
+    WrapperAppManager.prototype._removeConnectorIfCurrent = function (connector) {
+        if (this.connectors[connector.id] === connector) {
+            delete this.connectors[connector.id];
+        }
+    };
+    WrapperAppManager.prototype._handleDisconnectedEvent = function (connector) {
+        var _a;
+        // A requested disconnect keeps ownership until its Promise settles. An
+        // unsolicited terminal event has no such Promise, so release immediately.
+        if (((_a = this._disconnectOperations[connector.id]) === null || _a === void 0 ? void 0 : _a.connector) !== connector) {
+            this._removeConnectorIfCurrent(connector);
+        }
     };
     /**
      * Warranty Service bluetooth scan for device
@@ -334,17 +483,19 @@ var WrapperAppManager = /** @class */ (function () {
      */
     WrapperAppManager.prototype.scanForPotentialWarrantyDevice = function (existingDevices) {
         return __awaiter(this, void 0, void 0, function () {
-            var namesToIgnore, device_1, connector, isConnected, ricSystem, systemInfo, serialNumber, raftType, newDevice, error_1;
+            var namesToIgnore, warrantyConnManager, ownsTemporaryConnection, device_1, isConnected, connector, ricSystem, systemInfo, serialNumber, raftType, newDevice, error_2, error_3;
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
                         namesToIgnore = __spreadArray([], existingDevices.map(function (item) {
                             return { name: item.name || "" };
                         }), true).filter(function (item) { return item.name; });
+                        warrantyConnManager = new ConnManager();
+                        ownsTemporaryConnection = false;
                         _a.label = 1;
                     case 1:
-                        _a.trys.push([1, 9, , 10]);
-                        return [4 /*yield*/, ConnManager.getInstance().getBleDevicesWithGivenNamesToIgnore(namesToIgnore)];
+                        _a.trys.push([1, 7, 8, 14]);
+                        return [4 /*yield*/, warrantyConnManager.getBleDevicesWithGivenNamesToIgnore(namesToIgnore)];
                     case 2:
                         device_1 = _a.sent();
                         if (!device_1) {
@@ -353,40 +504,59 @@ var WrapperAppManager = /** @class */ (function () {
                         }
                         if (!!existingDevices.find(function (deviceInList) {
                             return deviceInList.id === device_1.id;
-                        })) return [3 /*break*/, 7];
-                        connector = ConnManager.getInstance().getConnector();
-                        return [4 /*yield*/, connector.initializeChannel("WebBLE")];
+                        })) return [3 /*break*/, 5];
+                        if (this._pageUnloadStarted) {
+                            return [2 /*return*/, existingDevices];
+                        }
+                        // The selected device remains outside the lease registry until
+                        // this connection attempt. ConnManager then atomically rejects an
+                        // ID already owned by the app instead of stealing its GATT server.
+                        this._pendingConnManagers.add(warrantyConnManager);
+                        ownsTemporaryConnection = true;
+                        return [4 /*yield*/, warrantyConnManager.connect("WebBLE", device_1, [ConnManager.RICUUID, ConnManager.COGUUID])];
                     case 3:
-                        _a.sent();
-                        return [4 /*yield*/, connector.connect(device_1)];
-                    case 4:
                         isConnected = _a.sent();
                         if (!isConnected) {
                             Logger.warn(SHOW_LOGS, TAG, "Failed to connect to device: ".concat(device_1.name));
                             return [2 /*return*/, existingDevices];
                         }
+                        connector = warrantyConnManager.getConnector();
                         ricSystem = connector.getRaftSystemUtils();
                         return [4 /*yield*/, ricSystem.getSystemInfo()];
-                    case 5:
+                    case 4:
                         systemInfo = _a.sent();
                         serialNumber = systemInfo.SerialNo || "";
                         raftType = systemInfo.SystemName;
-                        return [4 /*yield*/, connector.disconnect()];
-                    case 6:
-                        _a.sent();
                         newDevice = { id: device_1.id, name: device_1.name || "", serialNumber: serialNumber, type: raftType };
                         existingDevices.push(newDevice);
                         Logger.info(SHOW_LOGS, TAG, "".concat(device_1.name, " added to the list of robots."));
                         return [2 /*return*/, existingDevices];
-                    case 7:
+                    case 5:
                         Logger.warn(SHOW_LOGS, TAG, "".concat(device_1.name, " is already in the list of robots."));
-                        _a.label = 8;
-                    case 8: return [3 /*break*/, 10];
-                    case 9:
-                        error_1 = _a.sent();
-                        Logger.error(SHOW_LOGS, TAG, JSON.stringify(error_1));
+                        _a.label = 6;
+                    case 6: return [3 /*break*/, 14];
+                    case 7:
+                        error_2 = _a.sent();
+                        Logger.error(SHOW_LOGS, TAG, JSON.stringify(error_2));
                         return [2 /*return*/, existingDevices];
-                    case 10: return [2 /*return*/, existingDevices];
+                    case 8:
+                        if (!ownsTemporaryConnection) return [3 /*break*/, 13];
+                        _a.label = 9;
+                    case 9:
+                        _a.trys.push([9, 11, 12, 13]);
+                        return [4 /*yield*/, warrantyConnManager.disconnect()];
+                    case 10:
+                        _a.sent();
+                        return [3 /*break*/, 13];
+                    case 11:
+                        error_3 = _a.sent();
+                        Logger.warn(SHOW_LOGS, TAG, "Failed warranty connection cleanup: ".concat(error_3));
+                        return [3 /*break*/, 13];
+                    case 12:
+                        this._pendingConnManagers.delete(warrantyConnManager);
+                        return [7 /*endfinally*/];
+                    case 13: return [7 /*endfinally*/];
+                    case 14: return [2 /*return*/, existingDevices];
                 }
             });
         });
@@ -396,7 +566,7 @@ var WrapperAppManager = /** @class */ (function () {
      */
     WrapperAppManager.prototype.sendAtomicReadOperationToMarty = function (raftId) {
         return __awaiter(this, void 0, void 0, function () {
-            var raftConnector, systemType, error_2;
+            var raftConnector, systemType, error_4;
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
@@ -412,8 +582,8 @@ var WrapperAppManager = /** @class */ (function () {
                         _a.sent();
                         return [2 /*return*/, true];
                     case 3:
-                        error_2 = _a.sent();
-                        Logger.error(SHOW_LOGS, TAG, "Failed to send atomic read operation to Marty: ".concat(error_2));
+                        error_4 = _a.sent();
+                        Logger.error(SHOW_LOGS, TAG, "Failed to send atomic read operation to Marty: ".concat(error_4));
                         return [3 /*break*/, 4];
                     case 4: return [3 /*break*/, 6];
                     case 5:

package/dist-types/src/wrapper-app/communicators/WebAppCommunicator.js

@@ -116,7 +116,7 @@ var WebAppCommunicator = /** @class */ (function () {
 }());
 export default WebAppCommunicator;
 var receivedMessageHandler = function (receivedMessage, data, messagePromiseId) { return __awaiter(void 0, void 0, void 0, function () {
-    var _a, connectionResults, error_1, ricName, error_2, verifyResults, error_3, confirmVerifiedResults, error_4, stopVerifyResults, error_5, disconnectResults, error_6, restResults, error_7, missedConnEventResults, streamAudioResults, commsStats, calibrateColourSensorResults, error_8, resetColourSensorResults, error_9, deviceInfoResults, wasSaved, wasSaved, fileContents, existingDevices, devices, error_10, wasSent, error_11;
+    var _a, isConnected, connectionResults, error_1, ricName, error_2, verifyResults, error_3, confirmVerifiedResults, error_4, stopVerifyResults, error_5, disconnectResults, error_6, restResults, error_7, missedConnEventResults, streamAudioResults, commsStats, calibrateColourSensorResults, error_8, resetColourSensorResults, error_9, deviceInfoResults, wasSaved, wasSaved, fileContents, existingDevices, devices, error_10, wasSent, error_11;
     return __generator(this, function (_b) {
         switch (_b.label) {
             case 0:
@@ -146,11 +146,8 @@ var receivedMessageHandler = function (receivedMessage, data, messagePromiseId)
                 return [3 /*break*/, 54];
             case 1:
                 try {
-                    console.log("3");
-                    // const connectionResults = await wrapperAppManager.isConnected();
-                    console.log("12");
-                    // console.log("raft is connected results", connectionResults);
-                    window.wrapperCommunicator.onMessageResponse({ success: true, error: "", results: { log: "13" }, messagePromiseId: messagePromiseId });
+                    isConnected = wrapperAppManager.isConnected(data.raftId);
+                    window.wrapperCommunicator.onMessageResponse({ success: true, error: "", results: isConnected, messagePromiseId: messagePromiseId });
                 }
                 catch (error) {
                     window.wrapperCommunicator.onMessageResponse({ success: false, error: error.message, messagePromiseId: messagePromiseId });

package/dist-types/src/wrapper-app/connectors/CogConnector/CogConnector.d.ts

@@ -2,7 +2,7 @@ import { RaftInfoEvents } from "../../../types/events/raft-info";
 import { ConnectionAttemptResults, RaftTypeE } from "../../../types/raft";
 import Connector from "../Connector";
 import ConnectorInterface from "../ConnectorInterface";
-import { RaftConnEvent, RaftPublishEvent, RaftUpdateEvent } from "@robotical/raftjs";
+import { RaftConnEvent, RaftPublishEvent, RaftUpdateEvent } from "@robdobsn/raftjs";
 import { ConnManager } from "@robotical/roboticaljs";
 declare class CogConnector extends Connector implements ConnectorInterface {
     type: RaftTypeE;

package/dist-types/src/wrapper-app/connectors/CogConnector/CogConnector.js

@@ -53,7 +53,7 @@ import { RaftInfoEvents } from "../../../types/events/raft-info";
 import Logger from "../../../services/logger/Logger";
 import { RaftTypeE } from "../../../types/raft";
 import Connector from "../Connector";
-import { RaftConnEvent, RaftPublishEvent, RaftUpdateEvent } from "@robotical/raftjs";
+import { RaftConnEvent, RaftPublishEvent, RaftUpdateEvent } from "@robdobsn/raftjs";
 import { CogPublishedDataGetter } from "@robotical/roboticaljs";
 import { WrapperSentMessage } from "../../../types/communication-between-apps/wrapper-communication";
 var SHOW_LOGS = true;

package/dist-types/src/wrapper-app/connectors/Connector.d.ts

@@ -4,13 +4,14 @@ import { ConnectionAttemptResults, RaftTypeE } from "../../types/raft";
 import { RaftObserver } from "../../application/RAFTs/RaftObserver";
 import ConnectorInterface from "./ConnectorInterface";
 import { ConnManager, RICLedLcdColours } from "@robotical/roboticaljs";
-import { RaftOKFail, RaftConnEvent, RaftUpdateEvent, RaftPublishEvent } from "@robotical/raftjs";
+import { RaftOKFail, RaftConnEvent, RaftUpdateEvent, RaftPublishEvent } from "@robdobsn/raftjs";
 declare class Connector implements ConnectorInterface {
     id: string;
     type: RaftTypeE;
     protected _observers: {
         [key: string]: Array<RaftObserver>;
     };
+    private _onDisconnected?;
     connManager: ConnManager;
     constructor(id: string, connManager: ConnManager);
     /**
@@ -20,7 +21,7 @@ declare class Connector implements ConnectorInterface {
     /**
      * Get connected raft info
      */
-    getSystemInfo(): Promise<import("@robotical/raftjs").RaftSystemInfo>;
+    getSystemInfo(): Promise<import("@robdobsn/raftjs").RaftSystemInfo>;
     /**
      * Gets the RAFT name
      */
@@ -37,6 +38,17 @@ declare class Connector implements ConnectorInterface {
      * Disconnect from a RAFT
      */
     disconnect(): Promise<boolean>;
+    /**
+     * Register the manager-owned cleanup callback for a terminal disconnect event.
+     */
+    setOnDisconnected(onDisconnected: () => void): void;
+    /**
+     * Best-effort synchronous cleanup for page navigation/unload. Prefer the
+     * ConnManager boundary so its connection generation and Web BLE lease are
+     * finalized as well. The fallback keeps this app compatible with an older
+     * RoboticalJS package while the new ConnManager API is being released.
+     */
+    disconnectForPageUnload(): void;
     /**
      * Stop verifying RAFT
      * @param confirmCorrectRIC - indicates if the correct RAFT was selected (user input)

package/dist-types/src/wrapper-app/connectors/Connector.js

@@ -38,7 +38,7 @@ import { RaftInfoEvents } from "../../types/events/raft-info";
 import { WrapperSentMessage } from "../../types/communication-between-apps/wrapper-communication";
 import Logger from "../../services/logger/Logger";
 import { RaftTypeE } from "../../types/raft";
-import { RaftConnEvent, RaftUpdateEvent, RICRESTElemCode, } from "@robotical/raftjs";
+import { RaftConnEvent, RaftUpdateEvent, RICRESTElemCode, } from "@robdobsn/raftjs";
 var SHOW_LOGS = true;
 var TAG = "Connector";
 var formatRestCommand = function (msg, params) {
@@ -64,6 +64,7 @@ var Connector = /** @class */ (function () {
         // Set the listener function
         // Subscribe to connManager events
         this.connManager.setConnectionEventListener(function (eventType, eventEnum, eventName, eventData) {
+            var _a;
             if (eventType === "pub") {
                 // if it's a pub event, we are publishing it from _pubEventHandler method (in child classes)
             }
@@ -72,6 +73,9 @@ var Connector = /** @class */ (function () {
                 _this.publish(eventType, eventEnum, eventName, eventData);
             }
             _this.eventHandler(eventType, eventEnum, eventName, eventData);
+            if (eventType === "conn" && eventEnum === RaftConnEvent.CONN_DISCONNECTED) {
+                (_a = _this._onDisconnected) === null || _a === void 0 ? void 0 : _a.call(_this);
+            }
         });
     }
     /**
@@ -158,6 +162,26 @@ var Connector = /** @class */ (function () {
             });
         });
     };
+    /**
+     * Register the manager-owned cleanup callback for a terminal disconnect event.
+     */
+    Connector.prototype.setOnDisconnected = function (onDisconnected) {
+        this._onDisconnected = onDisconnected;
+    };
+    /**
+     * Best-effort synchronous cleanup for page navigation/unload. Prefer the
+     * ConnManager boundary so its connection generation and Web BLE lease are
+     * finalized as well. The fallback keeps this app compatible with an older
+     * RoboticalJS package while the new ConnManager API is being released.
+     */
+    Connector.prototype.disconnectForPageUnload = function () {
+        var connManagerWithPageUnload = this.connManager;
+        if (typeof connManagerWithPageUnload.disconnectForPageUnload === "function") {
+            connManagerWithPageUnload.disconnectForPageUnload();
+            return;
+        }
+        this.connManager.getConnector().disconnectForPageUnload();
+    };
     /**
      * Stop verifying RAFT
      * @param confirmCorrectRIC - indicates if the correct RAFT was selected (user input)

package/dist-types/src/wrapper-app/connectors/ConnectorFactory.d.ts

@@ -10,6 +10,6 @@ export default class ConnectorFactory {
      * @returns Promise<ConnectionAttemptResults>
      *
      */
-    static connectToRaftHelper(method: RaftConnectionMethod, uuids: string[]): Promise<Connector | null>;
+    static connectToRaftHelper(method: RaftConnectionMethod, uuids: string[], onConnManagerCreated?: (connManager: ConnManager) => void): Promise<Connector | null>;
     static createConnector(raftType: string | undefined, connManager: ConnManager): Connector;
 }

package/dist-types/src/wrapper-app/connectors/ConnectorFactory.js

@@ -52,25 +52,56 @@ var ConnectorFactory = /** @class */ (function () {
      * @returns Promise<ConnectionAttemptResults>
      *
      */
-    ConnectorFactory.connectToRaftHelper = function (method, uuids) {
+    ConnectorFactory.connectToRaftHelper = function (method, uuids, onConnManagerCreated) {
         return __awaiter(this, void 0, void 0, function () {
-            var connManager, wasConnected, systemInfo, raftType, connector;
+            var connManager, connectorWasCreated, lowLevelConnectionSucceeded, connectionResult, systemInfo, raftType, connector, error_1;
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
                         connManager = new ConnManager();
-                        Logger.info(SHOW_LOGS, TAG, "Connecting to RAFT with method: ".concat(method));
-                        return [4 /*yield*/, connManager.connect(method, "", uuids)];
+                        connectorWasCreated = false;
+                        lowLevelConnectionSucceeded = false;
+                        _a.label = 1;
                     case 1:
-                        wasConnected = _a.sent();
-                        Logger.info(SHOW_LOGS, TAG, "Was connected to RAFT: ".concat(wasConnected));
-                        if (!wasConnected) {
+                        _a.trys.push([1, , 3, 8]);
+                        onConnManagerCreated === null || onConnManagerCreated === void 0 ? void 0 : onConnManagerCreated(connManager);
+                        Logger.info(SHOW_LOGS, TAG, "Connecting to RAFT with method: ".concat(method));
+                        return [4 /*yield*/, connManager.connectDetailed(method, "", uuids)];
+                    case 2:
+                        connectionResult = _a.sent();
+                        lowLevelConnectionSucceeded = connectionResult.status === "success";
+                        Logger.info(SHOW_LOGS, TAG, "Connection result: ".concat(connectionResult.status));
+                        if (!lowLevelConnectionSucceeded) {
                             return [2 /*return*/, null];
                         }
                         systemInfo = connManager.getConnector().getRaftSystemUtils().getCachedSystemInfo();
                         raftType = systemInfo === null || systemInfo === void 0 ? void 0 : systemInfo.SystemName;
                         connector = this.createConnector(raftType, connManager);
+                        connectorWasCreated = true;
                         return [2 /*return*/, connector];
+                    case 3:
+                        if (!!connectorWasCreated) return [3 /*break*/, 7];
+                        if (!!lowLevelConnectionSucceeded) return [3 /*break*/, 4];
+                        // Before connectDetailed reports success there is no established
+                        // RAFT session to notify. Use immediate transport teardown for
+                        // chooser cancellation, generic failure, and thrown cancellation.
+                        // The graceful path sends `bledisconnect` retries and can otherwise
+                        // keep the UI pending for several seconds for a connection that
+                        // never existed.
+                        connManager.disconnectForPageUnload();
+                        return [3 /*break*/, 7];
+                    case 4:
+                        _a.trys.push([4, 6, , 7]);
+                        return [4 /*yield*/, connManager.disconnect()];
+                    case 5:
+                        _a.sent();
+                        return [3 /*break*/, 7];
+                    case 6:
+                        error_1 = _a.sent();
+                        Logger.warn(SHOW_LOGS, TAG, "Failed to clean up uncommitted RAFT connection: ".concat(error_1));
+                        return [3 /*break*/, 7];
+                    case 7: return [7 /*endfinally*/];
+                    case 8: return [2 /*return*/];
                 }
             });
         });

package/dist-types/src/wrapper-app/connectors/ConnectorInterface.d.ts

@@ -1,4 +1,4 @@
-import { RaftConnEvent, RaftPublishEvent, RaftUpdateEvent } from "@robotical/raftjs";
+import { RaftConnEvent, RaftPublishEvent, RaftUpdateEvent } from "@robdobsn/raftjs";
 import { ConnectionAttemptResults, RaftTypeE } from "../../types/raft";
 import { RaftInfoEvents } from "../../types/events/raft-info";
 import { RICLedLcdColours } from "@robotical/roboticaljs";

package/dist-types/src/wrapper-app/connectors/MartyConnector/MartyConnector.d.ts

@@ -2,7 +2,7 @@ import { RaftInfoEvents } from "../../../types/events/raft-info";
 import { ConnectionAttemptResults, RaftTypeE } from "../../../types/raft";
 import Connector from "../Connector";
 import ConnectorInterface from "../ConnectorInterface";
-import { RaftConnEvent, RaftUpdateEvent, RaftPublishEvent } from "@robotical/raftjs";
+import { RaftConnEvent, RaftUpdateEvent, RaftPublishEvent } from "@robdobsn/raftjs";
 import { ConnManager } from "@robotical/roboticaljs";
 declare class MartyConnector extends Connector implements ConnectorInterface {
     type: RaftTypeE;