@robotical/webapp-types 3.18.6 → 3.18.7

package/dist-types/src/application/ApplicationManager/ApplicationManager.d.ts

@@ -59,7 +59,11 @@ export default class ApplicationManager {
     getDeviceInfo(): Promise<void>;
     updateRaftNameInAllStates(raftId: string, name: string): Promise<boolean>;
     private getConnectedRaftName;
-    private isRaftActive;
+    /**
+     * Whether this exact RAFT object still owns its ID and is not already in
+     * the asynchronous disconnect pipeline.
+     */
+    isRaftActive(raft: RAFT): boolean;
     private addConnectedRaftToContext;
     private publishLocalVerifiedConnection;
     private confirmQrVerifiedConnection;

package/dist-types/src/application/ApplicationManager/ApplicationManager.js

@@ -59,6 +59,7 @@ import LEDLightsOrQRVerificationModal from "../../components/modals/LEDLightsOrQ
 import { CarouselNavigatorManager } from "../../utils/CarouselNavigatorManager";
 import i18n from "../../i18n";
 import InUnpluggedModalContent from "../../components/modals/InUnplugged";
+import { cogKeepAwakeManager, } from "../../features/cog-keep-awake";
 var SHOW_LOGS = true;
 var TAG = "ApplicationManager";
 var UNSUPPORTED_WEB_BLUETOOTH_BROWSER_MESSAGE = "This browser can't connect to Marty or Cog over Bluetooth. Please use Chrome or Edge, or use the iPad app.";
@@ -230,6 +231,10 @@ var ApplicationManager = /** @class */ (function () {
             });
         });
     };
+    /**
+     * Whether this exact RAFT object still owns its ID and is not already in
+     * the asynchronous disconnect pipeline.
+     */
     ApplicationManager.prototype.isRaftActive = function (raft) {
         return this.connectedRafts[raft.id] === raft && !this._disconnectPromises.has(raft);
     };
@@ -902,6 +907,10 @@ var ApplicationManager = /** @class */ (function () {
         if (inFlightDisconnect) {
             return inFlightDisconnect;
         }
+        if (raft.type === RaftTypeE.COG) {
+            // Stop scheduling before any asynchronous disconnect work starts.
+            cogKeepAwakeManager.removeCog(raft);
+        }
         var operation = Promise.resolve().then(function () { return __awaiter(_this, void 0, void 0, function () {
             return __generator(this, function (_a) {
                 switch (_a.label) {

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

@@ -16,6 +16,10 @@ declare class PublishedDataAnalyser extends EventEmitter {
     private cog;
     cogState: CogState;
     private pubSub;
+    private accelerometerActivityBaseline;
+    private lastAccelerometerActivityAt;
+    private static readonly ACCELEROMETER_ACTIVITY_DEADBAND;
+    private static readonly ACCELEROMETER_ACTIVITY_RATE_LIMIT_MS;
     rotationDetection: RotationDetection;
     shakeDetector: ShakeDetector;
     buttonClickDetection: ButtonClickDetection;
@@ -58,6 +62,7 @@ declare class PublishedDataAnalyser extends EventEmitter {
     setObjectSense(objectSense: CogState["objectSense"]): void;
     setLightSense(lightSense: CogState["lightSense"]): void;
     setSteering(steering: CogState["steering"]): void;
+    private recordAccelerometerActivity;
 }
 declare class SteeringDetection {
     private DELAY_FOR_NEXT_STEERING;

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

@@ -53,6 +53,7 @@ import { createRaftPubSubscriptionHelper } from "../raft-subscription-helpers";
 import { isVersionGreater_errorCatching } from "../../../utils/helpers/compare-version";
 import EventEmitter from "events";
 import Logger from "../../../services/logger/Logger";
+import userActivityTracker from "../../../features/cog-keep-awake/UserActivityTracker";
 var SHOW_LOGS = true;
 var TAG = "PublishedDataAnalyser";
 var PublishedDataAnalyser = /** @class */ (function (_super) {
@@ -60,6 +61,8 @@ var PublishedDataAnalyser = /** @class */ (function (_super) {
     function PublishedDataAnalyser(cog) {
         var _this = _super.call(this) || this;
         _this.cog = cog;
+        _this.accelerometerActivityBaseline = null;
+        _this.lastAccelerometerActivityAt = Number.NEGATIVE_INFINITY;
         _this.rotationDetection = new RotationDetection();
         _this.shakeDetector = new ShakeDetector();
         _this.buttonClickDetection = new ButtonClickDetection();
@@ -141,6 +144,8 @@ var PublishedDataAnalyser = /** @class */ (function (_super) {
         var gyroData = data.gyroscope;
         var lightData = data.light;
         var isMoving;
+        if (accelData)
+            this.recordAccelerometerActivity(accelData);
         if (accelData)
             isMoving = this.shakeDetector.detectShake(accelData.ax, accelData.ay, accelData.az, Date.now(), this);
         accelData && this.tiltDetection.detectTilt(accelData.ax, accelData.ay, accelData.az, isMoving, this, this.cog.getRaftVersion());
@@ -151,20 +156,32 @@ var PublishedDataAnalyser = /** @class */ (function (_super) {
         accelData && this.steeringDetection.detectSteering(accelData, this);
     };
     PublishedDataAnalyser.prototype.setTilt = function (tilt) {
+        var hasChanged = this.cogState.tilt !== tilt;
         this.cogState.tilt = tilt;
         this.emit(this.eventsMap.tilt[tilt]);
+        if (hasChanged)
+            userActivityTracker.recordActivity();
     };
     PublishedDataAnalyser.prototype.setMovementType = function (movementType) {
+        var hasChanged = this.cogState.movementType !== movementType;
         this.cogState.movementType = movementType;
         this.emit(this.eventsMap.movementType[movementType]);
+        if (hasChanged && movementType !== "none")
+            userActivityTracker.recordActivity();
     };
     PublishedDataAnalyser.prototype.setRotation = function (rotation) {
+        var hasChanged = this.cogState.rotation !== rotation;
         this.cogState.rotation = rotation;
         this.emit(this.eventsMap.rotation[rotation]);
+        if (hasChanged && rotation !== "none")
+            userActivityTracker.recordActivity();
     };
     PublishedDataAnalyser.prototype.setButtonClick = function (buttonClick) {
+        var hasChanged = this.cogState.buttonClick !== buttonClick;
         this.cogState.buttonClick = buttonClick;
         this.emit(this.eventsMap.buttonClick[buttonClick]);
+        if (hasChanged && buttonClick !== "none")
+            userActivityTracker.recordActivity();
     };
     PublishedDataAnalyser.prototype.setObjectSense = function (objectSense) {
         this.cogState.objectSense = objectSense;
@@ -175,9 +192,39 @@ var PublishedDataAnalyser = /** @class */ (function (_super) {
         this.emit(this.eventsMap.lightSense[lightSense]);
     };
     PublishedDataAnalyser.prototype.setSteering = function (steering) {
+        var hasChanged = this.cogState.steering !== steering;
         this.cogState.steering = steering;
         this.emit(this.eventsMap.steering[steering]);
+        if (hasChanged)
+            userActivityTracker.recordActivity();
+    };
+    PublishedDataAnalyser.prototype.recordAccelerometerActivity = function (accelerometer) {
+        var currentSample = {
+            ax: accelerometer.ax,
+            ay: accelerometer.ay,
+            az: accelerometer.az,
+        };
+        if (!this.accelerometerActivityBaseline) {
+            this.accelerometerActivityBaseline = currentSample;
+            return;
+        }
+        var delta = Math.hypot(currentSample.ax - this.accelerometerActivityBaseline.ax, currentSample.ay - this.accelerometerActivityBaseline.ay, currentSample.az - this.accelerometerActivityBaseline.az);
+        if (delta < PublishedDataAnalyser.ACCELEROMETER_ACTIVITY_DEADBAND) {
+            return;
+        }
+        // Keep the comparison anchored to the latest meaningful sample even
+        // when activity reporting is rate-limited. Otherwise a quick move and
+        // return can be reported again a second later while the Cog is still.
+        this.accelerometerActivityBaseline = currentSample;
+        var now = Date.now();
+        if (now - this.lastAccelerometerActivityAt < PublishedDataAnalyser.ACCELEROMETER_ACTIVITY_RATE_LIMIT_MS) {
+            return;
+        }
+        this.lastAccelerometerActivityAt = now;
+        userActivityTracker.recordActivity(now);
     };
+    PublishedDataAnalyser.ACCELEROMETER_ACTIVITY_DEADBAND = 0.12;
+    PublishedDataAnalyser.ACCELEROMETER_ACTIVITY_RATE_LIMIT_MS = 1000;
     return PublishedDataAnalyser;
 }(EventEmitter));
 var SteeringDetection = /** @class */ (function () {

package/dist-types/src/features/cog-keep-awake/CogKeepAwakeManager.d.ts

@@ -0,0 +1,53 @@
+import type { CogKeepAwakeCog, CogKeepAwakeRuntime, CogKeepAwakeSnapshot } from "./types";
+export type CogKeepAwakeManagerOptions = {
+    runtime?: Partial<CogKeepAwakeRuntime>;
+    keepAwakeIntervalMs?: number;
+    idleTimeoutMs?: number;
+    promptTimeoutMs?: number;
+    retryDelayMs?: number;
+    fastRetryLimit?: number;
+    schedulerIntervalMs?: number;
+};
+/**
+ * Owns keep-awake state independently from React so timing, connection races,
+ * and prompt decisions can be tested deterministically.
+ */
+export declare class CogKeepAwakeManager {
+    private runtime;
+    private readonly sessions;
+    private readonly listeners;
+    private activePrompt;
+    private scheduler;
+    private wasVisible;
+    private nextPromptRevision;
+    private readonly keepAwakeIntervalMs;
+    private readonly idleTimeoutMs;
+    private readonly promptTimeoutMs;
+    private readonly retryDelayMs;
+    private readonly fastRetryLimit;
+    private readonly schedulerIntervalMs;
+    constructor(options?: CogKeepAwakeManagerOptions);
+    setRuntime(runtime: Partial<CogKeepAwakeRuntime>): void;
+    start(): void;
+    stop(): void;
+    syncCogs(cogs: Iterable<CogKeepAwakeCog>): void;
+    addCog(cog: CogKeepAwakeCog): void;
+    removeCog(cogOrId: CogKeepAwakeCog | string): void;
+    subscribe(listener: (snapshot: CogKeepAwakeSnapshot) => void): () => void;
+    getSnapshot(): CogKeepAwakeSnapshot;
+    resolvePrompt(keepAwake: boolean, expectedRevision?: number): boolean;
+    deferPrompt(): void;
+    tick(): void;
+    private activateVerifiedSession;
+    private sendSignal;
+    private openPromptIfPossible;
+    private isSessionCurrentAndVerified;
+    private isSessionIdle;
+    private isConfirmedUsb;
+    private getCogName;
+    private removeSessionFromPrompt;
+    private buildPromptSnapshot;
+    private emitSnapshot;
+}
+export declare const cogKeepAwakeManager: CogKeepAwakeManager;
+export default cogKeepAwakeManager;

package/dist-types/src/features/cog-keep-awake/CogKeepAwakeManager.js

@@ -0,0 +1,495 @@
+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 { RaftConnEvent } from "@robdobsn/raftjs";
+import { KEEP_AWAKE_FAST_RETRY_LIMIT, KEEP_AWAKE_INTERVAL_MS, KEEP_AWAKE_RETRY_DELAY_MS, KEEP_AWAKE_SCHEDULER_INTERVAL_MS, PROMPT_TIMEOUT_MS, USER_IDLE_TIMEOUT_MS, } from "./constants";
+var defaultRuntime = {
+    now: function () { return Date.now(); },
+    getLastActivityAt: function () { return Date.now(); },
+    isVisible: function () {
+        return typeof document === "undefined" ||
+            (!document.hidden && document.visibilityState !== "hidden");
+    },
+    isCurrentCog: function () { return true; },
+    canPrompt: function () { return true; },
+};
+/**
+ * Owns keep-awake state independently from React so timing, connection races,
+ * and prompt decisions can be tested deterministically.
+ */
+var CogKeepAwakeManager = /** @class */ (function () {
+    function CogKeepAwakeManager(options) {
+        if (options === void 0) { options = {}; }
+        var _a, _b, _c, _d, _e, _f;
+        this.sessions = new Map();
+        this.listeners = new Set();
+        this.activePrompt = null;
+        this.scheduler = null;
+        this.wasVisible = null;
+        this.nextPromptRevision = 0;
+        this.runtime = __assign(__assign({}, defaultRuntime), options.runtime);
+        this.keepAwakeIntervalMs =
+            (_a = options.keepAwakeIntervalMs) !== null && _a !== void 0 ? _a : KEEP_AWAKE_INTERVAL_MS;
+        this.idleTimeoutMs = (_b = options.idleTimeoutMs) !== null && _b !== void 0 ? _b : USER_IDLE_TIMEOUT_MS;
+        this.promptTimeoutMs = (_c = options.promptTimeoutMs) !== null && _c !== void 0 ? _c : PROMPT_TIMEOUT_MS;
+        this.retryDelayMs = (_d = options.retryDelayMs) !== null && _d !== void 0 ? _d : KEEP_AWAKE_RETRY_DELAY_MS;
+        this.fastRetryLimit =
+            (_e = options.fastRetryLimit) !== null && _e !== void 0 ? _e : KEEP_AWAKE_FAST_RETRY_LIMIT;
+        this.schedulerIntervalMs =
+            (_f = options.schedulerIntervalMs) !== null && _f !== void 0 ? _f : KEEP_AWAKE_SCHEDULER_INTERVAL_MS;
+    }
+    CogKeepAwakeManager.prototype.setRuntime = function (runtime) {
+        this.runtime = __assign(__assign({}, this.runtime), runtime);
+        if (!this.runtime.canPrompt()) {
+            this.deferPrompt();
+            return;
+        }
+        this.tick();
+    };
+    CogKeepAwakeManager.prototype.start = function () {
+        var _this = this;
+        if (this.scheduler !== null) {
+            return;
+        }
+        this.scheduler = setInterval(function () { return _this.tick(); }, this.schedulerIntervalMs);
+        this.tick();
+    };
+    CogKeepAwakeManager.prototype.stop = function () {
+        if (this.scheduler !== null) {
+            clearInterval(this.scheduler);
+            this.scheduler = null;
+        }
+        for (var _i = 0, _a = Array.from(this.sessions.values()); _i < _a.length; _i++) {
+            var session = _a[_i];
+            this.removeCog(session.cog);
+        }
+        this.activePrompt = null;
+        this.wasVisible = null;
+        this.emitSnapshot();
+    };
+    CogKeepAwakeManager.prototype.syncCogs = function (cogs) {
+        var nextCogs = new Set(cogs);
+        for (var _i = 0, _a = Array.from(this.sessions.values()); _i < _a.length; _i++) {
+            var session = _a[_i];
+            if (!nextCogs.has(session.cog)) {
+                this.removeCog(session.cog);
+            }
+        }
+        for (var _b = 0, _c = Array.from(nextCogs); _b < _c.length; _b++) {
+            var cog = _c[_b];
+            this.addCog(cog);
+        }
+        this.tick();
+    };
+    CogKeepAwakeManager.prototype.addCog = function (cog) {
+        var _this = this;
+        if (this.sessions.has(cog)) {
+            return;
+        }
+        for (var _i = 0, _a = Array.from(this.sessions.values()); _i < _a.length; _i++) {
+            var session_1 = _a[_i];
+            if (session_1.cog.id === cog.id && session_1.cog !== cog) {
+                this.removeCog(session_1.cog);
+            }
+        }
+        var observer = {
+            notify: function (_eventType, eventEnum) {
+                if (eventEnum === RaftConnEvent.CONN_VERIFIED_CORRECT) {
+                    var currentSession = _this.sessions.get(cog);
+                    if ((currentSession === null || currentSession === void 0 ? void 0 : currentSession.state) === "waiting-for-verification") {
+                        _this.activateVerifiedSession(currentSession);
+                    }
+                    return;
+                }
+                if (eventEnum === RaftConnEvent.CONN_DISCONNECTED ||
+                    eventEnum === RaftConnEvent.CONN_REJECTED) {
+                    _this.removeCog(cog);
+                }
+            },
+        };
+        var onUsb = this.isConfirmedUsb(cog);
+        var session = {
+            cog: cog,
+            state: cog.hasVerifiedConnection()
+                ? onUsb
+                    ? "paused-usb"
+                    : "armed"
+                : "waiting-for-verification",
+            nextSignalAt: Number.POSITIVE_INFINITY,
+            idleGraceUntil: Number.NEGATIVE_INFINITY,
+            consecutiveFailures: 0,
+            signalGeneration: 0,
+            wasOnUsb: onUsb,
+            observer: observer,
+        };
+        this.sessions.set(cog, session);
+        cog.subscribe(observer, ["conn"]);
+        if (cog.hasVerifiedConnection() && !onUsb) {
+            this.activateVerifiedSession(session);
+        }
+    };
+    CogKeepAwakeManager.prototype.removeCog = function (cogOrId) {
+        var sessionsToRemove = Array.from(this.sessions.values()).filter(function (session) {
+            return typeof cogOrId === "string"
+                ? session.cog.id === cogOrId
+                : session.cog === cogOrId;
+        });
+        for (var _i = 0, sessionsToRemove_1 = sessionsToRemove; _i < sessionsToRemove_1.length; _i++) {
+            var session = sessionsToRemove_1[_i];
+            session.cog.unsubscribe(session.observer);
+            this.sessions.delete(session.cog);
+            this.removeSessionFromPrompt(session);
+        }
+    };
+    CogKeepAwakeManager.prototype.subscribe = function (listener) {
+        var _this = this;
+        this.listeners.add(listener);
+        return function () { return _this.listeners.delete(listener); };
+    };
+    CogKeepAwakeManager.prototype.getSnapshot = function () {
+        return { prompt: this.buildPromptSnapshot() };
+    };
+    CogKeepAwakeManager.prototype.resolvePrompt = function (keepAwake, expectedRevision) {
+        if (!this.activePrompt ||
+            (expectedRevision !== undefined &&
+                this.activePrompt.revision !== expectedRevision)) {
+            return false;
+        }
+        var promptedSessions = Array.from(this.activePrompt.sessions);
+        this.activePrompt = null;
+        for (var _i = 0, promptedSessions_1 = promptedSessions; _i < promptedSessions_1.length; _i++) {
+            var session = promptedSessions_1[_i];
+            if (this.sessions.get(session.cog) !== session ||
+                session.state !== "prompting") {
+                continue;
+            }
+            if (!keepAwake) {
+                session.state = "opted-out";
+                continue;
+            }
+            if (!this.runtime.isVisible() ||
+                !this.isSessionCurrentAndVerified(session)) {
+                session.state = "needs-confirmation";
+                continue;
+            }
+            if (this.isConfirmedUsb(session.cog)) {
+                session.wasOnUsb = true;
+                session.state = "paused-usb";
+                continue;
+            }
+            session.state = "armed";
+            void this.sendSignal(session);
+        }
+        this.emitSnapshot();
+        return true;
+    };
+    CogKeepAwakeManager.prototype.deferPrompt = function () {
+        if (!this.activePrompt) {
+            return;
+        }
+        for (var _i = 0, _a = Array.from(this.activePrompt.sessions); _i < _a.length; _i++) {
+            var session = _a[_i];
+            if (this.sessions.get(session.cog) === session &&
+                session.state === "prompting") {
+                session.state = "needs-confirmation";
+            }
+        }
+        this.activePrompt = null;
+        this.emitSnapshot();
+    };
+    CogKeepAwakeManager.prototype.tick = function () {
+        var now = this.runtime.now();
+        var isVisible = this.runtime.isVisible();
+        var resumedFromHidden = this.wasVisible === false && isVisible;
+        this.wasVisible = isVisible;
+        if (this.activePrompt && now >= this.activePrompt.expiresAt) {
+            this.resolvePrompt(false, this.activePrompt.revision);
+        }
+        for (var _i = 0, _a = Array.from(this.sessions.values()); _i < _a.length; _i++) {
+            var session = _a[_i];
+            if (!this.runtime.isCurrentCog(session.cog)) {
+                this.removeCog(session.cog);
+                continue;
+            }
+            // A No/timeout decision is a connection-lifetime latch. Power-source
+            // changes must never silently re-enable keep-awake for that Cog object.
+            if (session.state === "opted-out") {
+                continue;
+            }
+            var onUsb = this.isConfirmedUsb(session.cog);
+            if (onUsb) {
+                session.wasOnUsb = true;
+                if (session.state !== "waiting-for-verification") {
+                    session.state = "paused-usb";
+                    this.removeSessionFromPrompt(session);
+                }
+                continue;
+            }
+            if (session.wasOnUsb) {
+                session.wasOnUsb = false;
+                if (session.cog.hasVerifiedConnection()) {
+                    // Unplugging the Cog is itself physical activity and starts the
+                    // battery-only firmware timeout, so protect it immediately.
+                    session.idleGraceUntil = now + this.idleTimeoutMs;
+                    this.activateVerifiedSession(session);
+                }
+                continue;
+            }
+            if (session.state === "waiting-for-verification") {
+                if (session.cog.hasVerifiedConnection()) {
+                    this.activateVerifiedSession(session);
+                }
+                continue;
+            }
+            if (session.state === "sending" ||
+                session.state === "prompting" ||
+                session.state === "needs-confirmation" ||
+                session.state === "paused-usb") {
+                continue;
+            }
+            if (this.isSessionIdle(session, now)) {
+                session.state = "needs-confirmation";
+                continue;
+            }
+            if (now >= session.nextSignalAt) {
+                if (!isVisible || resumedFromHidden) {
+                    session.state = "needs-confirmation";
+                }
+                else {
+                    void this.sendSignal(session);
+                }
+            }
+        }
+        this.openPromptIfPossible(now);
+    };
+    CogKeepAwakeManager.prototype.activateVerifiedSession = function (session) {
+        if (this.sessions.get(session.cog) !== session) {
+            return;
+        }
+        if (this.isConfirmedUsb(session.cog)) {
+            session.wasOnUsb = true;
+            session.state = "paused-usb";
+            return;
+        }
+        if (!this.runtime.isVisible() || !this.runtime.isCurrentCog(session.cog)) {
+            session.state = "needs-confirmation";
+            this.openPromptIfPossible(this.runtime.now());
+            return;
+        }
+        if (this.isSessionIdle(session, this.runtime.now())) {
+            session.state = "needs-confirmation";
+            this.openPromptIfPossible(this.runtime.now());
+            return;
+        }
+        // In particular, make a USB -> battery transition eligible to send. The
+        // regular send guard correctly rejects sessions left in paused-usb.
+        session.state = "armed";
+        void this.sendSignal(session);
+    };
+    CogKeepAwakeManager.prototype.sendSignal = function (session) {
+        return __awaiter(this, void 0, void 0, function () {
+            var signalGeneration, response, _a, result, succeeded, now;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (this.sessions.get(session.cog) !== session ||
+                            session.state !== "armed" ||
+                            !this.isSessionCurrentAndVerified(session)) {
+                            return [2 /*return*/];
+                        }
+                        session.state = "sending";
+                        signalGeneration = ++session.signalGeneration;
+                        _b.label = 1;
+                    case 1:
+                        _b.trys.push([1, 3, , 4]);
+                        return [4 /*yield*/, session.cog.sendRestMessage("audio/vol")];
+                    case 2:
+                        response = _b.sent();
+                        return [3 /*break*/, 4];
+                    case 3:
+                        _a = _b.sent();
+                        response = null;
+                        return [3 /*break*/, 4];
+                    case 4:
+                        if (this.sessions.get(session.cog) !== session ||
+                            session.state !== "sending" ||
+                            session.signalGeneration !== signalGeneration) {
+                            return [2 /*return*/];
+                        }
+                        if (!this.isSessionCurrentAndVerified(session)) {
+                            this.removeCog(session.cog);
+                            return [2 /*return*/];
+                        }
+                        if (this.isConfirmedUsb(session.cog)) {
+                            session.wasOnUsb = true;
+                            session.state = "paused-usb";
+                            return [2 /*return*/];
+                        }
+                        result = response;
+                        succeeded = typeof (result === null || result === void 0 ? void 0 : result.rslt) === "string" && result.rslt.toLowerCase() === "ok";
+                        now = this.runtime.now();
+                        if (succeeded) {
+                            session.consecutiveFailures = 0;
+                            session.state = "armed";
+                            session.nextSignalAt = now + this.keepAwakeIntervalMs;
+                            return [2 /*return*/];
+                        }
+                        session.consecutiveFailures += 1;
+                        session.state = "armed";
+                        session.nextSignalAt =
+                            now +
+                                (session.consecutiveFailures <= this.fastRetryLimit
+                                    ? this.retryDelayMs
+                                    : this.keepAwakeIntervalMs);
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    CogKeepAwakeManager.prototype.openPromptIfPossible = function (now) {
+        var _this = this;
+        if (!this.runtime.isVisible() || !this.runtime.canPrompt()) {
+            return;
+        }
+        var sessions = Array.from(this.sessions.values()).filter(function (session) {
+            return session.state === "needs-confirmation" &&
+                _this.isSessionCurrentAndVerified(session) &&
+                !_this.isConfirmedUsb(session.cog);
+        });
+        if (sessions.length === 0) {
+            return;
+        }
+        if (this.activePrompt) {
+            for (var _i = 0, sessions_1 = sessions; _i < sessions_1.length; _i++) {
+                var session = sessions_1[_i];
+                session.state = "prompting";
+                this.activePrompt.sessions.add(session);
+            }
+            this.activePrompt.expiresAt = Math.max(this.activePrompt.expiresAt, now + this.promptTimeoutMs);
+            this.activePrompt.revision = ++this.nextPromptRevision;
+            this.emitSnapshot();
+            return;
+        }
+        for (var _a = 0, sessions_2 = sessions; _a < sessions_2.length; _a++) {
+            var session = sessions_2[_a];
+            session.state = "prompting";
+        }
+        this.activePrompt = {
+            revision: ++this.nextPromptRevision,
+            sessions: new Set(sessions),
+            expiresAt: now + this.promptTimeoutMs,
+        };
+        this.emitSnapshot();
+    };
+    CogKeepAwakeManager.prototype.isSessionCurrentAndVerified = function (session) {
+        return (this.sessions.get(session.cog) === session &&
+            this.runtime.isCurrentCog(session.cog) &&
+            session.cog.hasVerifiedConnection());
+    };
+    CogKeepAwakeManager.prototype.isSessionIdle = function (session, now) {
+        return (now >= session.idleGraceUntil &&
+            now - this.runtime.getLastActivityAt() >= this.idleTimeoutMs);
+    };
+    CogKeepAwakeManager.prototype.isConfirmedUsb = function (cog) {
+        var _a, _b;
+        var usb = (_b = (_a = cog.raftStateInfo) === null || _a === void 0 ? void 0 : _a.power) === null || _b === void 0 ? void 0 : _b.usb;
+        return typeof usb === "string" && usb.toLowerCase() === "yes";
+    };
+    CogKeepAwakeManager.prototype.getCogName = function (cog) {
+        var _a, _b;
+        try {
+            return ((_b = (_a = cog.getFriendlyName) === null || _a === void 0 ? void 0 : _a.call(cog)) === null || _b === void 0 ? void 0 : _b.trim()) || cog.id || "Cog";
+        }
+        catch (_c) {
+            return cog.id || "Cog";
+        }
+    };
+    CogKeepAwakeManager.prototype.removeSessionFromPrompt = function (session) {
+        var _a;
+        if (!((_a = this.activePrompt) === null || _a === void 0 ? void 0 : _a.sessions.delete(session))) {
+            return;
+        }
+        if (this.activePrompt.sessions.size === 0) {
+            this.activePrompt = null;
+        }
+        this.emitSnapshot();
+    };
+    CogKeepAwakeManager.prototype.buildPromptSnapshot = function () {
+        var _this = this;
+        if (!this.activePrompt) {
+            return null;
+        }
+        var devices = Array.from(this.activePrompt.sessions).map(function (session) { return ({
+            id: session.cog.id,
+            name: _this.getCogName(session.cog),
+        }); });
+        return {
+            revision: this.activePrompt.revision,
+            devices: devices,
+            deviceIds: devices.map(function (_a) {
+                var id = _a.id;
+                return id;
+            }),
+            deviceNames: devices.map(function (_a) {
+                var name = _a.name;
+                return name;
+            }),
+            expiresAt: this.activePrompt.expiresAt,
+        };
+    };
+    CogKeepAwakeManager.prototype.emitSnapshot = function () {
+        var snapshot = this.getSnapshot();
+        for (var _i = 0, _a = Array.from(this.listeners); _i < _a.length; _i++) {
+            var listener = _a[_i];
+            listener(snapshot);
+        }
+    };
+    return CogKeepAwakeManager;
+}());
+export { CogKeepAwakeManager };
+export var cogKeepAwakeManager = new CogKeepAwakeManager();
+export default cogKeepAwakeManager;

package/dist-types/src/features/cog-keep-awake/UserActivityTracker.d.ts

@@ -0,0 +1,22 @@
+type Cleanup = () => void;
+/**
+ * Tracks interaction with the app without treating an open/backgrounded tab as
+ * proof that somebody is still present.
+ */
+export declare class UserActivityTracker {
+    private readonly now;
+    private readonly isAppVisible;
+    private lastActivityAt;
+    constructor(now?: () => number, isAppVisible?: () => boolean);
+    getLastActivityAt(): number;
+    recordActivity(at?: number): boolean;
+    /**
+     * Attach activity listeners to either the main app window or a same-origin
+     * embedded editor window. The returned cleanup is safe to call repeatedly.
+     */
+    attachWindow(targetWindow: Window): Cleanup;
+    private isTopDocumentHidden;
+}
+declare const userActivityTracker: UserActivityTracker;
+export { userActivityTracker };
+export default userActivityTracker;

package/dist-types/src/features/cog-keep-awake/UserActivityTracker.js

@@ -0,0 +1,177 @@
+var DRAG_ACTIVITY_THROTTLE_MS = 1000;
+/**
+ * Tracks interaction with the app without treating an open/backgrounded tab as
+ * proof that somebody is still present.
+ */
+var UserActivityTracker = /** @class */ (function () {
+    function UserActivityTracker(now, isAppVisible) {
+        if (now === void 0) { now = function () { return Date.now(); }; }
+        if (isAppVisible === void 0) { isAppVisible = function () {
+            return typeof document === "undefined" ||
+                (!document.hidden && document.visibilityState !== "hidden");
+        }; }
+        this.now = now;
+        this.isAppVisible = isAppVisible;
+        this.lastActivityAt = this.now();
+    }
+    UserActivityTracker.prototype.getLastActivityAt = function () {
+        return this.lastActivityAt;
+    };
+    UserActivityTracker.prototype.recordActivity = function (at) {
+        if (at === void 0) { at = this.now(); }
+        if (!this.isAppVisible() || this.isTopDocumentHidden()) {
+            return false;
+        }
+        this.lastActivityAt = at;
+        return true;
+    };
+    /**
+     * Attach activity listeners to either the main app window or a same-origin
+     * embedded editor window. The returned cleanup is safe to call repeatedly.
+     */
+    UserActivityTracker.prototype.attachWindow = function (targetWindow) {
+        var _this = this;
+        var listeners = [];
+        var activePointerIds = new Set();
+        var mouseIsDown = false;
+        var touchIsActive = false;
+        var lastDragActivityAt = Number.NEGATIVE_INFINITY;
+        var addListener = function (type, listener, options) {
+            if (options === void 0) { options = { capture: true, passive: true }; }
+            targetWindow.addEventListener(type, listener, options);
+            listeners.push({ type: type, listener: listener, options: options });
+        };
+        var recordTrustedActivity = function (event) {
+            if (!event.isTrusted) {
+                return null;
+            }
+            var activityAt = _this.now();
+            return _this.recordActivity(activityAt) ? activityAt : null;
+        };
+        var activityListener = function (event) {
+            recordTrustedActivity(event);
+        };
+        var pointerDownListener = function (event) {
+            var activityAt = recordTrustedActivity(event);
+            if (activityAt === null) {
+                return;
+            }
+            var pointerId = event.pointerId;
+            activePointerIds.add(typeof pointerId === "number" ? pointerId : 0);
+            lastDragActivityAt = activityAt;
+        };
+        var pointerUpListener = function (event) {
+            var pointerId = event.pointerId;
+            if (typeof pointerId === "number") {
+                activePointerIds.delete(pointerId);
+            }
+            else {
+                activePointerIds.clear();
+            }
+            if (!activePointerIds.size) {
+                mouseIsDown = false;
+                touchIsActive = false;
+            }
+        };
+        var mouseDownListener = function (event) {
+            var activityAt = recordTrustedActivity(event);
+            if (activityAt === null) {
+                return;
+            }
+            mouseIsDown = true;
+            lastDragActivityAt = activityAt;
+        };
+        var touchStartListener = function (event) {
+            var activityAt = recordTrustedActivity(event);
+            if (activityAt === null) {
+                return;
+            }
+            touchIsActive = true;
+            lastDragActivityAt = activityAt;
+        };
+        var touchEndListener = function (event) {
+            var touches = event.touches;
+            touchIsActive = Boolean(touches === null || touches === void 0 ? void 0 : touches.length);
+        };
+        var pointerMoveListener = function (event) {
+            if (!activePointerIds.size && !mouseIsDown && !touchIsActive) {
+                return;
+            }
+            if (!event.isTrusted) {
+                return;
+            }
+            var activityAt = _this.now();
+            if (activityAt - lastDragActivityAt < DRAG_ACTIVITY_THROTTLE_MS) {
+                return;
+            }
+            if (_this.recordActivity(activityAt)) {
+                lastDragActivityAt = activityAt;
+            }
+        };
+        var resetPressedState = function () {
+            activePointerIds.clear();
+            mouseIsDown = false;
+            touchIsActive = false;
+        };
+        addListener("pointerdown", pointerDownListener);
+        addListener("pointerup", pointerUpListener);
+        addListener("pointercancel", pointerUpListener);
+        addListener("pointermove", pointerMoveListener);
+        // These also cover browsers/WebViews that do not expose Pointer Events.
+        addListener("mousedown", mouseDownListener);
+        addListener("mousemove", pointerMoveListener);
+        addListener("mouseup", function () {
+            mouseIsDown = false;
+        });
+        addListener("touchstart", touchStartListener);
+        addListener("touchmove", pointerMoveListener);
+        addListener("touchend", touchEndListener);
+        addListener("touchcancel", touchEndListener);
+        addListener("keydown", activityListener);
+        addListener("click", activityListener);
+        addListener("wheel", activityListener);
+        addListener("input", activityListener);
+        addListener("change", activityListener);
+        addListener("scroll", activityListener);
+        addListener("blur", resetPressedState, { capture: true });
+        var isCleanedUp = false;
+        return function () {
+            if (isCleanedUp) {
+                return;
+            }
+            isCleanedUp = true;
+            for (var _i = 0, listeners_1 = listeners; _i < listeners_1.length; _i++) {
+                var _a = listeners_1[_i], type = _a.type, listener = _a.listener, options = _a.options;
+                try {
+                    targetWindow.removeEventListener(type, listener, options);
+                }
+                catch (_b) {
+                    // The embedded document may have navigated to a different origin.
+                }
+            }
+            resetPressedState();
+        };
+    };
+    UserActivityTracker.prototype.isTopDocumentHidden = function () {
+        var _a, _b;
+        if (typeof document === "undefined") {
+            return false;
+        }
+        var topDocument = document;
+        if (typeof window !== "undefined") {
+            try {
+                topDocument = (_b = (_a = window.top) === null || _a === void 0 ? void 0 : _a.document) !== null && _b !== void 0 ? _b : document;
+            }
+            catch (_c) {
+                // A cross-origin parent is not expected in production, but the local
+                // document is still a safe fallback if this app is embedded elsewhere.
+            }
+        }
+        return topDocument.hidden || topDocument.visibilityState === "hidden";
+    };
+    return UserActivityTracker;
+}());
+export { UserActivityTracker };
+var userActivityTracker = new UserActivityTracker();
+export { userActivityTracker };
+export default userActivityTracker;

package/dist-types/src/features/cog-keep-awake/constants.d.ts

@@ -0,0 +1,6 @@
+export declare const KEEP_AWAKE_INTERVAL_MS: number;
+export declare const USER_IDLE_TIMEOUT_MS: number;
+export declare const PROMPT_TIMEOUT_MS: number;
+export declare const KEEP_AWAKE_RETRY_DELAY_MS: number;
+export declare const KEEP_AWAKE_FAST_RETRY_LIMIT = 2;
+export declare const KEEP_AWAKE_SCHEDULER_INTERVAL_MS = 1000;

package/dist-types/src/features/cog-keep-awake/constants.js

@@ -0,0 +1,6 @@
+export var KEEP_AWAKE_INTERVAL_MS = 5 * 60 * 1000;
+export var USER_IDLE_TIMEOUT_MS = 10 * 60 * 1000;
+export var PROMPT_TIMEOUT_MS = 60 * 1000;
+export var KEEP_AWAKE_RETRY_DELAY_MS = 30 * 1000;
+export var KEEP_AWAKE_FAST_RETRY_LIMIT = 2;
+export var KEEP_AWAKE_SCHEDULER_INTERVAL_MS = 1000;

package/dist-types/src/features/cog-keep-awake/index.d.ts

@@ -0,0 +1,4 @@
+export { CogKeepAwakeManager, cogKeepAwakeManager, } from "./CogKeepAwakeManager";
+export type { CogKeepAwakeManagerOptions } from "./CogKeepAwakeManager";
+export * from "./constants";
+export type { CogKeepAwakeCog, CogKeepAwakePrompt, CogKeepAwakeRuntime, CogKeepAwakeSnapshot, } from "./types";

package/dist-types/src/features/cog-keep-awake/index.js

@@ -0,0 +1,2 @@
+export { CogKeepAwakeManager, cogKeepAwakeManager, } from "./CogKeepAwakeManager";
+export * from "./constants";

package/dist-types/src/features/cog-keep-awake/types.d.ts

@@ -0,0 +1,41 @@
+export type CogKeepAwakeResult = {
+    rslt?: string;
+    [key: string]: unknown;
+};
+export type CogKeepAwakeObserver = {
+    notify: (eventType: string, eventEnum: unknown, eventName: string, eventData: unknown) => void;
+};
+export type CogKeepAwakeCog = {
+    id: string;
+    raftStateInfo?: {
+        power?: {
+            usb?: string;
+        };
+    } | null;
+    getFriendlyName?: () => string | undefined;
+    hasVerifiedConnection: () => boolean;
+    sendRestMessage: (message: string) => Promise<CogKeepAwakeResult | unknown>;
+    subscribe: (observer: CogKeepAwakeObserver, topics: string[]) => void;
+    unsubscribe: (observer: CogKeepAwakeObserver) => void;
+};
+export type CogKeepAwakeRuntime = {
+    now: () => number;
+    getLastActivityAt: () => number;
+    isVisible: () => boolean;
+    isCurrentCog: (cog: CogKeepAwakeCog) => boolean;
+    canPrompt: () => boolean;
+};
+export type CogKeepAwakePromptDevice = {
+    id: string;
+    name: string;
+};
+export type CogKeepAwakePrompt = {
+    revision: number;
+    devices: CogKeepAwakePromptDevice[];
+    deviceIds: string[];
+    deviceNames: string[];
+    expiresAt: number;
+};
+export type CogKeepAwakeSnapshot = {
+    prompt: CogKeepAwakePrompt | null;
+};

package/dist-types/src/features/cog-keep-awake/types.js

@@ -0,0 +1 @@
+export {};

package/dist-types/src/i18n.js

@@ -140,6 +140,20 @@ var resources = {
                 "more_info": "MORE INFORMATION",
                 "reject": "NO, I DON'T ACCEPT"
             },
+            "cog_keep_awake": {
+                "device_list_label": "Cogs affected by this choice",
+                "explanation": "If you choose No or do not respond, keep-awake signals will stop and normal automatic power-off will follow.",
+                "no": "No",
+                "no_aria_label": "No, stop keeping Cog awake",
+                "question": "We haven't detected any activity. Do you want to keep Cog turned on?",
+                "question_multiple": "We haven't detected any activity. Do you want to keep these Cogs turned on?",
+                "question_named": "We haven't detected any activity. Do you want to keep {{deviceName}} turned on?",
+                "seconds_remaining_one": "{{seconds}} second remaining",
+                "seconds_remaining_other": "{{seconds}} seconds remaining",
+                "title": "Keep Cog turned on?",
+                "yes": "Yes",
+                "yes_aria_label": "Yes, keep Cog awake"
+            },
             "calibration_screen": {
                 "colour_calibration": {
                     "unplugged_modal_title": "Unplugged",
@@ -549,6 +563,20 @@ var resources = {
                 "more_info": "ΠΕΡΙΣΣΟΤΕΡΕΣ ΠΛΗΡΟΦΟΡΙΕΣ",
                 "reject": "ΟΧΙ, ΔΕΝ ΑΠΟΔΕΧΟΜΑΙ"
             },
+            "cog_keep_awake": {
+                "device_list_label": "Συσκευές Cog που επηρεάζονται από αυτή την επιλογή",
+                "explanation": "Αν επιλέξετε «Όχι» ή δεν απαντήσετε, τα σήματα διατήρησης σε λειτουργία θα σταματήσουν και θα ισχύσει η κανονική αυτόματη απενεργοποίηση.",
+                "no": "Όχι",
+                "no_aria_label": "Όχι, σταμάτησε να διατηρείς το Cog ενεργό",
+                "question": "Δεν εντοπίσαμε καμία δραστηριότητα. Θέλετε να παραμείνει το Cog ενεργοποιημένο;",
+                "question_multiple": "Δεν εντοπίσαμε καμία δραστηριότητα. Θέλετε να παραμείνουν αυτές οι συσκευές Cog ενεργοποιημένες;",
+                "question_named": "Δεν εντοπίσαμε καμία δραστηριότητα. Θέλετε να παραμείνει το {{deviceName}} ενεργοποιημένο;",
+                "seconds_remaining_one": "Απομένει {{seconds}} δευτερόλεπτο",
+                "seconds_remaining_other": "Απομένουν {{seconds}} δευτερόλεπτα",
+                "title": "Να παραμείνει το Cog ενεργοποιημένο;",
+                "yes": "Ναι",
+                "yes_aria_label": "Ναι, διατήρησε το Cog ενεργό"
+            },
             "calibration_screen": {
                 "colour_calibration": {
                     "unplugged_modal_title": "Unplugged",
@@ -941,6 +969,20 @@ var resources = {
                 "more_info": "MEER INFORMATIE",
                 "reject": "NEE, IK ACCEPTEER HET NIET"
             },
+            "cog_keep_awake": {
+                "device_list_label": "Cog-apparaten waarop deze keuze van toepassing is",
+                "explanation": "Als je Nee kiest of niet reageert, stoppen de signalen die Cog actief houden en volgt de normale automatische uitschakeling.",
+                "no": "Nee",
+                "no_aria_label": "Nee, stop met Cog actief te houden",
+                "question": "We hebben geen activiteit gedetecteerd. Wil je Cog ingeschakeld houden?",
+                "question_multiple": "We hebben geen activiteit gedetecteerd. Wil je deze Cogs ingeschakeld houden?",
+                "question_named": "We hebben geen activiteit gedetecteerd. Wil je {{deviceName}} ingeschakeld houden?",
+                "seconds_remaining_one": "Nog {{seconds}} seconde",
+                "seconds_remaining_other": "Nog {{seconds}} seconden",
+                "title": "Cog ingeschakeld houden?",
+                "yes": "Ja",
+                "yes_aria_label": "Ja, houd Cog actief"
+            },
             "calibration_screen": {
                 "colour_calibration": {
                     "unplugged_modal_title": "Unplugged",
@@ -1333,6 +1375,21 @@ var resources = {
                 "more_info": "ULTERIORI INFORMAZIONI",
                 "reject": "NO, NON ACCETTO"
             },
+            "cog_keep_awake": {
+                "device_list_label": "Cog interessati da questa scelta",
+                "explanation": "Se scegli No o non rispondi, i segnali che mantengono Cog attivo si interromperanno e seguirà il normale spegnimento automatico.",
+                "no": "No",
+                "no_aria_label": "No, smetti di mantenere Cog attivo",
+                "question": "Non abbiamo rilevato alcuna attività. Vuoi lasciare Cog acceso?",
+                "question_multiple": "Non abbiamo rilevato alcuna attività. Vuoi lasciare accesi questi Cog?",
+                "question_named": "Non abbiamo rilevato alcuna attività. Vuoi lasciare acceso {{deviceName}}?",
+                "seconds_remaining_one": "{{seconds}} secondo rimanente",
+                "seconds_remaining_many": "{{seconds}} secondi rimanenti",
+                "seconds_remaining_other": "{{seconds}} secondi rimanenti",
+                "title": "Lasciare Cog acceso?",
+                "yes": "Sì",
+                "yes_aria_label": "Sì, mantieni Cog attivo"
+            },
             "calibration_screen": {
                 "colour_calibration": {
                     "unplugged_modal_title": "Unplugged",
@@ -1725,6 +1782,21 @@ var resources = {
                 "more_info": "PLUS D'INFORMATIONS",
                 "reject": "NON, JE N'ACCEPTE PAS"
             },
+            "cog_keep_awake": {
+                "device_list_label": "Cogs concernés par ce choix",
+                "explanation": "Si vous choisissez Non ou ne répondez pas, les signaux de maintien en éveil s’arrêteront et l’arrêt automatique normal suivra.",
+                "no": "Non",
+                "no_aria_label": "Non, arrêter de maintenir Cog en éveil",
+                "question": "Aucune activité n’a été détectée. Voulez-vous laisser Cog allumé ?",
+                "question_multiple": "Aucune activité n’a été détectée. Voulez-vous laisser ces Cogs allumés ?",
+                "question_named": "Aucune activité n’a été détectée. Voulez-vous laisser {{deviceName}} allumé ?",
+                "seconds_remaining_one": "{{seconds}} seconde restante",
+                "seconds_remaining_many": "{{seconds}} secondes restantes",
+                "seconds_remaining_other": "{{seconds}} secondes restantes",
+                "title": "Laisser Cog allumé ?",
+                "yes": "Oui",
+                "yes_aria_label": "Oui, maintenir Cog en éveil"
+            },
             "calibration_screen": {
                 "colour_calibration": {
                     "unplugged_modal_title": "Unplugged",
@@ -2117,6 +2189,20 @@ var resources = {
                 "more_info": "WEITERE INFORMATIONEN",
                 "reject": "NEIN, ICH AKZEPTIERE NICHT"
             },
+            "cog_keep_awake": {
+                "device_list_label": "Von dieser Auswahl betroffene Cogs",
+                "explanation": "Wenn Sie Nein wählen oder nicht antworten, werden keine Wachhaltesignale mehr gesendet und die normale automatische Abschaltung erfolgt.",
+                "no": "Nein",
+                "no_aria_label": "Nein, Cog nicht länger aktiv halten",
+                "question": "Wir haben keine Aktivität erkannt. Soll Cog eingeschaltet bleiben?",
+                "question_multiple": "Wir haben keine Aktivität erkannt. Sollen diese Cogs eingeschaltet bleiben?",
+                "question_named": "Wir haben keine Aktivität erkannt. Soll {{deviceName}} eingeschaltet bleiben?",
+                "seconds_remaining_one": "Noch {{seconds}} Sekunde",
+                "seconds_remaining_other": "Noch {{seconds}} Sekunden",
+                "title": "Cog eingeschaltet lassen?",
+                "yes": "Ja",
+                "yes_aria_label": "Ja, Cog aktiv halten"
+            },
             "calibration_screen": {
                 "colour_calibration": {
                     "unplugged_modal_title": "Unplugged",
@@ -2509,6 +2595,20 @@ var resources = {
                 "more_info": "ПОВЕЧЕ ИНФОРМАЦИЯ",
                 "reject": "НЕ, НЕ ПРИЕМАМ"
             },
+            "cog_keep_awake": {
+                "device_list_label": "Cog устройства, засегнати от този избор",
+                "explanation": "Ако изберете „Не“ или не отговорите, сигналите за поддържане на Cog активно ще спрат и ще последва нормалното автоматично изключване.",
+                "no": "Не",
+                "no_aria_label": "Не, спри да поддържаш Cog активно",
+                "question": "Не открихме активност. Искате ли Cog да остане включено?",
+                "question_multiple": "Не открихме активност. Искате ли тези Cog устройства да останат включени?",
+                "question_named": "Не открихме активност. Искате ли {{deviceName}} да остане включено?",
+                "seconds_remaining_one": "Остава {{seconds}} секунда",
+                "seconds_remaining_other": "Остават {{seconds}} секунди",
+                "title": "Cog да остане включено?",
+                "yes": "Да",
+                "yes_aria_label": "Да, поддържай Cog активно"
+            },
             "calibration_screen": {
                 "colour_calibration": {
                     "unplugged_modal_title": "Unplugged",
@@ -2901,6 +3001,20 @@ var resources = {
                 "more_info": "MERE INFORMATION",
                 "reject": "NEJ, JEG ACCEPTERER IKKE"
             },
+            "cog_keep_awake": {
+                "device_list_label": "Cog-enheder, som dette valg gælder for",
+                "explanation": "Hvis du vælger Nej eller ikke svarer, stopper signalerne, der holder Cog aktiv, og den normale automatiske slukning følger.",
+                "no": "Nej",
+                "no_aria_label": "Nej, stop med at holde Cog aktiv",
+                "question": "Vi har ikke registreret nogen aktivitet. Vil du holde Cog tændt?",
+                "question_multiple": "Vi har ikke registreret nogen aktivitet. Vil du holde disse Cogs tændt?",
+                "question_named": "Vi har ikke registreret nogen aktivitet. Vil du holde {{deviceName}} tændt?",
+                "seconds_remaining_one": "{{seconds}} sekund tilbage",
+                "seconds_remaining_other": "{{seconds}} sekunder tilbage",
+                "title": "Holde Cog tændt?",
+                "yes": "Ja",
+                "yes_aria_label": "Ja, hold Cog aktiv"
+            },
             "calibration_screen": {
                 "colour_calibration": {
                     "unplugged_modal_title": "Unplugged",
@@ -3293,6 +3407,20 @@ var resources = {
                 "more_info": "MER INFORMASJON",
                 "reject": "NEI, JEG GODTAR IKKE"
             },
+            "cog_keep_awake": {
+                "device_list_label": "Cog-enheter som påvirkes av dette valget",
+                "explanation": "Hvis du velger Nei eller ikke svarer, stopper signalene som holder Cog aktiv, og den vanlige automatiske avslåingen følger.",
+                "no": "Nei",
+                "no_aria_label": "Nei, slutt å holde Cog aktiv",
+                "question": "Vi har ikke registrert noen aktivitet. Vil du la Cog være slått på?",
+                "question_multiple": "Vi har ikke registrert noen aktivitet. Vil du la disse Cogs være slått på?",
+                "question_named": "Vi har ikke registrert noen aktivitet. Vil du la {{deviceName}} være slått på?",
+                "seconds_remaining_one": "{{seconds}} sekund igjen",
+                "seconds_remaining_other": "{{seconds}} sekunder igjen",
+                "title": "La Cog være slått på?",
+                "yes": "Ja",
+                "yes_aria_label": "Ja, hold Cog aktiv"
+            },
             "calibration_screen": {
                 "colour_calibration": {
                     "unplugged_modal_title": "Unplugged",
@@ -3685,6 +3813,22 @@ var resources = {
                 "more_info": "VÍCE INFORMACÍ",
                 "reject": "NE, NEPŘIJÍMÁM"
             },
+            "cog_keep_awake": {
+                "device_list_label": "Zařízení Cog, kterých se tato volba týká",
+                "explanation": "Pokud zvolíte Ne nebo neodpovíte, signály udržující Cog aktivní se zastaví a bude následovat běžné automatické vypnutí.",
+                "no": "Ne",
+                "no_aria_label": "Ne, přestat udržovat Cog aktivní",
+                "question": "Nezaznamenali jsme žádnou aktivitu. Chcete ponechat Cog zapnutý?",
+                "question_multiple": "Nezaznamenali jsme žádnou aktivitu. Chcete ponechat tato zařízení Cog zapnutá?",
+                "question_named": "Nezaznamenali jsme žádnou aktivitu. Chcete ponechat {{deviceName}} zapnutý?",
+                "seconds_remaining_one": "Zbývá {{seconds}} sekunda",
+                "seconds_remaining_few": "Zbývají {{seconds}} sekundy",
+                "seconds_remaining_many": "Zbývá {{seconds}} sekundy",
+                "seconds_remaining_other": "Zbývá {{seconds}} sekund",
+                "title": "Ponechat Cog zapnutý?",
+                "yes": "Ano",
+                "yes_aria_label": "Ano, udržovat Cog aktivní"
+            },
             "calibration_screen": {
                 "colour_calibration": {
                     "unplugged_modal_title": "Unplugged",
@@ -4077,6 +4221,21 @@ var resources = {
                 "more_info": "MÁS INFORMACIÓN",
                 "reject": "NO, NO ACEPTO"
             },
+            "cog_keep_awake": {
+                "device_list_label": "Dispositivos Cog afectados por esta elección",
+                "explanation": "Si eliges No o no respondes, dejarán de enviarse las señales que mantienen Cog activo y se aplicará el apagado automático normal.",
+                "no": "No",
+                "no_aria_label": "No, dejar de mantener Cog activo",
+                "question": "No hemos detectado actividad. ¿Quieres mantener Cog encendido?",
+                "question_multiple": "No hemos detectado actividad. ¿Quieres mantener estos Cogs encendidos?",
+                "question_named": "No hemos detectado actividad. ¿Quieres mantener {{deviceName}} encendido?",
+                "seconds_remaining_one": "Queda {{seconds}} segundo",
+                "seconds_remaining_many": "Quedan {{seconds}} segundos",
+                "seconds_remaining_other": "Quedan {{seconds}} segundos",
+                "title": "¿Mantener Cog encendido?",
+                "yes": "Sí",
+                "yes_aria_label": "Sí, mantener Cog activo"
+            },
             "calibration_screen": {
                 "colour_calibration": {
                     "unplugged_modal_title": "Unplugged",
@@ -4469,6 +4628,20 @@ var resources = {
                 "more_info": "MER INFORMATION",
                 "reject": "NEJ, JAG ACCEPTERAR INTE"
             },
+            "cog_keep_awake": {
+                "device_list_label": "Cog-enheter som påverkas av det här valet",
+                "explanation": "Om du väljer Nej eller inte svarar slutar signalerna som håller Cog aktiv att skickas, och den vanliga automatiska avstängningen följer.",
+                "no": "Nej",
+                "no_aria_label": "Nej, sluta hålla Cog aktiv",
+                "question": "Vi har inte registrerat någon aktivitet. Vill du låta Cog vara på?",
+                "question_multiple": "Vi har inte registrerat någon aktivitet. Vill du låta dessa Cogs vara på?",
+                "question_named": "Vi har inte registrerat någon aktivitet. Vill du låta {{deviceName}} vara på?",
+                "seconds_remaining_one": "{{seconds}} sekund återstår",
+                "seconds_remaining_other": "{{seconds}} sekunder återstår",
+                "title": "Låta Cog vara på?",
+                "yes": "Ja",
+                "yes_aria_label": "Ja, håll Cog aktiv"
+            },
             "calibration_screen": {
                 "colour_calibration": {
                     "unplugged_modal_title": "Unplugged",
@@ -4861,6 +5034,20 @@ var resources = {
                 "more_info": "LISÄTIETOJA",
                 "reject": "EI, EN HYVÄKSY"
             },
+            "cog_keep_awake": {
+                "device_list_label": "Cog-laitteet, joihin tämä valinta vaikuttaa",
+                "explanation": "Jos valitset Ei tai et vastaa, Cogin aktiivisena pitävät signaalit lopetetaan ja normaali automaattinen virrankatkaisu jatkuu.",
+                "no": "Ei",
+                "no_aria_label": "Ei, lopeta Cogin pitäminen aktiivisena",
+                "question": "Toimintaa ei ole havaittu. Haluatko pitää Cogin päällä?",
+                "question_multiple": "Toimintaa ei ole havaittu. Haluatko pitää nämä Cog-laitteet päällä?",
+                "question_named": "Toimintaa ei ole havaittu. Haluatko pitää laitteen {{deviceName}} päällä?",
+                "seconds_remaining_one": "{{seconds}} sekunti jäljellä",
+                "seconds_remaining_other": "{{seconds}} sekuntia jäljellä",
+                "title": "Pidetäänkö Cog päällä?",
+                "yes": "Kyllä",
+                "yes_aria_label": "Kyllä, pidä Cog aktiivisena"
+            },
             "calibration_screen": {
                 "colour_calibration": {
                     "unplugged_modal_title": "Unplugged",
@@ -5253,6 +5440,24 @@ var resources = {
                 "more_info": "مزيد من المعلومات",
                 "reject": "لا، لا أقبل"
             },
+            "cog_keep_awake": {
+                "device_list_label": "أجهزة Cog المتأثرة بهذا الاختيار",
+                "explanation": "إذا اخترت «لا» أو لم تستجب، فسيتوقف إرسال الإشارات التي تُبقي Cog نشطًا وسيعمل إيقاف التشغيل التلقائي المعتاد.",
+                "no": "لا",
+                "no_aria_label": "لا، أوقف إبقاء Cog نشطًا",
+                "question": "لم نكتشف أي نشاط. هل تريد إبقاء Cog قيد التشغيل؟",
+                "question_multiple": "لم نكتشف أي نشاط. هل تريد إبقاء أجهزة Cog هذه قيد التشغيل؟",
+                "question_named": "لم نكتشف أي نشاط. هل تريد إبقاء {{deviceName}} قيد التشغيل؟",
+                "seconds_remaining_zero": "{{seconds}} ثانية متبقية",
+                "seconds_remaining_one": "{{seconds}} ثانية متبقية",
+                "seconds_remaining_two": "{{seconds}} ثانية متبقية",
+                "seconds_remaining_few": "{{seconds}} ثوانٍ متبقية",
+                "seconds_remaining_many": "{{seconds}} ثانية متبقية",
+                "seconds_remaining_other": "{{seconds}} ثانية متبقية",
+                "title": "هل تريد إبقاء Cog قيد التشغيل؟",
+                "yes": "نعم",
+                "yes_aria_label": "نعم، أبقِ Cog نشطًا"
+            },
             "calibration_screen": {
                 "colour_calibration": {
                     "unplugged_modal_title": "Unplugged",

package/package.json

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