@robotical/webapp-types 3.18.13 → 3.19.1

package/dist-types/src/application/RAFTs/RaftWifiManager.js

@@ -0,0 +1,329 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+import { RaftWifiConnState, RaftWifiConnStatus, } from "@robdobsn/raftjs";
+import Logger from "../../services/logger/Logger";
+var SHOW_LOGS = true;
+var TAG = "RaftWifiManager";
+var flagIsSet = function (value) {
+    return value === true ||
+        value === 1 ||
+        value === "1" ||
+        (typeof value === "string" && value.toLowerCase() === "true");
+};
+var responseSucceeded = function (response) {
+    return !!response &&
+        typeof response === "object" &&
+        "rslt" in response &&
+        String(response.rslt).toLowerCase() === "ok";
+};
+/**
+ * Wi-Fi provisioning is implemented by the common RAFT NetMan endpoints, so
+ * it is shared by Marty and Cog. The manager deliberately owns no transport:
+ * commands continue over the RAFT's current BLE or WebSocket connection.
+ */
+var RaftWifiManager = /** @class */ (function () {
+    function RaftWifiManager(raft, _defaultWiFiHostname) {
+        if (_defaultWiFiHostname === void 0) { _defaultWiFiHostname = "Raft"; }
+        this.raft = raft;
+        this._defaultWiFiHostname = _defaultWiFiHostname;
+        this._wifiConnStatus = new RaftWifiConnStatus();
+        this._maxSecsToWaitForWiFiConn = 20;
+        this._wifiScanDuration = 10000;
+    }
+    RaftWifiManager.prototype._getHostnameFromFriendlyName = function () {
+        var friendlyName = this.raft.getFriendlyName();
+        if (!friendlyName) {
+            return this._defaultWiFiHostname;
+        }
+        return friendlyName.replace(/ /g, "-").replace(/\W+/g, "") ||
+            this._defaultWiFiHostname;
+    };
+    RaftWifiManager.prototype.wifiConnect = function (ssid, password) {
+        return __awaiter(this, void 0, void 0, function () {
+            var credentialsCommand, response, error_1, timeoutCount;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        Logger.info(SHOW_LOGS, TAG, "Connecting ".concat(this.raft.type, " to Wi-Fi network ").concat(ssid));
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, 3, , 4]);
+                        credentialsCommand = [
+                            "w",
+                            encodeURIComponent(ssid),
+                            encodeURIComponent(password),
+                            encodeURIComponent(this._getHostnameFromFriendlyName()),
+                        ].join("/");
+                        return [4 /*yield*/, this.raft.sendRestMessage(credentialsCommand)];
+                    case 2:
+                        response = _a.sent();
+                        if (!responseSucceeded(response)) {
+                            Logger.warn(SHOW_LOGS, TAG, "NetMan rejected Wi-Fi credentials for ".concat(ssid));
+                            return [2 /*return*/, false];
+                        }
+                        return [3 /*break*/, 4];
+                    case 3:
+                        error_1 = _a.sent();
+                        Logger.warn(SHOW_LOGS, TAG, "Failed to send Wi-Fi credentials: ".concat(error_1));
+                        return [2 /*return*/, false];
+                    case 4:
+                        timeoutCount = 0;
+                        _a.label = 5;
+                    case 5:
+                        if (!(timeoutCount < this._maxSecsToWaitForWiFiConn)) return [3 /*break*/, 9];
+                        return [4 /*yield*/, new Promise(function (resolve) { return setTimeout(resolve, 1000); })];
+                    case 6:
+                        _a.sent();
+                        return [4 /*yield*/, this.getWiFiConnStatus()];
+                    case 7:
+                        _a.sent();
+                        if (this._wifiConnStatus.connState ===
+                            RaftWifiConnState.WIFI_CONN_CONNECTED) {
+                            return [2 /*return*/, true];
+                        }
+                        _a.label = 8;
+                    case 8:
+                        timeoutCount++;
+                        return [3 /*break*/, 5];
+                    case 9: return [2 /*return*/, false];
+                }
+            });
+        });
+    };
+    RaftWifiManager.prototype.wifiDisconnect = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var response, error_2;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 5, , 6]);
+                        return [4 /*yield*/, this.raft.sendRestMessage("wc/norestart")];
+                    case 1:
+                        response = _a.sent();
+                        if (!!responseSucceeded(response)) return [3 /*break*/, 3];
+                        return [4 /*yield*/, this.raft.sendRestMessage("wc")];
+                    case 2:
+                        // Older Marty firmware only implements the original command,
+                        // which restarts its network manager after clearing credentials.
+                        response = _a.sent();
+                        if (!responseSucceeded(response)) {
+                            return [2 /*return*/, false];
+                        }
+                        _a.label = 3;
+                    case 3: return [4 /*yield*/, this.getWiFiConnStatus()];
+                    case 4:
+                        _a.sent();
+                        return [2 /*return*/, true];
+                    case 5:
+                        error_2 = _a.sent();
+                        Logger.warn(SHOW_LOGS, TAG, "Failed to clear Wi-Fi credentials: ".concat(error_2));
+                        return [2 /*return*/, false];
+                    case 6: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    RaftWifiManager.prototype.getWiFiConnStatus = function () {
+        var _a, _b, _c, _d, _e, _f, _g, _h;
+        return __awaiter(this, void 0, void 0, function () {
+            var status_1, station, isConnected, isPaused, error_3;
+            return __generator(this, function (_j) {
+                switch (_j.label) {
+                    case 0:
+                        _j.trys.push([0, 2, , 3]);
+                        return [4 /*yield*/, this.raft.sendRestMessage("sysmodinfo/NetMan")];
+                    case 1:
+                        status_1 = _j.sent();
+                        if (String(status_1 === null || status_1 === void 0 ? void 0 : status_1.rslt).toLowerCase() !== "ok") {
+                            throw new Error("NetMan is unavailable");
+                        }
+                        station = status_1.wifiSTA;
+                        isConnected = station
+                            ? flagIsSet(station.conn)
+                            : flagIsSet(status_1.isConn);
+                        isPaused = station
+                            ? flagIsSet(station.paused)
+                            : flagIsSet(status_1.isPaused);
+                        this._wifiConnStatus.connState = isConnected
+                            ? RaftWifiConnState.WIFI_CONN_CONNECTED
+                            : RaftWifiConnState.WIFI_CONN_NONE;
+                        this._wifiConnStatus.isPaused = isPaused;
+                        this._wifiConnStatus.ipAddress = (_b = (_a = station === null || station === void 0 ? void 0 : station.IP) !== null && _a !== void 0 ? _a : status_1.IP) !== null && _b !== void 0 ? _b : "";
+                        this._wifiConnStatus.hostname = (_d = (_c = status_1.hostname) !== null && _c !== void 0 ? _c : status_1.Hostname) !== null && _d !== void 0 ? _d : "";
+                        this._wifiConnStatus.ssid = (_f = (_e = station === null || station === void 0 ? void 0 : station.SSID) !== null && _e !== void 0 ? _e : status_1.SSID) !== null && _f !== void 0 ? _f : "";
+                        this._wifiConnStatus.bssid = (_h = (_g = station === null || station === void 0 ? void 0 : station.MAC) !== null && _g !== void 0 ? _g : status_1.WiFiMAC) !== null && _h !== void 0 ? _h : "";
+                        this._wifiConnStatus.validMs = Date.now();
+                        return [2 /*return*/, isConnected || isPaused];
+                    case 2:
+                        error_3 = _j.sent();
+                        Logger.info(SHOW_LOGS, TAG, "Wi-Fi status is unavailable: ".concat(error_3));
+                        this._wifiConnStatus = new RaftWifiConnStatus();
+                        return [2 /*return*/, null];
+                    case 3: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    RaftWifiManager.prototype.pauseWifiConnection = function (pause) {
+        return __awaiter(this, void 0, void 0, function () {
+            var response, statusResult, error_4;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 4, , 5]);
+                        return [4 /*yield*/, this.raft.sendRestMessage(pause ? "wifipause/pause" : "wifipause/resume", undefined, { waitForResponse: false })];
+                    case 1:
+                        response = _a.sent();
+                        if (!responseSucceeded(response)) {
+                            return [2 /*return*/, false];
+                        }
+                        return [4 /*yield*/, new Promise(function (resolve) { return setTimeout(resolve, 250); })];
+                    case 2:
+                        _a.sent();
+                        return [4 /*yield*/, this.getWiFiConnStatus()];
+                    case 3:
+                        statusResult = _a.sent();
+                        return [2 /*return*/, statusResult !== null &&
+                                this._wifiConnStatus.isPaused === pause];
+                    case 4:
+                        error_4 = _a.sent();
+                        Logger.warn(SHOW_LOGS, TAG, "Failed to ".concat(pause ? "pause" : "resume", " Wi-Fi: ").concat(error_4));
+                        return [2 /*return*/, false];
+                    case 5: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    RaftWifiManager.prototype._wifiScanResults = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var response, error_5;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 2, , 3]);
+                        return [4 /*yield*/, this.raft.sendRestMessage("wifiscan/results")];
+                    case 1:
+                        response = _a.sent();
+                        return [2 /*return*/, response];
+                    case 2:
+                        error_5 = _a.sent();
+                        Logger.warn(SHOW_LOGS, TAG, "Failed to get Wi-Fi scan results: ".concat(error_5));
+                        return [2 /*return*/, false];
+                    case 3: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    RaftWifiManager.prototype._wifiScanStart = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var response, error_6;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 2, , 3]);
+                        return [4 /*yield*/, this.raft.sendRestMessage("wifiscan/start")];
+                    case 1:
+                        response = _a.sent();
+                        return [2 /*return*/, responseSucceeded(response)];
+                    case 2:
+                        error_6 = _a.sent();
+                        Logger.warn(SHOW_LOGS, TAG, "Failed to start Wi-Fi scan: ".concat(error_6));
+                        return [2 /*return*/, false];
+                    case 3: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    RaftWifiManager.prototype.getCachedWifiStatus = function () {
+        return this._wifiConnStatus;
+    };
+    RaftWifiManager.prototype.getWifiScanResults = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var statusResult, wasPaused, _a, results;
+            var _this = this;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0: return [4 /*yield*/, this.getWiFiConnStatus()];
+                    case 1:
+                        statusResult = _b.sent();
+                        if (statusResult === null) {
+                            return [2 /*return*/, false];
+                        }
+                        wasPaused = this._wifiConnStatus.isPaused;
+                        _b.label = 2;
+                    case 2:
+                        _b.trys.push([2, , 8, 11]);
+                        _a = wasPaused;
+                        if (!_a) return [3 /*break*/, 4];
+                        return [4 /*yield*/, this.pauseWifiConnection(false)];
+                    case 3:
+                        _a = !(_b.sent());
+                        _b.label = 4;
+                    case 4:
+                        if (_a) {
+                            return [2 /*return*/, false];
+                        }
+                        return [4 /*yield*/, this._wifiScanStart()];
+                    case 5:
+                        if (!(_b.sent())) {
+                            return [2 /*return*/, false];
+                        }
+                        return [4 /*yield*/, new Promise(function (resolve) { return setTimeout(resolve, _this._wifiScanDuration); })];
+                    case 6:
+                        _b.sent();
+                        return [4 /*yield*/, this._wifiScanResults()];
+                    case 7:
+                        results = _b.sent();
+                        if (results && "wifi" in results) {
+                            return [2 /*return*/, results];
+                        }
+                        return [2 /*return*/, false];
+                    case 8:
+                        if (!wasPaused) return [3 /*break*/, 10];
+                        return [4 /*yield*/, this.pauseWifiConnection(true)];
+                    case 9:
+                        _b.sent();
+                        _b.label = 10;
+                    case 10: return [7 /*endfinally*/];
+                    case 11: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    return RaftWifiManager;
+}());
+export { RaftWifiManager };

package/dist-types/src/application/communicators/WrapperCommunicator.js

@@ -39,6 +39,7 @@ import { AppSentMessage, WrapperSentMessage } from "../../types/communication-be
 import randomHashGenerator from "../../utils/helpers/randomHashGenerator";
 import isPhoneApp from "../../utils/phone-app-communication/is-phone-app";
 import SelfdestructiveMessagePromise from "./SelfdestructiveMessagePromise";
+import { RaftConnectionMethod } from "../../types/raft";
 var SHOW_LOGS = true;
 var TAG = "WrapperAppCommunicator";
 var WrapperCommunicator = /** @class */ (function () {
@@ -61,9 +62,12 @@ var WrapperCommunicator = /** @class */ (function () {
         var promise = new Promise(function (resolve, reject) {
             _this.messagePromises[messagePromiseId] = new SelfdestructiveMessagePromise(resolve, reject, messagePromiseId, _this.messagePromises, 
             // Choosing a physical Bluetooth device is user-mediated and has no
-            // application-safe deadline. The connecting modal owns cancellation;
-            // timing this bridge request out would orphan a later chooser result.
-            message === AppSentMessage.RAFT_CONNECT ? null : undefined);
+            // application-safe deadline. A direct WebSocket connection is not, so
+            // retain the normal bridge timeout if a native wrapper fails to reply.
+            message === AppSentMessage.RAFT_CONNECT &&
+                (data === null || data === void 0 ? void 0 : data.method) !== RaftConnectionMethod.WEB_SOCKET
+                ? null
+                : undefined);
         });
         var messageObject = {
             message: message,

package/dist-types/src/components/modals/VerificationModal/index.js

@@ -56,6 +56,8 @@ import SimpleButton from "../../disposables/buttons/SimpleButton";
 import LEDs from "../../oneoffs/LEDs";
 import { raftConnectingSubscriptionHelper } from "../../../application/RAFTs/raft-subscription-helpers";
 import { useTranslation } from "react-i18next";
+import { FaWifi } from "react-icons/fa";
+import { RaftConnectionMethod } from "../../../types/raft";
 function VerificationModal(_a) {
     var _this = this;
     var connectedRAFT_ = _a.connectedRAFT_;
@@ -65,6 +67,7 @@ function VerificationModal(_a) {
     var _d = useState(false), isActionPending = _d[0], setIsActionPending = _d[1];
     var actionStartedRef = useRef(false);
     var t = useTranslation().t;
+    var isWifiConnection = (connectedRAFT_ === null || connectedRAFT_ === void 0 ? void 0 : connectedRAFT_.connectionMethod) === RaftConnectionMethod.WEB_SOCKET;
     var claimVerificationAction = function () {
         if (actionStartedRef.current)
             return false;
@@ -126,7 +129,7 @@ function VerificationModal(_a) {
         /* Verify the connectedRaft once it's connected */
         connectedRAFT_ === null || connectedRAFT_ === void 0 ? void 0 : connectedRAFT_.verifyRaft();
     }, [connectedRAFT_]);
-    var contentJSX = _jsxs("div", __assign({ className: "verification-modal-container" }, { children: [_jsxs("div", __assign({ className: "verification-modal-martys-container" }, { children: [_jsxs("div", __assign({ className: "verification-modal-marty-name-row-container" }, { children: [_jsx("p", __assign({ className: "verification-modal-marty-name" }, { children: connectedRAFT_ === null || connectedRAFT_ === void 0 ? void 0 : connectedRAFT_.getFriendlyName() })), _jsx("div", __assign({ className: "verification-modal-marty-signal-container" }, { children: _jsx(RICSignal, { signalStrength: RSSI }) })), _jsx(BluetoothSVG, { fill: MAIN_BLUE })] })), _jsx("p", __assign({ className: "verification-modal-martys-back-hint" }, { children: t("verification_modal_phone.look_on_back", { raftType: connectedRAFT_ === null || connectedRAFT_ === void 0 ? void 0 : connectedRAFT_.type }) })), _jsxs("div", __assign({ className: "verification-modal-led-row-container" }, { children: [_jsx(LEDs, { coloursArr: randomColours, connectedRaft: connectedRAFT_ }), _jsx(SimpleButton, { onClick: onCancel, title: t("verification_modal_phone.no"), disabled: isActionPending, borderColour: "red", colour: "white", textColour: "red" }), _jsx(SimpleButton, { onClick: onYes, title: t("connection.yes"), disabled: isActionPending })] }))] })), _jsxs("div", __assign({ className: "verification-modal-bottom-btns-container" }, { children: [_jsx("div", { className: "dummy-gap" }), _jsx(SimpleButton, { onClick: onCancel, title: t("connection.cancel"), disabled: isActionPending })] }))] }));
+    var contentJSX = _jsxs("div", __assign({ className: "verification-modal-container" }, { children: [_jsxs("div", __assign({ className: "verification-modal-martys-container" }, { children: [_jsxs("div", __assign({ className: "verification-modal-marty-name-row-container" }, { children: [_jsx("p", __assign({ className: "verification-modal-marty-name" }, { children: connectedRAFT_ === null || connectedRAFT_ === void 0 ? void 0 : connectedRAFT_.getFriendlyName() })), _jsx("div", __assign({ className: "verification-modal-marty-signal-container" }, { children: _jsx(RICSignal, { signalStrength: RSSI }) })), isWifiConnection ? (_jsx(FaWifi, { className: "verification-modal-transport-icon", color: MAIN_BLUE, "aria-label": String(t("connection.wifi_title", "Wi-Fi")) })) : (_jsx(BluetoothSVG, { fill: MAIN_BLUE }))] })), _jsx("p", __assign({ className: "verification-modal-martys-back-hint" }, { children: t("verification_modal_phone.look_on_back", { raftType: connectedRAFT_ === null || connectedRAFT_ === void 0 ? void 0 : connectedRAFT_.type }) })), _jsxs("div", __assign({ className: "verification-modal-led-row-container" }, { children: [_jsx(LEDs, { coloursArr: randomColours, connectedRaft: connectedRAFT_ }), _jsx(SimpleButton, { onClick: onCancel, title: t("verification_modal_phone.no"), disabled: isActionPending, borderColour: "red", colour: "white", textColour: "red" }), _jsx(SimpleButton, { onClick: onYes, title: t("connection.yes"), disabled: isActionPending })] }))] })), _jsxs("div", __assign({ className: "verification-modal-bottom-btns-container" }, { children: [_jsx("div", { className: "dummy-gap" }), _jsx(SimpleButton, { onClick: onCancel, title: t("connection.cancel"), disabled: isActionPending })] }))] }));
     return contentJSX;
 }
 export default VerificationModal;

package/dist-types/src/components/modals/WifiConnectionModal/index.d.ts

@@ -0,0 +1,6 @@
+import { ConnectableRaftType } from "../../../types/raft";
+type Props = {
+    raftType: ConnectableRaftType;
+};
+export default function WifiConnectionModal({ raftType }: Props): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist-types/src/components/modals/WifiConnectionModal/index.js

@@ -0,0 +1,41 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState } from "react";
+import { useTranslation } from "react-i18next";
+import modalState from "../../../state-observables/modal/ModalState";
+import { RaftTypeE } from "../../../types/raft";
+import { normalizeWifiLocator } from "../../../utils/wifi-connection";
+import styles from "./styles.module.css";
+var MARTY_WIFI_GUIDE_URL = "https://userguides.robotical.io/martyv2/userguides/marty/wifi?s[]=wifi";
+export default function WifiConnectionModal(_a) {
+    var raftType = _a.raftType;
+    var t = useTranslation().t;
+    var _b = useState(""), endpoint = _b[0], setEndpoint = _b[1];
+    var _c = useState(""), error = _c[0], setError = _c[1];
+    var submit = function (event) {
+        event.preventDefault();
+        try {
+            var locator = normalizeWifiLocator(endpoint, raftType);
+            modalState.closeModalWithoutAnimation(locator);
+        }
+        catch (normalizationError) {
+            setError(normalizationError instanceof Error
+                ? normalizationError.message
+                : String(t("connection.wifi_invalid_endpoint", "Enter a valid IP address or hostname.")));
+        }
+    };
+    return (_jsxs("form", __assign({ className: styles.container, onSubmit: submit }, { children: [_jsx("p", __assign({ className: styles.description }, { children: t("connection.wifi_endpoint_prompt", "Enter the IP address or hostname shown in your device's Wi-Fi settings.") })), raftType === RaftTypeE.MARTY && (_jsxs("p", __assign({ className: styles.guide }, { children: [t("connection.wifi_marty_guide_prompt", "Need help connecting Marty to Wi-Fi?"), " ", _jsx("a", __assign({ className: styles.guideLink, href: MARTY_WIFI_GUIDE_URL, target: "_blank", rel: "noopener noreferrer" }, { children: t("connection.wifi_marty_guide_link", "View the step-by-step guide.") }))] }))), _jsx("label", __assign({ className: styles.label, htmlFor: "wifi-robot-endpoint" }, { children: t("connection.wifi_endpoint_label", "IP address or hostname") })), _jsx("input", { id: "wifi-robot-endpoint", className: styles.input, type: "text", value: endpoint, onChange: function (event) {
+                    setEndpoint(event.target.value);
+                    setError("");
+                }, autoCapitalize: "none", autoCorrect: "off", spellCheck: false, inputMode: "url", placeholder: String(t("connection.wifi_endpoint_placeholder", "192.168.1.42 or marty.local")), autoFocus: true }), error && (_jsx("p", __assign({ className: styles.error, role: "alert" }, { children: error }))), _jsxs("div", __assign({ className: styles.actions }, { children: [_jsx("button", __assign({ type: "button", className: styles.cancelButton, onClick: function () { return modalState.closeModalWithoutAnimation(false); } }, { children: t("connection.cancel") })), _jsx("button", __assign({ type: "submit", className: styles.connectButton }, { children: t("connection.wifi_connect", "Connect over Wi-Fi") }))] }))] })));
+}

package/dist-types/src/i18n.js

@@ -244,13 +244,22 @@ var resources = {
                 "choose_robot_cta": "Choose device to connect",
                 "choose_robot_prompt": "Choose the device you want to connect.",
                 "choose_robot_title": "Choose a Device",
+                "choose_transport_prompt": "Choose how you want to connect to your device.",
+                "choose_transport_title": "Choose a Connection",
+                "bluetooth_title": "Bluetooth",
+                "bluetooth_subtitle": "Choose a nearby device using Bluetooth.",
                 "cog_verification_prompt": "Choose how you want to verify your Cog connection.",
+                "cog_bluetooth_only": "Cog always connects using Bluetooth.",
+                "cog_wifi_unsupported": "Cog does not support Wi-Fi. Connect using Bluetooth instead.",
                 "connect_another_robot": "Connect another device",
                 "connect_cog": "Connect Cog",
-                "connect_cog_subtitle": "Choose Bluetooth verification with LED lights or QR.",
+                "connect_cog_subtitle": "Connect using Bluetooth.",
+                "connect_device": "Connect a device",
+                "connect_device_using_method": "Connect a device using {{method}}",
                 "connect_marty": "Connect Marty",
                 "connect_marty_instead": "Connect Marty instead",
-                "connect_marty_subtitle": "Connect using Bluetooth.",
+                "connect_marty_subtitle": "Connect using Bluetooth or Wi-Fi.",
+                "connect_using_method": "Connect using {{method}}.",
                 "connecting_to": "Connecting to",
                 "connecting_loading": "This shouldn't take long!",
                 "connecting_msg": "Connecting...",
@@ -266,6 +275,22 @@ var resources = {
                 "switch_to_front_camera": "Switch to front camera",
                 "switch_to_rear_camera": "Switch to rear camera",
                 "verification_method": "Verification Method",
+                "wait_for_disconnect": "Please wait for the current device disconnect to finish.",
+                "wifi_connect": "Connect over Wi-Fi",
+                "wifi_connect_failed": "Couldn't connect over Wi-Fi. Check the address, local-network permission, and that the device is online.",
+                "wifi_already_connected": "This Wi-Fi device is already connected or connecting.",
+                "wifi_connection_title": "Connect over Wi-Fi",
+                "wifi_endpoint_label": "IP address or hostname",
+                "wifi_endpoint_placeholder": "192.168.1.42 or marty.local",
+                "wifi_endpoint_prompt": "Enter the IP address or hostname shown in your device's Wi-Fi settings.",
+                "wifi_invalid_endpoint": "Enter a valid IP address or hostname.",
+                "wifi_marty_guide_link": "View the step-by-step guide.",
+                "wifi_marty_guide_prompt": "Need help connecting Marty to Wi-Fi?",
+                "wifi_robot_type_required": "Choose Marty or Cog before connecting over Wi-Fi.",
+                "wifi_subtitle": "Connect to a device on the same local network.",
+                "wifi_title": "Wi-Fi",
+                "wifi_wrong_robot_type": "The address belongs to a {{actualType}}, not a {{expectedType}}.",
+                "wifi_wrong_robot_type_generic": "The address belongs to a different kind of device.",
                 "yes": "Yes"
             },
             "detailed_feedback_modal": {
@@ -342,11 +367,26 @@ var resources = {
                 "games": "Cog Games",
                 "sensors": "Sensor Dashboard"
             },
+            "layout": {
+                "app_settings": "App settings",
+                "content_visibility": "Visible content",
+                "language_selector": "App language",
+                "marty_connection_method": "Marty connection method",
+                "primary_navigation": "Primary navigation",
+                "skip_to_main_content": "Skip to main content"
+            },
             "nav": {
                 "activities": "Activities",
+                "choose_robot_settings_prompt": "Choose a connected robot to configure.",
+                "choose_robot_settings_title": "Choose Robot Settings",
+                "currently_selected_robot": "Currently selected",
                 "games": "Cog Games",
                 "home": "Home",
-                "not_connected_robot_msg_for_configuration_page": "Oops! It looks like you’re not connected to a device. Connect to a device via Bluetooth to access the configuration page"
+                "open_robot_settings_for": "Open robot settings for {{name}}",
+                "robot_settings_unavailable": "Connect a device to access robot settings",
+                "robot_settings": "Robot settings",
+                "robot_type_cog": "Cog",
+                "robot_type_marty": "Marty"
             },
             "report_issue": {
                 "app_issue_desc": "Report an application issue.",

package/dist-types/src/store/ConnectionMethodPreference.d.ts

@@ -0,0 +1,7 @@
+export declare enum ConnectionMethodPreference {
+    BLUETOOTH = "bluetooth",
+    WIFI = "wifi"
+}
+export declare const getConnectionMethodPreference: () => ConnectionMethodPreference;
+export declare const setConnectionMethodPreference: (method: ConnectionMethodPreference) => void;
+export declare const useConnectionMethodPreference: () => readonly [ConnectionMethodPreference, (nextMethod: ConnectionMethodPreference) => void];

package/dist-types/src/store/ConnectionMethodPreference.js

@@ -0,0 +1,44 @@
+import { useCallback, useEffect, useState } from "react";
+export var ConnectionMethodPreference;
+(function (ConnectionMethodPreference) {
+    ConnectionMethodPreference["BLUETOOTH"] = "bluetooth";
+    ConnectionMethodPreference["WIFI"] = "wifi";
+})(ConnectionMethodPreference || (ConnectionMethodPreference = {}));
+var STORAGE_KEY = "connection.preferredMethod";
+var CHANGE_EVENT = "robotical:connection-method-change";
+export var getConnectionMethodPreference = function () {
+    try {
+        return window.localStorage.getItem(STORAGE_KEY) === ConnectionMethodPreference.WIFI
+            ? ConnectionMethodPreference.WIFI
+            : ConnectionMethodPreference.BLUETOOTH;
+    }
+    catch (_a) {
+        return ConnectionMethodPreference.BLUETOOTH;
+    }
+};
+export var setConnectionMethodPreference = function (method) {
+    try {
+        window.localStorage.setItem(STORAGE_KEY, method);
+    }
+    catch (_a) {
+        // Keep the current in-memory component state when storage is unavailable.
+    }
+    window.dispatchEvent(new CustomEvent(CHANGE_EVENT, { detail: method }));
+};
+export var useConnectionMethodPreference = function () {
+    var _a = useState(getConnectionMethodPreference), method = _a[0], setMethodState = _a[1];
+    useEffect(function () {
+        var syncMethod = function () { return setMethodState(getConnectionMethodPreference()); };
+        window.addEventListener(CHANGE_EVENT, syncMethod);
+        window.addEventListener("storage", syncMethod);
+        return function () {
+            window.removeEventListener(CHANGE_EVENT, syncMethod);
+            window.removeEventListener("storage", syncMethod);
+        };
+    }, []);
+    var setMethod = useCallback(function (nextMethod) {
+        setMethodState(nextMethod);
+        setConnectionMethodPreference(nextMethod);
+    }, []);
+    return [method, setMethod];
+};

package/dist-types/src/store/SelectedRaftContext.d.ts

@@ -1,4 +1,4 @@
-import { RaftTypeE } from '../types/raft';
+import { RaftConnectionMethod, RaftTypeE } from '../types/raft';
 export declare enum NewRobotIdE {
     NEW = "=+__new__+="
 }
@@ -7,6 +7,8 @@ export type ConnectedRaftItem = {
     name: string;
     type: RaftTypeE;
     isSelected: boolean;
+    connectionMethod?: RaftConnectionMethod | null;
+    connectionLocator?: string;
 };
 export declare const removeConnectedRaftFromList: (connectedRafts: ConnectedRaftItem[], connectedRaftId: string) => ConnectedRaftItem[];
 export declare const ConnectedRaftContentProvider: ({ children }: {

package/dist-types/src/store/SelectedRaftContext.js

@@ -61,7 +61,7 @@ export var ConnectedRaftContentProvider = function (_a) {
         // if the new raft is already in the list, do not add it again, just select it
         var existingRaft = connectedRafts.find(function (connectedRaft_) { return connectedRaft_.id === connectedRaft.id; });
         if (existingRaft) {
-            setConnectedRafts(function (prev) { return prev.map(function (connectedRaft_) { return (__assign(__assign({}, connectedRaft_), { isSelected: connectedRaft_.id === connectedRaft.id })); }); });
+            setConnectedRafts(function (prev) { return prev.map(function (connectedRaft_) { return (__assign(__assign(__assign({}, connectedRaft_), (connectedRaft_.id === connectedRaft.id ? connectedRaft : {})), { isSelected: connectedRaft_.id === connectedRaft.id })); }); });
             return;
         }
         // if the newly added raft is selected, deselect the previously selected raft

package/dist-types/src/types/raft.d.ts

@@ -4,6 +4,29 @@ export declare enum RaftConnectionMethod {
     WEB_BLE = "WebBLE",
     PHONE_BLE = "PhoneBLE"
 }
+export type ConnectableRaftType = RaftTypeE.MARTY | RaftTypeE.COG;
+/**
+ * Optional connection controls for host integrations such as MartyBlocks and
+ * Blocks Jr. Omitting `method` uses Marty's connection method selected in App
+ * Settings for Marty, while Cog always defaults to Bluetooth.
+ */
+export type RaftConnectOptions = {
+    method?: RaftConnectionMethod;
+    locator?: string;
+    expectedRaftType?: ConnectableRaftType;
+};
+/**
+ * Shared browser/native bridge contract for a direct RAFT connection.
+ *
+ * WebSocket locators are complete ws:// or wss:// URLs. Bluetooth connections
+ * use an empty locator because their platform chooser/discovery owns selection.
+ */
+export type RaftConnectRequest = {
+    method: RaftConnectionMethod;
+    locator: string;
+    uuids: string[];
+    expectedRaftType?: ConnectableRaftType;
+};
 export type ConnectionAttemptResults = {
     success: boolean;
     reason: 'failed' | 'unplugged' | 'success' | 'no_sys_info' | 'invalid_raft_type';

package/dist-types/src/utils/helpers/wifi-configuration-subtitle-gen.d.ts

@@ -1,4 +1,5 @@
 import RAFT from "../../application/RAFTs/RAFT";
 import { RaftWifiConnStatus } from "@robdobsn/raftjs";
 export declare const FW_VERSION_RSSI_WIFI = "1.2.0";
-export default function wifiConfigSub(raft: RAFT | undefined, cachedStatus: RaftWifiConnStatus | undefined): string | undefined;
+export type WifiCapability = "checking" | "supported" | "unsupported";
+export default function wifiConfigSub(raft: RAFT | undefined, cachedStatus: RaftWifiConnStatus | undefined, capability?: WifiCapability): string;