@robotical/webapp-types 3.25.5 → 3.25.7

package/dist-types/src/utils/colour-sensor-profile.js

@@ -0,0 +1,229 @@
+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 { COLOUR_DATABASE_URL, assertColourSensorActive, getColourSensors } from "./colour-sensor-diagnostics";
+import { classifyColour, colourChannelsFromValues } from "./colour-classifier";
+import { lockColourSensorOperation } from "./colour-sensor-operation";
+import { readColourSensorHardware, readColourSensorReadiness, readColourSensorRegister } from "./colour-sensor-registers";
+import { getPendingColourCalibration } from "./colour-calibration-reconnect";
+var PREFIX = "marty-colour-signal-profile:";
+var memory = new Map();
+var active = new WeakMap();
+var retries = new WeakMap();
+var profileKey = function (profile) {
+    return "".concat(profile.serialNumber, "/").concat(profile.offsetsHex).concat(profile.whiteCalibrationHex);
+};
+export var validColourSensorProfile = function (value) {
+    var profile = value;
+    return !!profile && profile.schemaVersion === 1 && /^[a-zA-Z0-9_-]{1,128}$/.test(profile.serialNumber) &&
+        ["97", "98"].includes(profile.typeCode) && typeof profile.firmwareVersion === "string" &&
+        /^[a-f0-9]{8}$/.test(profile.offsetsHex) && /^[a-f0-9]{16}$/.test(profile.whiteCalibrationHex) &&
+        Number.isFinite(profile.capturedAtMs) && profile.capturedAtMs > 0 && typeof profile.purpleIncluded === "boolean" &&
+        ["clearThreshold", "rgbFallback", "purpleSkipped"].includes(profile.groundDetection) &&
+        ["red", "green", "blue"].every(function (channel) {
+            var _a, _b, _c, _d, _e, _f;
+            var c = channel;
+            return [(_b = (_a = profile.signal) === null || _a === void 0 ? void 0 : _a.airMin) === null || _b === void 0 ? void 0 : _b[c], (_d = (_c = profile.signal) === null || _c === void 0 ? void 0 : _c.airMax) === null || _d === void 0 ? void 0 : _d[c], (_f = (_e = profile.signal) === null || _e === void 0 ? void 0 : _e.margin) === null || _f === void 0 ? void 0 : _f[c]]
+                .every(function (v) { return Number.isFinite(v) && v >= 0; }) && profile.signal.airMin[c] <= profile.signal.airMax[c] && profile.signal.margin[c] > 0;
+        });
+};
+export var cacheColourSensorProfile = function (profile) {
+    if (!validColourSensorProfile(profile))
+        return;
+    memory.set(profileKey(profile), profile);
+    try {
+        localStorage.setItem(PREFIX + profileKey(profile), JSON.stringify(profile));
+    }
+    catch ( /* Cloud records retain the profile too. */_a) { /* Cloud records retain the profile too. */ }
+};
+export var colourSensorProfilePath = function (profile) {
+    return "".concat(COLOUR_DATABASE_URL, "/colourSensorProfiles/").concat(profileKey(profile));
+};
+export var bindColourSensorProfile = function (sensor, profile) {
+    var profiles = active.get(sensor.raft);
+    if (!profiles) {
+        profiles = new Map();
+        active.set(sensor.raft, profiles);
+    }
+    profiles.set(sensor.key, profile);
+};
+export var getActiveColourSensorProfile = function (sensor) { var _a; return (_a = active.get(sensor.raft)) === null || _a === void 0 ? void 0 : _a.get(sensor.key); };
+export var getAddonColourSensorProfile = function (raft, addon) { var _a; return (_a = active.get(raft)) === null || _a === void 0 ? void 0 : _a.get(JSON.stringify([addon.id, addon.name])); };
+export var clearActiveColourSensorProfile = function (sensor) { var _a; return (_a = active.get(sensor.raft)) === null || _a === void 0 ? void 0 : _a.delete(sensor.key); };
+export var classifyColourAddon = function (addon) {
+    var _a;
+    var raft = Object.values(window.applicationManager.connectedRafts).find(function (candidate) {
+        return candidate.raftStateInfo && "addOnInfo" in candidate.raftStateInfo &&
+            candidate.raftStateInfo.addOnInfo.addons.some(function (current) { return current === addon; });
+    });
+    return classifyColour(colourChannelsFromValues(addon.vals), raft ? (_a = getAddonColourSensorProfile(raft, addon)) === null || _a === void 0 ? void 0 : _a.signal : undefined).classifiedColour;
+};
+// Check physical identity and the complete saved coordinate system before using a persisted profile.
+export var loadColourSensorProfile = function (sensor, signal) { return __awaiter(void 0, void 0, void 0, function () {
+    var release, check, readiness, hardware, white, offsets, identity, key_1, profile, stored, controller_1, abort, timeout, response, records, _a, state, current;
+    var _b;
+    return __generator(this, function (_c) {
+        switch (_c.label) {
+            case 0:
+                release = lockColourSensorOperation(sensor.raft, true);
+                if (!release)
+                    return [2 /*return*/];
+                check = function () { return assertColourSensorActive(sensor, signal); };
+                _c.label = 1;
+            case 1:
+                _c.trys.push([1, , 13, 14]);
+                check();
+                clearActiveColourSensorProfile(sensor);
+                return [4 /*yield*/, readColourSensorReadiness(sensor, signal, check)];
+            case 2:
+                readiness = _c.sent();
+                if (readiness.status !== "ok" || !readiness.value)
+                    return [2 /*return*/];
+                return [4 /*yield*/, readColourSensorHardware(sensor, signal, check)];
+            case 3:
+                hardware = _c.sent();
+                if (hardware.status !== "ok" || hardware.value.commsOk === 0 || !hardware.value.serialNumber ||
+                    !/^[a-zA-Z0-9_-]{1,128}$/.test(hardware.value.serialNumber))
+                    return [2 /*return*/];
+                return [4 /*yield*/, readColourSensorRegister(sensor, "4020", signal, check)];
+            case 4:
+                white = _c.sent();
+                if (white.status !== "ok")
+                    return [2 /*return*/];
+                return [4 /*yield*/, readColourSensorRegister(sensor, "4018", signal, check)];
+            case 5:
+                offsets = _c.sent();
+                if (offsets.status !== "ok")
+                    return [2 /*return*/];
+                identity = { serialNumber: hardware.value.serialNumber, offsetsHex: offsets.value, whiteCalibrationHex: white.value };
+                key_1 = profileKey(identity);
+                profile = memory.get(key_1);
+                try {
+                    stored = JSON.parse(localStorage.getItem(PREFIX + key_1) || "null");
+                    if (validColourSensorProfile(stored))
+                        profile = stored;
+                }
+                catch ( /* Native WebViews may have temporary or unavailable storage. */_d) { /* Native WebViews may have temporary or unavailable storage. */ }
+                if (!!profile) return [3 /*break*/, 12];
+                controller_1 = new AbortController();
+                abort = function () { return controller_1.abort(); };
+                signal.addEventListener("abort", abort, { once: true });
+                timeout = setTimeout(abort, 5000);
+                _c.label = 6;
+            case 6:
+                _c.trys.push([6, 10, 11, 12]);
+                return [4 /*yield*/, fetch("".concat(COLOUR_DATABASE_URL, "/colourSensorProfiles/").concat(key_1, ".json"), { signal: controller_1.signal })];
+            case 7:
+                response = _c.sent();
+                if (!response.ok) return [3 /*break*/, 9];
+                return [4 /*yield*/, response.json()];
+            case 8:
+                records = _c.sent();
+                if (records && typeof records === "object")
+                    profile = Object.values(records).filter(validColourSensorProfile)
+                        .filter(function (value) { return profileKey(value) === key_1; }).sort(function (a, b) { return b.capturedAtMs - a.capturedAtMs; })[0];
+                _c.label = 9;
+            case 9: return [3 /*break*/, 12];
+            case 10:
+                _a = _c.sent();
+                return [3 /*break*/, 12];
+            case 11:
+                clearTimeout(timeout);
+                signal.removeEventListener("abort", abort);
+                return [7 /*endfinally*/];
+            case 12:
+                check();
+                state = sensor.raft.raftStateInfo;
+                current = state.addOnInfo.addons.find(function (addon) { return addon.id === sensor.addon.id && addon.name === sensor.addon.name; });
+                if (!current || (current.status !== undefined && !(current.status & 128)) ||
+                    Date.now() - state.addOnInfoValidMs > 1500 || state.addOnInfoValidMs > Date.now() || ((_b = state.power) === null || _b === void 0 ? void 0 : _b.powerStatus.power5VIsOn) === false)
+                    return [2 /*return*/];
+                if (profile && profileKey(profile) === key_1 && profile.typeCode === hardware.value.typeCode &&
+                    profile.firmwareVersion === hardware.value.firmwareVersion) {
+                    cacheColourSensorProfile(profile);
+                    bindColourSensorProfile(sensor, profile);
+                }
+                return [3 /*break*/, 14];
+            case 13:
+                release();
+                return [7 /*endfinally*/];
+            case 14: return [2 /*return*/];
+        }
+    });
+}); };
+/** Read-only browser/WebView hydration. Never wakes sleeping sensors or modifies their registers. */
+export var startColourSensorProfileSync = function () {
+    var controllers = new Set();
+    var busy = new Set();
+    var poll = function () {
+        var _a;
+        if (document.hidden || !window.applicationManager)
+            return;
+        for (var _i = 0, _b = Object.keys(window.applicationManager.connectedRafts); _i < _b.length; _i++) {
+            var raftId = _b[_i];
+            var _loop_1 = function (sensor) {
+                var state = sensor.raft.raftStateInfo;
+                if (sensor.addon.status !== undefined && !(sensor.addon.status & 128))
+                    clearActiveColourSensorProfile(sensor);
+                if (busy.has(sensor.raft) || getPendingColourCalibration(sensor) || ((_a = state.power) === null || _a === void 0 ? void 0 : _a.powerStatus.power5VIsOn) === false ||
+                    !(sensor.addon.status === undefined || sensor.addon.status & 128) || Date.now() - state.addOnInfoValidMs > 1500)
+                    return "continue";
+                var times = retries.get(sensor.raft);
+                if (!times) {
+                    times = new Map();
+                    retries.set(sensor.raft, times);
+                }
+                if (Date.now() < (times.get(sensor.key) || 0))
+                    return "continue";
+                // Refresh occasionally to notice a swapped sensor or settings changed by another app.
+                times.set(sensor.key, Date.now() + 60000);
+                var controller = new AbortController();
+                controllers.add(controller);
+                busy.add(sensor.raft);
+                void loadColourSensorProfile(sensor, controller.signal).catch(function () { }).finally(function () {
+                    controllers.delete(controller);
+                    busy.delete(sensor.raft);
+                });
+            };
+            for (var _c = 0, _d = getColourSensors(raftId); _c < _d.length; _c++) {
+                var sensor = _d[_c];
+                _loop_1(sensor);
+            }
+        }
+    };
+    var timer = setInterval(poll, 1000);
+    return function () { clearInterval(timer); controllers.forEach(function (controller) { return controller.abort(); }); };
+};

package/dist-types/src/utils/colour-sensor-registers.d.ts

@@ -0,0 +1,53 @@
+import type { ColourSensor } from "./colour-sensor-diagnostics";
+type ReadFailure = "unsupported" | "timeout" | "commandFailed" | "invalidResponse" | "initialising" | "offline";
+export type SensorRead<T> = {
+    requestedAtMs: number;
+    receivedAtMs: number;
+} & ({
+    status: "ok";
+    value: T;
+} | {
+    status: "unavailable";
+    reason: ReadFailure;
+});
+type Channels = {
+    clear: number;
+    red: number;
+    green: number;
+    blue: number;
+    hexRd: string;
+};
+export type RawColourFrame = Channels & {
+    sensorStatusByte: number;
+    detectionFlags: number;
+    isOnAir: boolean;
+    touch: boolean;
+    irVal: number;
+    irReading: number;
+    irAmbient: number;
+};
+type SensorHardware = {
+    firmwareVersion: string | null;
+    typeCode: string | null;
+    serialNumber: string | null;
+    commsOk: number | null;
+};
+export type ColourSensorSetup = {
+    readiness: SensorRead<boolean>;
+    power?: SensorRead<boolean>;
+    hardware: SensorRead<SensorHardware>;
+    groundThreshold: SensorRead<{
+        storedValue: number;
+        hexRd: string;
+    }>;
+    offsets: SensorRead<Channels>;
+    whiteCalibration: SensorRead<Channels>;
+};
+export type ColourSensorRegister = "4014" | "4018" | "4020";
+export declare const readColourSensorRegister: (sensor: ColourSensor, address: ColourSensorRegister, signal: AbortSignal, checkActive: () => void) => Promise<SensorRead<string>>;
+export declare const readColourSensorHardware: (sensor: ColourSensor, signal: AbortSignal, checkActive: () => void) => Promise<SensorRead<SensorHardware>>;
+export declare const wakeColourSensor: (sensor: ColourSensor, signal: AbortSignal, checkActive: () => void) => Promise<SensorRead<boolean>>;
+export declare const readColourSensorReadiness: (sensor: ColourSensor, signal: AbortSignal, checkActive: () => void) => Promise<SensorRead<boolean>>;
+export declare const collectColourSensorSetup: (sensor: ColourSensor, signal: AbortSignal, checkActive: () => void) => Promise<ColourSensorSetup>;
+export declare const readRawColourSensor: (sensor: ColourSensor, signal: AbortSignal, checkActive: () => void) => Promise<SensorRead<RawColourFrame>>;
+export {};

package/dist-types/src/utils/colour-sensor-registers.js

@@ -0,0 +1,310 @@
+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);
+};
+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 { RICHWElemList_Str } from "@robotical/roboticaljs";
+var READ_TIMEOUT_MS = 1500;
+// The caller checks robot ownership, visibility and cancellation. Every exit removes the temporary observer.
+var read = function (signal, checkActive, start, timeoutMs) {
+    if (timeoutMs === void 0) { timeoutMs = READ_TIMEOUT_MS; }
+    return new Promise(function (resolve, reject) {
+        checkActive();
+        var requestedAtMs = Date.now();
+        var finished = false;
+        var dispose = function () { };
+        var cleanup = function () {
+            clearTimeout(timeout);
+            clearInterval(watchdog);
+            signal.removeEventListener("abort", guard);
+            dispose();
+        };
+        var finish = function (result) {
+            if (finished)
+                return;
+            finished = true;
+            cleanup();
+            resolve(__assign({ requestedAtMs: requestedAtMs, receivedAtMs: Date.now() }, result));
+        };
+        var guard = function () {
+            if (finished)
+                return;
+            try {
+                checkActive();
+            }
+            catch (failure) {
+                finished = true;
+                cleanup();
+                reject(failure);
+            }
+        };
+        var timeout = setTimeout(function () {
+            guard();
+            finish({ status: "unavailable", reason: "timeout" });
+        }, timeoutMs);
+        var watchdog = setInterval(guard, 100);
+        signal.addEventListener("abort", guard, { once: true });
+        var ok = function (value) { guard(); finish({ status: "ok", value: value }); };
+        var unavailable = function (reason) { guard(); finish({ status: "unavailable", reason: reason }); };
+        try {
+            dispose = start(ok, unavailable) || (function () { });
+        }
+        catch (_a) {
+            unavailable("commandFailed");
+        }
+        if (finished)
+            dispose();
+    });
+};
+var readHex = function (sensor, hexWr, bytes, signal, checkActive) {
+    return read(signal, checkActive, function (ok, unavailable) {
+        var raft = sensor.raft;
+        if (!raft.sendRestMessage || !raft.subscribe || !raft.unsubscribe) {
+            unavailable("unsupported");
+            return;
+        }
+        var keyBytes = new Uint8Array(8);
+        window.crypto.getRandomValues(keyBytes);
+        var msgKey = "cd".concat(Array.from(keyBytes, function (byte) { return byte.toString(16).padStart(2, "0"); }).join(""));
+        var observer = {
+            notify: function (eventType, _eventEnum, _eventName, report) {
+                // Current RIC firmware labels raw-command replies "raw"; older add-on drivers use "addOnRx".
+                if (eventType !== "msg" || ((report === null || report === void 0 ? void 0 : report.msgType) !== "raw" && (report === null || report === void 0 ? void 0 : report.msgType) !== "addOnRx") || report.elemName !== sensor.addon.name ||
+                    String(report.msgKey) !== msgKey || (report.IDNo !== undefined && Number(report.IDNo) !== sensor.addon.id))
+                    return;
+                if (typeof report.hexRd !== "string" || !new RegExp("^[a-f0-9]{".concat(bytes * 2, "}$"), "i").test(report.hexRd)) {
+                    unavailable("invalidResponse");
+                }
+                else {
+                    ok(report.hexRd.toLowerCase());
+                }
+            },
+        };
+        raft.subscribe(observer, ["msg"]);
+        // 0x10 selects an EEPROM read address; an empty write requests an atomic sample. No settings are written.
+        try {
+            raft.sendRestMessage("elem/".concat(encodeURIComponent(sensor.addon.name), "/json?cmd=raw&hexWr=").concat(hexWr, "&numToRd=").concat(bytes, "&msgKey=").concat(msgKey))
+                .then(function (result) {
+                if (!result || result.rslt !== "ok")
+                    unavailable("commandFailed");
+            }, function () { return unavailable("commandFailed"); });
+        }
+        catch (_a) {
+            unavailable("commandFailed");
+        }
+        return function () { return raft.unsubscribe(observer); };
+    });
+};
+export var readColourSensorRegister = function (sensor, address, signal, checkActive) {
+    return readHex(sensor, "10".concat(address), { "4014": 2, "4018": 4, "4020": 8 }[address], signal, checkActive);
+};
+var mapRead = function (result, convert) {
+    return result.status === "ok" ? __assign(__assign({}, result), { value: convert(result.value) }) : result;
+};
+var byteAt = function (hex, byte) { return parseInt(hex.slice(byte * 2, byte * 2 + 2), 16); };
+var wordAt = function (hex, byte) { return parseInt(hex.slice(byte * 2, byte * 2 + 4), 16); };
+var channels = function (hexRd, word) {
+    var valueAt = word ? wordAt : byteAt;
+    var step = word ? 2 : 1;
+    return { hexRd: hexRd, clear: valueAt(hexRd, 0), red: valueAt(hexRd, step), green: valueAt(hexRd, step * 2), blue: valueAt(hexRd, step * 3) };
+};
+export var readColourSensorHardware = function (sensor, signal, checkActive) {
+    return read(signal, checkActive, function (ok, unavailable) {
+        if (!sensor.raft.sendRestMessage) {
+            unavailable("unsupported");
+            return;
+        }
+        var stopped = false;
+        var request = function () { return __awaiter(void 0, void 0, void 0, function () {
+            var response, encoded, elements, element, stringOrNull;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, sensor.raft.sendRestMessage("hwstatus/strstat?filterByType=RSAddOn")];
+                    case 1:
+                        response = _a.sent();
+                        if (stopped)
+                            return [2 /*return*/];
+                        checkActive();
+                        if (!((response === null || response === void 0 ? void 0 : response.rslt) !== "ok" || !Array.isArray(response.hw) || response.hw.some(function (item) { return typeof item === "string"; }))) return [3 /*break*/, 3];
+                        return [4 /*yield*/, sensor.raft.sendRestMessage("hwstatus?filterByType=RSAddOn")];
+                    case 2:
+                        response = (_a.sent());
+                        if (stopped)
+                            return [2 /*return*/];
+                        checkActive();
+                        _a.label = 3;
+                    case 3:
+                        if ((response === null || response === void 0 ? void 0 : response.rslt) !== "ok" || !Array.isArray(response.hw)) {
+                            unavailable("invalidResponse");
+                            return [2 /*return*/];
+                        }
+                        encoded = response.hw.some(function (item) { return typeof (item === null || item === void 0 ? void 0 : item.a) === "string"; });
+                        if (encoded && response.hw.some(function (item) { return typeof (item === null || item === void 0 ? void 0 : item.a) !== "string" || item.a.split("|").length < 8; })) {
+                            unavailable("invalidResponse");
+                            return [2 /*return*/];
+                        }
+                        elements = encoded ? RICHWElemList_Str.expand(response).hw : response.hw;
+                        element = elements.find(function (item) { return (item === null || item === void 0 ? void 0 : item.name) === sensor.addon.name && item.whoAmI === sensor.addon.whoAmI; });
+                        if (!element) {
+                            unavailable("invalidResponse");
+                            return [2 /*return*/];
+                        }
+                        stringOrNull = function (value) { return typeof value === "string" && value.length ? value : null; };
+                        ok({ firmwareVersion: stringOrNull(element.versionStr), typeCode: stringOrNull(element.whoAmITypeCode), serialNumber: stringOrNull(element.SN),
+                            commsOk: typeof element.commsOk === "number" ? element.commsOk : null });
+                        return [2 /*return*/];
+                }
+            });
+        }); };
+        request().catch(function () { return unavailable("commandFailed"); });
+        return function () { stopped = true; };
+    });
+};
+// Marty can keep BLE alive after its idle timer turns off the 5V sensor/servo supply.
+// This is the same temporary wake command used by colour calibration; it does not write settings or move joints.
+export var wakeColourSensor = function (sensor, signal, checkActive) {
+    return read(signal, checkActive, function (ok, unavailable) {
+        if (!sensor.raft.sendRestMessage) {
+            unavailable("unsupported");
+            return;
+        }
+        var requestedAtMs = Date.now();
+        var acknowledged = false;
+        var inspect = function () {
+            var _a;
+            if (!acknowledged)
+                return;
+            var state = sensor.raft.raftStateInfo;
+            var addon = state === null || state === void 0 ? void 0 : state.addOnInfo.addons.find(function (item) { return item.id === sensor.addon.id && item.name === sensor.addon.name; });
+            // Wait for a new online frame, rather than accepting cached telemetry from before the wake command.
+            if (addon && state.addOnInfoValidMs >= requestedAtMs && ((_a = state === null || state === void 0 ? void 0 : state.power) === null || _a === void 0 ? void 0 : _a.powerStatus.power5VIsOn) !== false &&
+                (addon.status === undefined || Boolean(addon.status & 0x80)))
+                ok(true);
+        };
+        var timer = setInterval(inspect, 100);
+        try {
+            sensor.raft.sendRestMessage("pwrctrl/5von").then(function (response) {
+                if ((response === null || response === void 0 ? void 0 : response.rslt) !== "ok") {
+                    unavailable("commandFailed");
+                    return;
+                }
+                acknowledged = true;
+                inspect();
+            }, function () { return unavailable("commandFailed"); });
+        }
+        catch (_a) {
+            unavailable("commandFailed");
+        }
+        return function () { return clearInterval(timer); };
+    }, 5000);
+};
+export var readColourSensorReadiness = function (sensor, signal, checkActive) {
+    return read(signal, checkActive, function (ok, unavailable) {
+        if (!sensor.raft.sendRestMessage) {
+            unavailable("unsupported");
+            return;
+        }
+        sensor.raft.sendRestMessage("diagnostics/colourSensorReady").then(function (response) {
+            var result = response;
+            if ((result === null || result === void 0 ? void 0 : result.rslt) === "ok" && result.colourDiagnosticsProtocol === 1 && typeof result.ready === "boolean")
+                ok(result.ready);
+            else
+                unavailable("unsupported");
+        }, function () { return unavailable("unsupported"); });
+    });
+};
+export var collectColourSensorSetup = function (sensor, signal, checkActive) { return __awaiter(void 0, void 0, void 0, function () {
+    var readiness, missing, power, hardware, missing, groundThreshold, _a, offsets, _b, whiteCalibration, _c;
+    return __generator(this, function (_d) {
+        switch (_d.label) {
+            case 0: return [4 /*yield*/, readColourSensorReadiness(sensor, signal, checkActive)];
+            case 1:
+                readiness = _d.sent();
+                if (readiness.status !== "ok" || !readiness.value) {
+                    missing = { requestedAtMs: readiness.requestedAtMs, receivedAtMs: readiness.receivedAtMs,
+                        status: "unavailable", reason: readiness.status === "unavailable" ? readiness.reason : "initialising" };
+                    return [2 /*return*/, { readiness: readiness, hardware: missing, groundThreshold: missing, offsets: missing, whiteCalibration: missing }];
+                }
+                return [4 /*yield*/, wakeColourSensor(sensor, signal, checkActive)];
+            case 2:
+                power = _d.sent();
+                if (power.status !== "ok") {
+                    return [2 /*return*/, { readiness: readiness, power: power, hardware: power, groundThreshold: power, offsets: power, whiteCalibration: power }];
+                }
+                return [4 /*yield*/, readColourSensorHardware(sensor, signal, checkActive)];
+            case 3:
+                hardware = _d.sent();
+                if (hardware.status === "ok" && hardware.value.commsOk === 0) {
+                    missing = { requestedAtMs: hardware.requestedAtMs, receivedAtMs: hardware.receivedAtMs,
+                        status: "unavailable", reason: "offline" };
+                    return [2 /*return*/, { readiness: readiness, power: power, hardware: hardware, groundThreshold: missing, offsets: missing, whiteCalibration: missing }];
+                }
+                _a = mapRead;
+                return [4 /*yield*/, readHex(sensor, "104014", 2, signal, checkActive)];
+            case 4:
+                groundThreshold = _a.apply(void 0, [_d.sent(), function (hexRd) { return ({ storedValue: wordAt(hexRd, 0), hexRd: hexRd }); }]);
+                _b = mapRead;
+                return [4 /*yield*/, readHex(sensor, "104018", 4, signal, checkActive)];
+            case 5:
+                offsets = _b.apply(void 0, [_d.sent(), function (hexRd) { return channels(hexRd, false); }]);
+                _c = mapRead;
+                return [4 /*yield*/, readHex(sensor, "104020", 8, signal, checkActive)];
+            case 6:
+                whiteCalibration = _c.apply(void 0, [_d.sent(), function (hexRd) { return channels(hexRd, true); }]);
+                return [2 /*return*/, { readiness: readiness, power: power, hardware: hardware, groundThreshold: groundThreshold, offsets: offsets, whiteCalibration: whiteCalibration }];
+        }
+    });
+}); };
+export var readRawColourSensor = function (sensor, signal, checkActive) { return __awaiter(void 0, void 0, void 0, function () {
+    var _a;
+    return __generator(this, function (_b) {
+        switch (_b.label) {
+            case 0:
+                _a = mapRead;
+                return [4 /*yield*/, readHex(sensor, "", 13, signal, checkActive)];
+            case 1: return [2 /*return*/, _a.apply(void 0, [_b.sent(), function (hexRd) { return (__assign(__assign({}, channels(hexRd.slice(2, 10), false)), { hexRd: hexRd, sensorStatusByte: byteAt(hexRd, 0), detectionFlags: byteAt(hexRd, 6), isOnAir: Boolean(byteAt(hexRd, 6) & 2), touch: Boolean(byteAt(hexRd, 6) & 1), irVal: wordAt(hexRd, 7), irReading: wordAt(hexRd, 9), irAmbient: wordAt(hexRd, 11) })); }])];
+        }
+    });
+}); };

package/dist-types/src/utils/marty-colour-policy.json

@@ -1,10 +1,12 @@
 {
-    "source": "Marty web app colour boundaries v3",
+    "source": "Marty web app RGB signal policy v4",
+    "clearBoundsUsedForClassification": false,
+    "signal": { "minimumChroma": 8, "minimumSaturation": 0.15, "airNoiseMarginRaw": 3 },
     "boundaries": [
         { "hue": [0, 15], "chroma": [50, 200], "clear": [40, 150], "name": "red" },
         { "hue": [20, 65], "chroma": [40, 300], "clear": [100, 255], "name": "yellow" },
-        { "hue": [85, 160], "chroma": [5, 100], "clear": [25, 150], "name": "green" },
-        { "hue": [180, 240], "chroma": [40, 230], "clear": [55, 255], "name": "blue" },
+        { "hue": [75, 160], "chroma": [5, 100], "clear": [25, 150], "name": "green" },
+        { "hue": [180, 240], "chroma": [40, 260], "clear": [55, 255], "name": "blue" },
         { "hue": [240, 320], "chroma": [5, 100], "clear": [10, 150], "name": "purple" },
         { "hue": [345, 361], "chroma": [50, 200], "clear": [40, 150], "name": "red" }
     ]

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@robotical/webapp-types",
-  "version": "3.25.5",
+  "version": "3.25.7",
   "description": "Type definitions for the Application Manager",
   "main": "dist/application-manager.d.ts",
   "types": "dist/application-manager.d.ts",