@robotical/webapp-types 3.25.4 → 3.25.6

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

@@ -0,0 +1,364 @@
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+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 };
+    }
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+import packageInfo from "../../package.json";
+import colourPolicy from "./marty-colour-policy.json";
+import { classifyColour, colourChannelsFromValues } from "./colour-classifier";
+import { getActiveColourSensorProfile } from "./colour-sensor-profile";
+import { lockColourSensorOperation, waitForColourProfileRead } from "./colour-sensor-operation";
+import { getPendingColourCalibration } from "./colour-calibration-reconnect";
+import { collectColourSensorSetup, readRawColourSensor } from "./colour-sensor-registers";
+export var CARD_COLOURS = ["green", "purple", "yellow", "blue", "red"];
+export var CAPTURE_TARGETS = __spreadArray(__spreadArray([], CARD_COLOURS, true), ["air"], false);
+export var COLOUR_DATABASE_URL = "https://platforms-error-logging-default-rtdb.europe-west1.firebasedatabase.app";
+var STORAGE_KEY = "marty-colour-diagnostics-v1";
+var CAPTURE_INTERVAL_MS = 200;
+var CAPTURE_DURATION_MS = 2000;
+var MAX_READING_AGE_MS = 1500;
+// The asset preparation script applies this same policy to the bundled Blocks reporter.
+export var BLOCKS_COLOUR_BOUNDARIES = colourPolicy.boundaries;
+var ColourDiagnosticError = /** @class */ (function (_super) {
+    __extends(ColourDiagnosticError, _super);
+    function ColourDiagnosticError(code) {
+        var _this = _super.call(this, code) || this;
+        _this.code = code;
+        return _this;
+    }
+    return ColourDiagnosticError;
+}(Error));
+export { ColourDiagnosticError };
+var createId = function () {
+    var bytes = new Uint8Array(16);
+    window.crypto.getRandomValues(bytes);
+    return Array.from(bytes, function (value) { return value.toString(16).padStart(2, "0"); }).join("");
+};
+export var newColourSession = function () { return ({
+    schemaVersion: 1, sessionId: createId(), startedAtMs: Date.now(), captures: [],
+}); };
+export var getColourSensors = function (raftId) {
+    var _a, _b;
+    var raft = window.applicationManager.connectedRafts[raftId];
+    if (!raft || raft.type !== "Marty" || !raft.isVerified)
+        return [];
+    return (((_b = (_a = raft.raftStateInfo) === null || _a === void 0 ? void 0 : _a.addOnInfo) === null || _b === void 0 ? void 0 : _b.addons) || [])
+        .filter(function (addon) { return addon.whoAmI === "coloursensor"; })
+        .map(function (addon) { return ({ key: JSON.stringify([addon.id, addon.name]), raftId: raftId, raft: raft, addon: addon }); });
+};
+export var assertColourSensorActive = function (sensor, signal) {
+    if (signal.aborted)
+        throw new ColourDiagnosticError("cancelled");
+    if (document.hidden)
+        throw new ColourDiagnosticError("backgrounded");
+    var current = getColourSensors(sensor.raftId).find(function (candidate) { return candidate.key === sensor.key; });
+    if (!current || current.raft !== sensor.raft)
+        throw new ColourDiagnosticError("sensorDisconnected");
+};
+export var interpretColour = function (vals, profile) {
+    var _a = colourChannelsFromValues(vals), red = _a.red, green = _a.green, blue = _a.blue, clear = _a.clear, air = _a.air;
+    if (![red, green, blue, clear].every(function (value) { return typeof value === "number" && Number.isFinite(value); }) ||
+        ![true, false, 0, 1].includes(air))
+        throw new ColourDiagnosticError("invalidReading");
+    var r = red, g = green, b = blue, c = clear;
+    return __assign(__assign({}, classifyColour({ red: r, green: g, blue: b, clear: c, air: air }, profile)), { red: r, green: g, blue: b, clear: c, isOnAir: Boolean(air), 
+        // Calibration can produce values outside 0–255. Clamp only the display colour.
+        hex: "#".concat([r, g, b].map(function (value) { return Math.max(0, Math.min(255, Math.round(value))).toString(16).padStart(2, "0"); }).join("")) });
+};
+export var readColourSensor = function (sensor) {
+    var _a, _b, _c;
+    var current = getColourSensors(sensor.raftId).find(function (candidate) { return candidate.key === sensor.key; });
+    if (!current || current.raft !== sensor.raft)
+        throw new ColourDiagnosticError("sensorDisconnected");
+    var observedAtMs = Date.now();
+    var receivedAtMs = current.raft.raftStateInfo.addOnInfoValidMs;
+    var ageMs = observedAtMs - receivedAtMs;
+    if (!Number.isFinite(receivedAtMs) || receivedAtMs <= 0 || ageMs < 0 || ageMs > MAX_READING_AGE_MS) {
+        throw new ColourDiagnosticError("staleReading");
+    }
+    var powerAt = current.raft.raftStateInfo.powerValidMs;
+    if (powerAt && observedAtMs - powerAt >= 0 && observedAtMs - powerAt < 3000 &&
+        ((_a = current.raft.raftStateInfo.power) === null || _a === void 0 ? void 0 : _a.powerStatus.power5VIsOn) === false)
+        throw new ColourDiagnosticError("sensorAsleep");
+    // The high bit of Marty add-on telemetry means communications are healthy. A new packet can contain cached offline values.
+    if (current.addon.status !== undefined && !(current.addon.status & 0x80))
+        throw new ColourDiagnosticError("sensorOffline");
+    return __assign(__assign({}, interpretColour(current.addon.vals, (_b = getActiveColourSensorProfile(sensor)) === null || _b === void 0 ? void 0 : _b.signal)), { observedAtMs: observedAtMs, receivedAtMs: receivedAtMs, ageMs: ageMs, publishedValues: __assign({}, current.addon.vals), sensorStatus: (_c = current.addon.status) !== null && _c !== void 0 ? _c : null, irFootSensors: (current.raft.raftStateInfo.addOnInfo.addons || [])
+            .filter(function (addon) { return addon.whoAmI === "IRFoot"; })
+            .map(function (addon) { return (__assign(__assign({}, addon), { vals: __assign({}, addon.vals) })); }) });
+};
+var delay = function (ms, signal) { return new Promise(function (resolve, reject) {
+    var abort = function () {
+        clearTimeout(timer);
+        signal.removeEventListener("abort", abort);
+        reject(new ColourDiagnosticError("cancelled"));
+    };
+    var timer = setTimeout(function () { signal.removeEventListener("abort", abort); resolve(); }, ms);
+    signal.addEventListener("abort", abort, { once: true });
+    if (signal.aborted)
+        abort();
+}); };
+var captureUnlocked = function (sensor, expectedColour, session, signal) { return __awaiter(void 0, void 0, void 0, function () {
+    var startedAtMs, checkActive, sensorSetup, sampleWindowStartedAtMs, samples, rawSamples, rawController, abortRaw, rawFailure, collectRaw, rawCapture, index, reading;
+    var _a, _b, _c, _d, _e, _f;
+    return __generator(this, function (_g) {
+        switch (_g.label) {
+            case 0:
+                startedAtMs = Date.now();
+                checkActive = function () {
+                    assertColourSensorActive(sensor, signal);
+                    if (getPendingColourCalibration(sensor))
+                        throw new ColourDiagnosticError("calibrationReconnectRequired");
+                };
+                checkActive();
+                return [4 /*yield*/, collectColourSensorSetup(sensor, signal, checkActive)];
+            case 1:
+                sensorSetup = _g.sent();
+                checkActive();
+                if (sensorSetup.readiness.status === "ok" && !sensorSetup.readiness.value)
+                    throw new ColourDiagnosticError("sensorInitialising");
+                if (((_a = sensorSetup.power) === null || _a === void 0 ? void 0 : _a.status) === "unavailable")
+                    throw new ColourDiagnosticError("sensorPowerFailed");
+                if (sensorSetup.hardware.status === "ok" && sensorSetup.hardware.value.commsOk === 0)
+                    throw new ColourDiagnosticError("sensorOffline");
+                readColourSensor(sensor);
+                sampleWindowStartedAtMs = Date.now();
+                samples = [];
+                rawSamples = [];
+                rawController = new AbortController();
+                abortRaw = function () { return rawController.abort(); };
+                signal.addEventListener("abort", abortRaw, { once: true });
+                collectRaw = function () { return __awaiter(void 0, void 0, void 0, function () {
+                    var result, failure_1;
+                    return __generator(this, function (_a) {
+                        switch (_a.label) {
+                            case 0:
+                                _a.trys.push([0, 5, , 6]);
+                                if (sensorSetup.readiness.status === "unavailable") {
+                                    rawSamples.push(sensorSetup.readiness);
+                                    return [2 /*return*/];
+                                }
+                                _a.label = 1;
+                            case 1:
+                                if (!(!rawController.signal.aborted && Date.now() - sampleWindowStartedAtMs < CAPTURE_DURATION_MS)) return [3 /*break*/, 4];
+                                return [4 /*yield*/, readRawColourSensor(sensor, rawController.signal, function () { return assertColourSensorActive(sensor, rawController.signal); })];
+                            case 2:
+                                result = _a.sent();
+                                rawSamples.push(result);
+                                if (result.status === "unavailable")
+                                    return [3 /*break*/, 4];
+                                return [4 /*yield*/, delay(CAPTURE_INTERVAL_MS, rawController.signal)];
+                            case 3:
+                                _a.sent();
+                                return [3 /*break*/, 1];
+                            case 4: return [3 /*break*/, 6];
+                            case 5:
+                                failure_1 = _a.sent();
+                                if (!(failure_1 instanceof ColourDiagnosticError && failure_1.code === "cancelled" && !signal.aborted))
+                                    rawFailure = failure_1;
+                                return [3 /*break*/, 6];
+                            case 6: return [2 /*return*/];
+                        }
+                    });
+                }); };
+                rawCapture = collectRaw();
+                _g.label = 2;
+            case 2:
+                _g.trys.push([2, , 7, 9]);
+                index = 0;
+                _g.label = 3;
+            case 3:
+                if (!(index <= CAPTURE_DURATION_MS / CAPTURE_INTERVAL_MS)) return [3 /*break*/, 6];
+                checkActive();
+                if (rawFailure)
+                    throw rawFailure;
+                reading = readColourSensor(sensor);
+                if (!samples.length || samples[samples.length - 1].receivedAtMs !== reading.receivedAtMs)
+                    samples.push(reading);
+                if (!(index < CAPTURE_DURATION_MS / CAPTURE_INTERVAL_MS)) return [3 /*break*/, 5];
+                return [4 /*yield*/, delay(CAPTURE_INTERVAL_MS, signal)];
+            case 4:
+                _g.sent();
+                _g.label = 5;
+            case 5:
+                index++;
+                return [3 /*break*/, 3];
+            case 6: return [3 /*break*/, 9];
+            case 7:
+                rawController.abort();
+                signal.removeEventListener("abort", abortRaw);
+                return [4 /*yield*/, rawCapture];
+            case 8:
+                _g.sent();
+                return [7 /*endfinally*/];
+            case 9:
+                if (rawFailure)
+                    throw rawFailure;
+                if (samples.length < 2)
+                    throw new ColourDiagnosticError("staleReading");
+                return [2 /*return*/, __assign(__assign({ schemaVersion: 2, sessionId: session.sessionId, sessionStartedAtMs: session.startedAtMs, captureId: createId(), expectedColour: expectedColour, startedAtMs: startedAtMs, finishedAtMs: Date.now(), appVersion: packageInfo.version, classifier: { source: colourPolicy.source, airFlagTakesPrecedence: false, boundaries: BLOCKS_COLOUR_BOUNDARIES,
+                            signal: colourPolicy.signal, profile: getActiveColourSensorProfile(sensor), clearBoundsUsedForClassification: false }, device: {
+                            id: sensor.raftId, type: sensor.raft.type, name: ((_c = (_b = sensor.raft).getFriendlyName) === null || _c === void 0 ? void 0 : _c.call(_b)) || sensor.raftId,
+                            firmwareVersion: ((_d = sensor.raft.systemInfo) === null || _d === void 0 ? void 0 : _d.SystemVersion) || null, connectionMethod: sensor.raft.connectionMethod || null,
+                        }, sensor: { id: sensor.addon.id, name: sensor.addon.name, whoAmI: sensor.addon.whoAmI } }, (((_f = (_e = sensor.raft.raftStateInfo) === null || _e === void 0 ? void 0 : _e.power) === null || _f === void 0 ? void 0 : _f.powerStatus) && { powerStatus: {
+                            receivedAtMs: sensor.raft.raftStateInfo.powerValidMs || 0, values: __assign({}, sensor.raft.raftStateInfo.power.powerStatus),
+                        } })), { sampleIntervalMs: CAPTURE_INTERVAL_MS, sampleCount: samples.length, samples: samples, sampleWindowStartedAtMs: sampleWindowStartedAtMs, sensorSetup: sensorSetup, rawSamples: rawSamples })];
+        }
+    });
+}); };
+export var captureColourSnapshot = function (sensor, expectedColour, session, signal) { return __awaiter(void 0, void 0, void 0, function () {
+    var release;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/, waitForColourProfileRead(sensor.raft, function () { return assertColourSensorActive(sensor, signal); })];
+            case 1:
+                _a.sent();
+                release = lockColourSensorOperation(sensor.raft);
+                if (!release)
+                    throw new ColourDiagnosticError("sensorBusy");
+                _a.label = 2;
+            case 2:
+                _a.trys.push([2, , 4, 5]);
+                return [4 /*yield*/, captureUnlocked(sensor, expectedColour, session, signal)];
+            case 3: return [2 /*return*/, _a.sent()];
+            case 4:
+                release();
+                return [7 /*endfinally*/];
+            case 5: return [2 /*return*/];
+        }
+    });
+}); };
+export var uploadColourSnapshot = function (snapshot, signal) { return __awaiter(void 0, void 0, void 0, function () {
+    var controller, abort, timer, response, error_1;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                controller = new AbortController();
+                abort = function () { return controller.abort(); };
+                signal.addEventListener("abort", abort, { once: true });
+                if (signal.aborted)
+                    abort();
+                timer = setTimeout(abort, 15000);
+                _a.label = 1;
+            case 1:
+                _a.trys.push([1, 3, 4, 5]);
+                return [4 /*yield*/, fetch("".concat(COLOUR_DATABASE_URL, "/colours/").concat(snapshot.sessionId, "/captures/").concat(snapshot.captureId, ".json"), {
+                        method: "PUT", headers: { "Content-Type": "application/json" },
+                        body: JSON.stringify(__assign(__assign({}, snapshot), { uploadedAt: { ".sv": "timestamp" } })), signal: controller.signal,
+                    })];
+            case 2:
+                response = _a.sent();
+                if (!response.ok)
+                    throw new ColourDiagnosticError(response.status === 401 || response.status === 403 ? "uploadDenied" : "uploadFailed");
+                return [3 /*break*/, 5];
+            case 3:
+                error_1 = _a.sent();
+                if (signal.aborted)
+                    throw new ColourDiagnosticError("cancelled");
+                throw error_1 instanceof ColourDiagnosticError ? error_1 : new ColourDiagnosticError("uploadFailed");
+            case 4:
+                clearTimeout(timer);
+                signal.removeEventListener("abort", abort);
+                return [7 /*endfinally*/];
+            case 5: return [2 /*return*/];
+        }
+    });
+}); };
+export var loadColourSession = function () {
+    try {
+        var saved_1 = JSON.parse(localStorage.getItem(STORAGE_KEY) || "null");
+        if ((saved_1 === null || saved_1 === void 0 ? void 0 : saved_1.schemaVersion) === 1 && /^[a-f0-9]{32}$/.test(saved_1.sessionId) && Number.isFinite(saved_1.startedAtMs) &&
+            Array.isArray(saved_1.captures) && saved_1.captures.every(function (entry) {
+            var _a;
+            return ((_a = entry.snapshot) === null || _a === void 0 ? void 0 : _a.sessionId) === saved_1.sessionId &&
+                /^[a-f0-9]{32}$/.test(entry.snapshot.captureId) && CAPTURE_TARGETS.includes(entry.snapshot.expectedColour) &&
+                Array.isArray(entry.snapshot.samples);
+        }))
+            return saved_1;
+    }
+    catch ( /* A browser without local storage can still capture and download in-memory data. */_a) { /* A browser without local storage can still capture and download in-memory data. */ }
+    return newColourSession();
+};
+export var persistColourSession = function (session) {
+    try {
+        localStorage.setItem(STORAGE_KEY, JSON.stringify(session));
+        return true;
+    }
+    catch (_a) {
+        return false;
+    }
+};
+export var downloadColourSession = function (session) {
+    var url = URL.createObjectURL(new Blob([JSON.stringify(session, null, 2)], { type: "application/json" }));
+    var anchor = document.createElement("a");
+    anchor.href = url;
+    anchor.download = "marty-colours-".concat(session.sessionId, ".json");
+    anchor.click();
+    setTimeout(function () { return URL.revokeObjectURL(url); }, 1000);
+};

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

@@ -0,0 +1,2 @@
+export declare const lockColourSensorOperation: (raft: object, background?: boolean) => (() => void) | null;
+export declare const waitForColourProfileRead: (raft: object, check: () => void) => Promise<void>;

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

@@ -0,0 +1,62 @@
+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 };
+    }
+};
+// Raw add-on commands have one response slot. Share ownership across all app workflows.
+var owners = new WeakMap();
+export var lockColourSensorOperation = function (raft, background) {
+    if (background === void 0) { background = false; }
+    if (owners.has(raft))
+        return null;
+    owners.set(raft, { background: background });
+    return function () { owners.delete(raft); };
+};
+export var waitForColourProfileRead = function (raft, check) { return __awaiter(void 0, void 0, void 0, function () {
+    var _a;
+    return __generator(this, function (_b) {
+        switch (_b.label) {
+            case 0:
+                if (!((_a = owners.get(raft)) === null || _a === void 0 ? void 0 : _a.background)) return [3 /*break*/, 2];
+                check();
+                return [4 /*yield*/, new Promise(function (resolve) { return setTimeout(resolve, 100); })];
+            case 1:
+                _b.sent();
+                return [3 /*break*/, 0];
+            case 2:
+                check();
+                return [2 /*return*/];
+        }
+    });
+}); };

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

@@ -0,0 +1,32 @@
+import type { ColourSensor } from "./colour-sensor-diagnostics";
+import { ColourSignalProfile } from "./colour-classifier";
+export type ColourSensorProfile = {
+    schemaVersion: 1;
+    serialNumber: string;
+    typeCode: string;
+    firmwareVersion: string;
+    offsetsHex: string;
+    whiteCalibrationHex: string;
+    capturedAtMs: number;
+    signal: ColourSignalProfile;
+    purpleIncluded: boolean;
+    groundDetection: "clearThreshold" | "rgbFallback" | "purpleSkipped";
+};
+export declare const validColourSensorProfile: (value: unknown) => value is ColourSensorProfile;
+export declare const cacheColourSensorProfile: (profile: ColourSensorProfile) => void;
+export declare const colourSensorProfilePath: (profile: ColourSensorProfile) => string;
+export declare const bindColourSensorProfile: (sensor: ColourSensor, profile: ColourSensorProfile) => void;
+export declare const getActiveColourSensorProfile: (sensor: Pick<ColourSensor, "raft" | "key">) => ColourSensorProfile | undefined;
+export declare const getAddonColourSensorProfile: (raft: object, addon: {
+    id: number;
+    name: string;
+}) => ColourSensorProfile | undefined;
+export declare const clearActiveColourSensorProfile: (sensor: Pick<ColourSensor, "raft" | "key">) => boolean | undefined;
+export declare const classifyColourAddon: (addon: {
+    id: number;
+    name: string;
+    vals: Record<string, number | boolean>;
+}) => import("./colour-classifier").ColourName;
+export declare const loadColourSensorProfile: (sensor: ColourSensor, signal: AbortSignal) => Promise<void>;
+/** Read-only browser/WebView hydration. Never wakes sleeping sensors or modifies their registers. */
+export declare const startColourSensorProfileSync: () => () => void;