@robotical/webapp-types 3.25.9 → 3.25.11

package/dist-types/package.json

@@ -1,6 +1,6 @@
 {
     "name": "marty-web-app",
-    "version": "3.25.9",
+    "version": "3.25.11",
     "private": true,
     "engines": {
         "node": ">=20"

package/dist-types/src/application/RAFTs/Marty/PublishedDataAnalyser.d.ts

@@ -1,11 +1,13 @@
 /// <reference types="node" />
 import EventEmitter from "events";
-import { ColourSignalProfile } from "../../../utils/colour-classifier";
+import { classifyColour, ColourSignalProfile } from "../../../utils/colour-classifier";
 import RAFT from "../RAFT";
 import type { RICStateInfo } from "@robotical/roboticaljs";
 import { type ColourSensorValues } from "./published-data-helpers";
 interface MartyState {
     colourSensed: "blue" | "green" | "red" | "yellow" | "purple" | "unclear" | "air";
+    /** Rule strength of the confirmed/held colour (0–100); null without a reading. */
+    colourConfidence: number | null;
     lightSense: "none" | "high" | "mid" | "low";
     objectSense: "none" | "near";
     noiseSense: "none" | "detected";
@@ -14,6 +16,11 @@ declare class PublishedDataAnalyser extends EventEmitter {
     private marty;
     martyState: MartyState;
     private pubSub;
+    lastColourReading: ReturnType<typeof classifyColour> | null;
+    private colourFilter;
+    private colourContext;
+    private colourExpiry;
+    private connectionObserver;
     lightSenseDetection: LightSenseDetection;
     colourSensedDetection: ColourSensedDetection;
     objectSenseDetection: ObjectSenseDetection;
@@ -34,13 +41,16 @@ declare class PublishedDataAnalyser extends EventEmitter {
     subscribeToPublishedData(): void;
     unsubscribeFromPublishedData(): void;
     analyse(data: RICStateInfo): void;
-    setColourSensed(colour: MartyState["colourSensed"]): void;
+    setColourSensed(colour: MartyState["colourSensed"], confidence?: number | null): void;
+    private resetColourDetection;
+    recordColourReading(reading: ReturnType<typeof classifyColour>, receivedAtMs: number): void;
+    private scheduleColourExpiry;
     setLightSense(lightSense: MartyState["lightSense"]): void;
     setObjectSense(objectSense: MartyState["objectSense"]): void;
     setNoiseSense(noiseSense: MartyState["noiseSense"]): void;
 }
 declare class ColourSensedDetection {
-    detectColourSensed({ r, g, b, clear, air }: ColourSensorValues, analyser: PublishedDataAnalyser, profile?: ColourSignalProfile): void;
+    detectColourSensed({ r, g, b, clear, air }: ColourSensorValues, analyser: PublishedDataAnalyser, profile?: ColourSignalProfile, receivedAtMs?: number): void;
 }
 declare class LightSenseDetection {
     private lowLightThreshold;

package/dist-types/src/application/RAFTs/Marty/PublishedDataAnalyser.js

@@ -14,15 +14,29 @@ var __extends = (this && this.__extends) || (function () {
     };
 })();
 import EventEmitter from "events";
-import { classifyColour } from "../../../utils/colour-classifier";
+import { RaftConnEvent } from "@robdobsn/raftjs";
+import { classifyColour, colourChannelsFromValues } from "../../../utils/colour-classifier";
+import { ColourEventFilter } from "../../../utils/colour-event-filter";
 import { getAddonColourSensorProfile } from "../../../utils/colour-sensor-profile";
 import { createRaftPubSubscriptionHelper } from "../raft-subscription-helpers";
-import { getColourSensor, getLightSensor, getObjectSensor, getNoiseSensor, getRGBFromColourSensorVals, getLightSenseValues, getObjectIsTouchingFromVals, getNoiseSenseValue, } from "./published-data-helpers";
+import { getColourSensor, getLightSensor, getObjectSensor, getNoiseSensor, getLightSenseValues, getObjectIsTouchingFromVals, getNoiseSenseValue, } from "./published-data-helpers";
 var PublishedDataAnalyser = /** @class */ (function (_super) {
     __extends(PublishedDataAnalyser, _super);
     function PublishedDataAnalyser(marty) {
         var _this = _super.call(this) || this;
         _this.marty = marty;
+        _this.lastColourReading = null;
+        _this.colourFilter = new ColourEventFilter();
+        _this.colourContext = "";
+        _this.colourExpiry = null;
+        _this.connectionObserver = {
+            notify: function (eventType, eventEnum) {
+                if (eventType === "conn" && [RaftConnEvent.CONN_DISCONNECTED, RaftConnEvent.CONN_REJECTED,
+                    RaftConnEvent.CONN_VERIFYING_CORRECT, RaftConnEvent.CONN_VERIFIED_CORRECT].includes(eventEnum)) {
+                    _this.resetColourDetection();
+                }
+            },
+        };
         _this.lightSenseDetection = new LightSenseDetection();
         _this.colourSensedDetection = new ColourSensedDetection();
         _this.objectSenseDetection = new ObjectSenseDetection();
@@ -61,6 +75,7 @@ var PublishedDataAnalyser = /** @class */ (function (_super) {
         _this.marty = marty;
         _this.martyState = {
             colourSensed: "unclear",
+            colourConfidence: null,
             lightSense: "none",
             objectSense: "none",
             noiseSense: "none",
@@ -71,6 +86,9 @@ var PublishedDataAnalyser = /** @class */ (function (_super) {
     }
     PublishedDataAnalyser.prototype.subscribeToPublishedData = function () {
         var _this = this;
+        var _a;
+        (_a = this.pubSub) === null || _a === void 0 ? void 0 : _a.unsubscribe();
+        this.marty.subscribe(this.connectionObserver, ["conn"]);
         this.pubSub = createRaftPubSubscriptionHelper(this.marty, this.marty.id);
         this.pubSub.subscribe(function (data) {
             _this.analyse(data.stateInfo);
@@ -79,6 +97,9 @@ var PublishedDataAnalyser = /** @class */ (function (_super) {
     PublishedDataAnalyser.prototype.unsubscribeFromPublishedData = function () {
         var _a;
         (_a = this.pubSub) === null || _a === void 0 ? void 0 : _a.unsubscribe();
+        this.pubSub = null;
+        this.marty.unsubscribe(this.connectionObserver);
+        this.resetColourDetection();
     };
     PublishedDataAnalyser.prototype.analyse = function (data) {
         var _a;
@@ -88,8 +109,23 @@ var PublishedDataAnalyser = /** @class */ (function (_super) {
         var lightSensor = getLightSensor(data);
         var objectSensor = getObjectSensor(data);
         var noiseSensor = getNoiseSensor(data);
-        colourSensor &&
-            this.colourSensedDetection.detectColourSensed(getRGBFromColourSensorVals(colourSensor), this, (_a = getAddonColourSensorProfile(this.marty, colourSensor)) === null || _a === void 0 ? void 0 : _a.signal);
+        var powerAge = Date.now() - data.powerValidMs;
+        if (!colourSensor || this.marty.isVerified === false || document.hidden ||
+            (colourSensor.status !== undefined && !(colourSensor.status & 0x80)) ||
+            (data.powerValidMs > 0 && powerAge >= 0 && powerAge < 3000 && ((_a = data.power) === null || _a === void 0 ? void 0 : _a.powerStatus.power5VIsOn) === false)) {
+            this.resetColourDetection();
+        }
+        else {
+            var profile = getAddonColourSensorProfile(this.marty, colourSensor);
+            var context = JSON.stringify([colourSensor.id, colourSensor.name, profile === null || profile === void 0 ? void 0 : profile.serialNumber, profile === null || profile === void 0 ? void 0 : profile.offsetsHex, profile === null || profile === void 0 ? void 0 : profile.whiteCalibrationHex, profile === null || profile === void 0 ? void 0 : profile.capturedAtMs]);
+            if (context !== this.colourContext) {
+                this.resetColourDetection();
+                this.colourContext = context;
+            }
+            var values = colourChannelsFromValues(colourSensor.vals);
+            this.colourSensedDetection.detectColourSensed({ r: values.red, g: values.green, b: values.blue,
+                clear: values.clear, air: values.air }, this, profile === null || profile === void 0 ? void 0 : profile.signal, data.addOnInfoValidMs);
+        }
         (objectSensor || colourSensor) &&
             this.objectSenseDetection.detectObjectSense(getObjectIsTouchingFromVals(objectSensor, colourSensor), this);
         lightSensor &&
@@ -101,9 +137,44 @@ var PublishedDataAnalyser = /** @class */ (function (_super) {
         this.connectedSensors.objectSensor = !!objectSensor || !!colourSensor;
         this.connectedSensors.noiseSensor = !!noiseSensor;
     };
-    PublishedDataAnalyser.prototype.setColourSensed = function (colour) {
+    PublishedDataAnalyser.prototype.setColourSensed = function (colour, confidence) {
+        if (confidence === void 0) { confidence = null; }
+        var changed = colour !== this.martyState.colourSensed;
         this.martyState.colourSensed = colour;
-        this.emit(this.eventsMap.colourSensed[colour]);
+        this.martyState.colourConfidence = confidence;
+        if (changed)
+            this.emit(this.eventsMap.colourSensed[colour]);
+    };
+    PublishedDataAnalyser.prototype.resetColourDetection = function () {
+        if (this.colourExpiry !== null)
+            clearTimeout(this.colourExpiry);
+        this.colourExpiry = null;
+        this.colourContext = "";
+        this.colourFilter.reset();
+        this.lastColourReading = null;
+        this.setColourSensed("unclear", null);
+    };
+    PublishedDataAnalyser.prototype.recordColourReading = function (reading, receivedAtMs) {
+        this.lastColourReading = reading;
+        var value = this.colourFilter.update(reading, receivedAtMs, Date.now());
+        this.setColourSensed(value.colour, value.confidence);
+        this.scheduleColourExpiry();
+    };
+    PublishedDataAnalyser.prototype.scheduleColourExpiry = function () {
+        var _this = this;
+        if (this.colourExpiry !== null)
+            clearTimeout(this.colourExpiry);
+        var expiresAt = this.colourFilter.nextExpiryAtMs;
+        this.colourExpiry = expiresAt === null ? null : setTimeout(function () {
+            _this.colourExpiry = null;
+            if (_this.marty.isVerified === false || document.hidden) {
+                _this.resetColourDetection();
+                return;
+            }
+            var value = _this.colourFilter.current(Date.now());
+            _this.setColourSensed(value.colour, value.confidence);
+            _this.scheduleColourExpiry();
+        }, Math.max(0, expiresAt - Date.now()));
     };
     PublishedDataAnalyser.prototype.setLightSense = function (lightSense) {
         this.martyState.lightSense = lightSense;
@@ -122,9 +193,11 @@ var PublishedDataAnalyser = /** @class */ (function (_super) {
 var ColourSensedDetection = /** @class */ (function () {
     function ColourSensedDetection() {
     }
-    ColourSensedDetection.prototype.detectColourSensed = function (_a, analyser, profile) {
+    ColourSensedDetection.prototype.detectColourSensed = function (_a, analyser, profile, receivedAtMs) {
         var r = _a.r, g = _a.g, b = _a.b, clear = _a.clear, air = _a.air;
-        return analyser.setColourSensed(classifyColour({ red: r, green: g, blue: b, clear: clear, air: air }, profile).classifiedColour);
+        if (receivedAtMs === void 0) { receivedAtMs = Date.now(); }
+        var reading = classifyColour({ red: r, green: g, blue: b, clear: clear, air: air }, profile);
+        return analyser.recordColourReading(reading, receivedAtMs);
     };
     return ColourSensedDetection;
 }());

package/dist-types/src/screens/configuration/marty/Diagnostics/ColourSensorDiagnostics/messages.d.ts

@@ -16,6 +16,10 @@ declare const colourDiagnosticsEnglish: {
     prompt: string;
     airPrompt: string;
     result: string;
+    confidence: string;
+    confidenceUnavailable: string;
+    confidenceAbout: string;
+    confidenceHelp: string;
     withoutAir: string;
     firmwareAir: string;
     waiting: string;

package/dist-types/src/screens/configuration/marty/Diagnostics/ColourSensorDiagnostics/messages.js

@@ -11,6 +11,10 @@ var colourDiagnosticsEnglish = {
     prompt: "Place the selected sensor on the {{colour}} card.",
     airPrompt: "Lift Marty so both feet are at least 10 cm above any card or surface, with the sensors facing down and uncovered. Keep the lighting the same and hold still.",
     result: "Blocks interpretation: {{result}}",
+    confidence: "Confidence {{score}}/100",
+    confidenceUnavailable: "Confidence unavailable",
+    confidenceAbout: "About confidence",
+    confidenceHelp: "Rule strength, not probability. Higher scores mean more room before a colour or air cutoff. Air needs a saved calibration to score.",
     withoutAir: "Firmware reports air; the RGB signal matches {{result}}.",
     firmwareAir: "Firmware Air",
     waiting: "Select a sensor and wait for fresh readings.",

package/dist-types/src/utils/colour-classifier.d.ts

@@ -9,6 +9,13 @@ export type ColourSignalProfile = {
     margin: RGB;
 };
 export type ColourName = "red" | "yellow" | "green" | "blue" | "purple" | "air" | "unclear";
+export type ColourConfidenceFactors = {
+    hue?: number;
+    chroma?: number;
+    saturation?: number;
+    air?: number;
+};
+export declare const COLOUR_CONFIDENCE_METHOD: string;
 /** Published channels are white-normalised by the SDK; do not clamp them for classification. */
 export declare const classifyColour: (values: RGB & {
     clear: number;
@@ -18,12 +25,15 @@ export declare const classifyColour: (values: RGB & {
     colourWithoutAirOverride: ColourName;
     hue: number | null;
     chroma: number;
+    confidence: number | null;
+    confidenceMethod: string;
+    confidenceFactors: ColourConfidenceFactors;
     saturation: number;
     signalAboveAir: boolean;
     signalSource: string;
     classificationReason: string;
 };
-export declare const colourChannelsFromValues: (vals: Record<string, number | boolean>) => {
+export declare const colourChannelsFromValues: (vals: Record<string, unknown>) => {
     red: number;
     green: number;
     blue: number;

package/dist-types/src/utils/colour-classifier.js

@@ -1,4 +1,40 @@
+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 policy from "./marty-colour-policy.json";
+export var COLOUR_CONFIDENCE_METHOD = policy.confidence.method;
+var channels = ["red", "green", "blue"];
+var marginScore = function (fraction) { return Number.isFinite(fraction) ? Math.round(100 * Math.max(0, Math.min(1, fraction))) : 0; };
+var colourConfidenceFactors = function (values, hue, chroma, saturation, match, profile) {
+    var _a = match.hue, lowerHue = _a[0], upperHue = _a[1];
+    // Red's two table entries are one continuous interval across 360°/0°.
+    // That seam is not a decision boundary, so pure red must not get a zero score.
+    var sameBand = policy.boundaries.filter(function (band) { return band.name === match.name &&
+        band.chroma[0] === match.chroma[0] && band.chroma[1] === match.chroma[1]; });
+    var start = sameBand.find(function (band) { return band.hue[0] === 0; });
+    var end = sameBand.find(function (band) { return band.hue[1] >= 360; });
+    if (start && end) {
+        lowerHue = end.hue[0] - 360;
+        upperHue = start.hue[1];
+        if (hue > 180)
+            hue -= 360;
+    }
+    // Two channels determine chroma. Use the two largest channel margins as a
+    // conservative noise scale, in the same white-normalised units as the RGB.
+    var noise = channels.map(function (channel) { var _a; return (_a = profile === null || profile === void 0 ? void 0 : profile.margin[channel]) !== null && _a !== void 0 ? _a : policy.confidence.defaultChannelMargin; })
+        .sort(function (a, b) { return b - a; });
+    return __assign({ hue: marginScore(Math.min(hue - lowerHue, upperHue - hue) / policy.confidence.fullHueMarginDegrees), chroma: marginScore(Math.min(chroma - Math.max(match.chroma[0], policy.signal.minimumChroma), match.chroma[1] - chroma) / (noise[0] + noise[1])), saturation: marginScore((saturation - policy.signal.minimumSaturation) / policy.confidence.fullSaturationMargin) }, (profile && { air: marginScore(Math.max.apply(Math, channels.map(function (channel) {
+            return (values[channel] - profile.airMax[channel] - profile.margin[channel]) / profile.margin[channel];
+        }))) }));
+};
 /** Published channels are white-normalised by the SDK; do not clamp them for classification. */
 export var classifyColour = function (values, profile) {
     var r = values.red, g = values.green, b = values.blue, clear = values.clear, air = values.air;
@@ -20,7 +56,24 @@ export var classifyColour = function (values, profile) {
     var colourWithoutAirOverride = confident && match ? match.name : "unclear";
     var classifiedColour = colourWithoutAirOverride !== "unclear" ? colourWithoutAirOverride :
         valid && air ? "air" : "unclear";
-    return { classifiedColour: classifiedColour, colourWithoutAirOverride: colourWithoutAirOverride, hue: Number.isFinite(hue) ? hue : null, chroma: chroma, saturation: saturation, signalAboveAir: exceedsAir, signalSource: profile ? "calibratedAir" : "defaultRules", classificationReason: !valid ? "invalid" :
+    // A rule-strength score, not a statistical probability or a new acceptance
+    // gate. The weakest decision margin wins; existing colour decisions stay intact.
+    var confidence = 0;
+    var confidenceFactors = {};
+    if (colourWithoutAirOverride !== "unclear" && match) {
+        confidenceFactors = colourConfidenceFactors(values, hue, chroma, saturation, match, profile);
+        confidence = Math.min.apply(Math, Object.values(confidenceFactors));
+    }
+    else if (classifiedColour === "air") {
+        // Firmware Air alone has no measurable confidence. With calibration, all
+        // channels must agree with the air ceiling; contrary RGB evidence scores 0.
+        confidence = profile ? marginScore(Math.min.apply(Math, channels.map(function (channel) {
+            return (profile.airMax[channel] + profile.margin[channel] - values[channel]) / profile.margin[channel];
+        }))) : null;
+        if (confidence !== null)
+            confidenceFactors = { air: confidence };
+    }
+    return { classifiedColour: classifiedColour, colourWithoutAirOverride: colourWithoutAirOverride, hue: Number.isFinite(hue) ? hue : null, chroma: chroma, confidence: confidence, confidenceMethod: COLOUR_CONFIDENCE_METHOD, confidenceFactors: confidenceFactors, saturation: saturation, signalAboveAir: exceedsAir, signalSource: profile ? "calibratedAir" : "defaultRules", classificationReason: !valid ? "invalid" :
             !exceedsAir ? "withinCalibratedAir" : confident && match ? air ? "rgbOverridesFirmwareAir" : "rgbColour" :
                 air ? "firmwareAir" : "weakOrUnknownColour" };
 };
@@ -33,5 +86,5 @@ export var colourChannelsFromValues = function (vals) {
                 values[channel.toLowerCase()] = vals[key];
         }
     return { red: values.red, green: values.green, blue: values.blue,
-        clear: values.clear, air: [true, false, 0, 1].includes(values.air) ? Boolean(values.air) : undefined };
+        clear: values.clear, air: [true, false, 0, 1].some(function (value) { return value === values.air; }) ? Boolean(values.air) : undefined };
 };

package/dist-types/src/utils/colour-event-filter.d.ts

@@ -0,0 +1,24 @@
+import type { classifyColour, ColourName } from "./colour-classifier";
+export declare const COLOUR_EVENT_TIMING: {
+    readonly minimumReadings: 3;
+    readonly confirmationMs: 200;
+    readonly signalGapMs: 250;
+    readonly staleMs: 500;
+};
+type Reading = Pick<ReturnType<typeof classifyColour>, "classifiedColour" | "confidence" | "classificationReason">;
+type Value = {
+    colour: ColourName;
+    confidence: number | null;
+};
+/** Per-sensor event confirmation. Instantaneous classification remains independent. */
+export declare class ColourEventFilter {
+    private lastPacketAtMs;
+    private latest;
+    private confirmed;
+    private candidate;
+    reset(): void;
+    current(now: number): Value;
+    update(reading: Reading, receivedAtMs: number, now: number): Value;
+    get nextExpiryAtMs(): number | null;
+}
+export {};

package/dist-types/src/utils/colour-event-filter.js

@@ -0,0 +1,88 @@
+export var COLOUR_EVENT_TIMING = {
+    minimumReadings: 3,
+    confirmationMs: 200,
+    signalGapMs: 250,
+    staleMs: 500,
+};
+var isCard = function (colour) { return colour !== "air" && colour !== "unclear"; };
+/** Per-sensor event confirmation. Instantaneous classification remains independent. */
+var ColourEventFilter = /** @class */ (function () {
+    function ColourEventFilter() {
+        this.lastPacketAtMs = null;
+        this.latest = null;
+        this.confirmed = null;
+        this.candidate = null;
+    }
+    ColourEventFilter.prototype.reset = function () {
+        this.lastPacketAtMs = null;
+        this.latest = this.confirmed = this.candidate = null;
+    };
+    ColourEventFilter.prototype.current = function (now) {
+        var _a, _b;
+        if (this.lastPacketAtMs !== null && now - this.lastPacketAtMs >= COLOUR_EVENT_TIMING.staleMs) {
+            // Retain the packet watermark: repeated cached packets are still duplicates.
+            this.latest = this.confirmed = this.candidate = null;
+        }
+        if (this.confirmed && now - this.confirmed.lastAtMs >= COLOUR_EVENT_TIMING.signalGapMs)
+            this.confirmed = null;
+        if (this.candidate && now - this.candidate.lastAtMs >= COLOUR_EVENT_TIMING.signalGapMs)
+            this.candidate = null;
+        return ((_a = this.confirmed) === null || _a === void 0 ? void 0 : _a.value) || (((_b = this.latest) === null || _b === void 0 ? void 0 : _b.colour) === "air" ? this.latest :
+            { colour: "unclear", confidence: this.latest ? 0 : null });
+    };
+    ColourEventFilter.prototype.update = function (reading, receivedAtMs, now) {
+        var _a, _b;
+        this.current(now);
+        if (!Number.isFinite(receivedAtMs) || receivedAtMs <= 0 || receivedAtMs > now ||
+            now - receivedAtMs >= COLOUR_EVENT_TIMING.staleMs) {
+            this.reset();
+            return this.current(now);
+        }
+        // A STATE_INFO event can reuse the same add-on packet when other telemetry changes.
+        if (this.lastPacketAtMs !== null && receivedAtMs <= this.lastPacketAtMs)
+            return this.current(now);
+        this.lastPacketAtMs = receivedAtMs;
+        var value = { colour: reading.classifiedColour, confidence: reading.confidence };
+        this.latest = value;
+        if (reading.classificationReason === "invalid") {
+            this.confirmed = this.candidate = null;
+        }
+        else if (isCard(value.colour)) {
+            if (((_a = this.confirmed) === null || _a === void 0 ? void 0 : _a.value.colour) === value.colour) {
+                this.confirmed.value = value;
+                this.confirmed.lastAtMs = receivedAtMs;
+                this.candidate = null;
+            }
+            else {
+                if (((_b = this.candidate) === null || _b === void 0 ? void 0 : _b.value.colour) === value.colour) {
+                    this.candidate.count++;
+                    this.candidate.lastAtMs = receivedAtMs;
+                    this.candidate.value = value;
+                }
+                else {
+                    this.candidate = { value: value, firstAtMs: receivedAtMs, lastAtMs: receivedAtMs, count: 1 };
+                }
+                if (this.candidate.count >= COLOUR_EVENT_TIMING.minimumReadings &&
+                    receivedAtMs - this.candidate.firstAtMs >= COLOUR_EVENT_TIMING.confirmationMs) {
+                    this.confirmed = this.candidate;
+                    this.candidate = null;
+                }
+            }
+        }
+        return this.current(now);
+    };
+    Object.defineProperty(ColourEventFilter.prototype, "nextExpiryAtMs", {
+        get: function () {
+            var deadlines = [
+                this.confirmed && this.confirmed.lastAtMs + COLOUR_EVENT_TIMING.signalGapMs,
+                this.candidate && this.candidate.lastAtMs + COLOUR_EVENT_TIMING.signalGapMs,
+                this.latest && this.lastPacketAtMs + COLOUR_EVENT_TIMING.staleMs,
+            ].filter(function (value) { return value !== null; });
+            return deadlines.length ? Math.min.apply(Math, deadlines) : null;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return ColourEventFilter;
+}());
+export { ColourEventFilter };

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

@@ -1,5 +1,5 @@
 import colourPolicy from "./marty-colour-policy.json";
-import { ColourSignalProfile } from "./colour-classifier";
+import { ColourConfidenceFactors, ColourSignalProfile } from "./colour-classifier";
 import { ColourSensorProfile } from "./colour-sensor-profile";
 import type { RaftObserver } from "../application/RAFTs/RaftObserver";
 import type { RestMessageOptions } from "../types/communication-between-apps/wrapper-communication";
@@ -68,6 +68,9 @@ export type ColourReading = {
     hue: number | null;
     chroma: number;
     classifiedColour: string;
+    confidence?: number | null;
+    confidenceMethod?: string;
+    confidenceFactors?: ColourConfidenceFactors;
     colourWithoutAirOverride?: string;
     saturation?: number;
     signalAboveAir?: boolean;
@@ -93,6 +96,7 @@ export type ColourSnapshot = {
         signal?: typeof colourPolicy.signal;
         profile?: ColourSensorProfile;
         clearBoundsUsedForClassification?: boolean;
+        confidence?: typeof colourPolicy.confidence;
     };
     device: {
         id: string;
@@ -148,6 +152,9 @@ export declare const interpretColour: (vals: Record<string, number | boolean>, p
     colourWithoutAirOverride: import("./colour-classifier").ColourName;
     hue: number | null;
     chroma: number;
+    confidence: number | null;
+    confidenceMethod: string;
+    confidenceFactors: ColourConfidenceFactors;
     saturation: number;
     signalAboveAir: boolean;
     signalSource: string;

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

@@ -263,7 +263,8 @@ var captureUnlocked = function (sensor, expectedColour, session, signal) { retur
                 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: {
+                            signal: colourPolicy.signal, profile: getActiveColourSensorProfile(sensor), clearBoundsUsedForClassification: false,
+                            confidence: colourPolicy.confidence }, 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: {

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

@@ -2,6 +2,7 @@
     "source": "Marty web app RGB signal policy v4",
     "clearBoundsUsedForClassification": false,
     "signal": { "minimumChroma": 8, "minimumSaturation": 0.15, "airNoiseMarginRaw": 3 },
+    "confidence": { "method": "rule-margin-v1", "fullHueMarginDegrees": 15, "fullSaturationMargin": 0.15, "defaultChannelMargin": 3 },
     "boundaries": [
         { "hue": [0, 15], "chroma": [50, 200], "clear": [40, 150], "name": "red" },
         { "hue": [20, 65], "chroma": [40, 300], "clear": [100, 255], "name": "yellow" },

package/package.json

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