@flighthq/power 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export * from './power';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,SAAS,CAAC"}

package/dist/index.js

@@ -0,0 +1,2 @@
+export * from './power';
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,SAAS,CAAC"}

package/dist/power.d.ts

@@ -0,0 +1,21 @@
+import type { Power, PowerBackend, PowerBatteryHealth, PowerIdleState, PowerKeepAwakeMode, PowerStatus, PowerThermalState } from '@flighthq/types';
+export declare function attachPower(power: Power, idleThresholdSeconds?: number): void;
+export declare function createPower(): Power;
+export declare function createPowerBatteryHealth(): PowerBatteryHealth;
+export declare function createPowerStatus(): PowerStatus;
+export declare function createWebPowerBackend(): PowerBackend;
+export declare function detachPower(power: Power): void;
+export declare function disposePower(power: Power): void;
+export declare function enablePowerSignals(): Power;
+export declare function getPowerBackend(): PowerBackend;
+export declare function getPowerBatteryHealth(out: PowerBatteryHealth): PowerBatteryHealth | null;
+export declare function getPowerIdlePollingIntervalMs(): number;
+export declare function getPowerStatus(out: PowerStatus): PowerStatus;
+export declare function getPowerSystemIdleState(thresholdSeconds: number): PowerIdleState;
+export declare function getPowerSystemIdleTime(): number;
+export declare function getPowerThermalState(): PowerThermalState;
+export declare function hasPowerKeepAwake(): boolean;
+export declare function setPowerBackend(backend: PowerBackend | null): void;
+export declare function setPowerIdlePollingIntervalMs(intervalMs: number): void;
+export declare function setPowerKeepAwake(enabled: boolean, mode?: PowerKeepAwakeMode): boolean;
+//# sourceMappingURL=power.d.ts.map

package/dist/power.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"power.d.ts","sourceRoot":"","sources":["../src/power.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,KAAK,EACL,YAAY,EACZ,kBAAkB,EAClB,cAAc,EACd,kBAAkB,EAClB,WAAW,EACX,iBAAiB,EAClB,MAAM,iBAAiB,CAAC;AASzB,wBAAgB,WAAW,CAAC,KAAK,EAAE,KAAK,EAAE,oBAAoB,SAAK,GAAG,IAAI,CA+CzE;AAGD,wBAAgB,WAAW,IAAI,KAAK,CAanC;AAGD,wBAAgB,wBAAwB,IAAI,kBAAkB,CAQ7D;AAGD,wBAAgB,iBAAiB,IAAI,WAAW,CAW/C;AAID,wBAAgB,qBAAqB,IAAI,YAAY,CA0JpD;AAGD,wBAAgB,WAAW,CAAC,KAAK,EAAE,KAAK,GAAG,IAAI,CAM9C;AAID,wBAAgB,YAAY,CAAC,KAAK,EAAE,KAAK,GAAG,IAAI,CAE/C;AAED,wBAAgB,kBAAkB,IAAI,KAAK,CAE1C;AAED,wBAAgB,eAAe,IAAI,YAAY,CAG9C;AAID,wBAAgB,qBAAqB,CAAC,GAAG,EAAE,kBAAkB,GAAG,kBAAkB,GAAG,IAAI,CAExF;AAGD,wBAAgB,6BAA6B,IAAI,MAAM,CAEtD;AAGD,wBAAgB,cAAc,CAAC,GAAG,EAAE,WAAW,GAAG,WAAW,CAE5D;AAGD,wBAAgB,uBAAuB,CAAC,gBAAgB,EAAE,MAAM,GAAG,cAAc,CAEhF;AAGD,wBAAgB,sBAAsB,IAAI,MAAM,CAE/C;AAGD,wBAAgB,oBAAoB,IAAI,iBAAiB,CAExD;AAGD,wBAAgB,iBAAiB,IAAI,OAAO,CAE3C;AAGD,wBAAgB,eAAe,CAAC,OAAO,EAAE,YAAY,GAAG,IAAI,GAAG,IAAI,CAElE;AAKD,wBAAgB,6BAA6B,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI,CAEtE;AAID,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,OAAO,EAAE,IAAI,CAAC,EAAE,kBAAkB,GAAG,OAAO,CAEtF"}

package/dist/power.js

@@ -0,0 +1,341 @@
+import { createSignal, emitSignal, hasSignalSlots } from '@flighthq/signals';
+// Begins delivering power changes to `power`'s signals by subscribing to the active backend. On each
+// change it reads a fresh status and emits onChange plus onCharging/onDischarging on charging
+// transitions. For onIdleStateChange, a polling interval is started at the rate set by
+// setPowerIdlePollingIntervalMs (default 5000ms); the poll is guarded so it only emits when at least
+// one listener is connected to onIdleStateChange. idleThresholdSeconds (default 60) controls what
+// idle state the backend reports as 'Idle' vs 'Active'. Idempotent: a prior subscription is torn
+// down first. Pair with detachPower/disposePower.
+export function attachPower(power, idleThresholdSeconds = 60) {
+    detachPower(power);
+    const backend = getPowerBackend();
+    let wasCharging = backend.getStatus(_scratch).isCharging;
+    const unsubscribeChange = backend.subscribe(() => {
+        const status = backend.getStatus(_scratch);
+        emitSignal(power.onChange, status);
+        if (status.isCharging !== wasCharging) {
+            wasCharging = status.isCharging;
+            emitSignal(status.isCharging ? power.onCharging : power.onDischarging);
+        }
+    });
+    const unsubscribeLockScreen = backend.subscribeLockScreen(() => emitSignal(power.onLockScreen));
+    const unsubscribeLowPowerModeChange = backend.subscribeLowPowerModeChange(() => emitSignal(power.onLowPowerModeChange));
+    const unsubscribeResume = backend.subscribeResume(() => emitSignal(power.onResume));
+    const unsubscribeSuspend = backend.subscribeSuspend(() => emitSignal(power.onSuspend));
+    const unsubscribeThermalStateChange = backend.subscribeThermalStateChange(() => emitSignal(power.onThermalStateChange));
+    const unsubscribeUnlockScreen = backend.subscribeUnlockScreen(() => emitSignal(power.onUnlockScreen));
+    // Idle state polling: poll at the configured interval and emit onIdleStateChange on transitions.
+    // The poll emits only when at least one slot is connected, avoiding spurious allocations when
+    // nobody is listening. The interval still runs (cheaply) so state transitions are never missed
+    // when a listener connects after attach.
+    let lastIdleState = backend.getSystemIdleState(idleThresholdSeconds);
+    const idleIntervalId = setInterval(() => {
+        if (!hasSignalSlots(power.onIdleStateChange))
+            return;
+        const current = backend.getSystemIdleState(idleThresholdSeconds);
+        if (current !== lastIdleState) {
+            lastIdleState = current;
+            emitSignal(power.onIdleStateChange);
+        }
+    }, _idlePollingIntervalMs);
+    _subscriptions.set(power, () => {
+        unsubscribeChange();
+        unsubscribeLockScreen();
+        unsubscribeLowPowerModeChange();
+        unsubscribeResume();
+        unsubscribeSuspend();
+        unsubscribeThermalStateChange();
+        unsubscribeUnlockScreen();
+        clearInterval(idleIntervalId);
+    });
+}
+// Allocates a Power event entity with inert signals; call attachPower to start delivery.
+export function createPower() {
+    return {
+        onChange: createSignal(),
+        onCharging: createSignal(),
+        onDischarging: createSignal(),
+        onIdleStateChange: createSignal(),
+        onLockScreen: createSignal(),
+        onLowPowerModeChange: createSignal(),
+        onResume: createSignal(),
+        onSuspend: createSignal(),
+        onThermalStateChange: createSignal(),
+        onUnlockScreen: createSignal(),
+    };
+}
+// Allocates a zeroed PowerBatteryHealth, suitable as the `out` for getPowerBatteryHealth.
+export function createPowerBatteryHealth() {
+    return {
+        capacityWearLevel: -1,
+        cycleCount: -1,
+        healthState: 'Unknown',
+        temperatureCelsius: -1,
+        voltage: -1,
+    };
+}
+// Allocates a zeroed PowerStatus, suitable as the `out` for getPowerStatus.
+export function createPowerStatus() {
+    return {
+        batteryLevel: -1,
+        chargingTime: -1,
+        dischargingTime: -1,
+        isBatteryLow: false,
+        isCharging: false,
+        isLowPower: false,
+        isOnBattery: false,
+        thermalState: 'Unknown',
+    };
+}
+// Builds the default web backend over the Battery Status API and the Screen Wake Lock API. Degrades
+// to batteryLevel=-1 / not charging and a no-op subscription where the APIs are absent.
+export function createWebPowerBackend() {
+    let cachedLevel = -1;
+    let cachedCharging = false;
+    let cachedChargingTime = -1;
+    let cachedDischargingTime = -1;
+    return {
+        getBatteryHealth(_out) {
+            // Browser Battery Status API does not expose health information.
+            return null;
+        },
+        isKeepAwakeActive() {
+            return _wakeLockSentinel !== null;
+        },
+        getStatus(out) {
+            // Read all input values first (alias-safe: out may be the same object as an input).
+            const level = cachedLevel;
+            const charging = cachedCharging;
+            const chargingTime = cachedChargingTime;
+            const dischargingTime = cachedDischargingTime;
+            out.batteryLevel = level;
+            out.chargingTime = chargingTime;
+            out.dischargingTime = dischargingTime;
+            out.isBatteryLow = level >= 0 && level <= 0.2 && !charging;
+            out.isCharging = charging;
+            // Web Battery Status API: isOnBattery = device has a battery and is not charging/AC.
+            // If level is -1 (API absent), we cannot determine the power source; use false as sentinel.
+            out.isOnBattery = level >= 0 && !charging;
+            // No real OS low-power-mode read available on web; use false as sentinel.
+            out.isLowPower = false;
+            out.thermalState = 'Unknown';
+            return out;
+        },
+        getSystemIdleState(_thresholdSeconds) {
+            // The Idle Detection API is permission-gated and not widely available; return sentinel.
+            return 'Unknown';
+        },
+        getSystemIdleTime() {
+            // No idle-time API available on web; return sentinel.
+            return -1;
+        },
+        setKeepAwake(enabled, mode) {
+            const resolvedMode = mode ?? 'PreventDisplaySleep';
+            // Web only supports display-sleep prevention via the Screen Wake Lock API.
+            if (resolvedMode === 'PreventAppSuspension')
+                return false;
+            if (typeof navigator === 'undefined')
+                return false;
+            const wakeLock = navigator.wakeLock;
+            if (wakeLock === undefined)
+                return false;
+            try {
+                if (!enabled) {
+                    _wakeLockSentinel?.release?.().catch(() => { });
+                    _wakeLockSentinel = null;
+                    return true;
+                }
+                wakeLock
+                    .request('screen')
+                    .then((sentinel) => {
+                    _wakeLockSentinel = sentinel;
+                    // Re-acquire the lock after visibility is restored; browsers auto-release it when the
+                    // tab goes hidden.
+                    sentinel.addEventListener?.('release', () => {
+                        if (_wakeLockSentinel === sentinel && !document.hidden) {
+                            wakeLock
+                                .request('screen')
+                                .then((newSentinel) => {
+                                if (_wakeLockSentinel === sentinel)
+                                    _wakeLockSentinel = newSentinel;
+                            })
+                                .catch(() => { });
+                        }
+                    });
+                })
+                    .catch(() => { });
+                return true;
+            }
+            catch {
+                return false;
+            }
+        },
+        subscribe(listener) {
+            const battery = getWebBatteryManagerPromise();
+            if (battery === null)
+                return () => { };
+            let manager = null;
+            const onLevelChange = () => {
+                if (manager !== null)
+                    cachedLevel = manager.level;
+                listener();
+            };
+            const onChargingChange = () => {
+                if (manager !== null)
+                    cachedCharging = manager.charging;
+                listener();
+            };
+            const onChargingTimeChange = () => {
+                if (manager !== null) {
+                    const t = manager.chargingTime;
+                    cachedChargingTime = t === Infinity ? -1 : t;
+                }
+                listener();
+            };
+            const onDischargingTimeChange = () => {
+                if (manager !== null) {
+                    const t = manager.dischargingTime;
+                    cachedDischargingTime = t === Infinity ? -1 : t;
+                }
+                listener();
+            };
+            let cancelled = false;
+            battery
+                .then((m) => {
+                if (cancelled)
+                    return;
+                manager = m;
+                cachedLevel = m.level;
+                cachedCharging = m.charging;
+                cachedChargingTime = m.chargingTime === Infinity ? -1 : m.chargingTime;
+                cachedDischargingTime = m.dischargingTime === Infinity ? -1 : m.dischargingTime;
+                m.addEventListener?.('levelchange', onLevelChange);
+                m.addEventListener?.('chargingchange', onChargingChange);
+                m.addEventListener?.('chargingtimechange', onChargingTimeChange);
+                m.addEventListener?.('dischargingtimechange', onDischargingTimeChange);
+                listener();
+            })
+                .catch(() => { });
+            return () => {
+                cancelled = true;
+                manager?.removeEventListener?.('levelchange', onLevelChange);
+                manager?.removeEventListener?.('chargingchange', onChargingChange);
+                manager?.removeEventListener?.('chargingtimechange', onChargingTimeChange);
+                manager?.removeEventListener?.('dischargingtimechange', onDischargingTimeChange);
+                manager = null;
+            };
+        },
+        subscribeLockScreen() {
+            // The Web Platform has no lock-screen API; only native hosts can detect screen lock.
+            return () => { };
+        },
+        subscribeLowPowerModeChange() {
+            // No OS low-power-mode API available on web; return a no-op unsubscriber.
+            return () => { };
+        },
+        subscribeResume(listener) {
+            if (typeof document === 'undefined')
+                return () => { };
+            document.addEventListener('resume', listener);
+            return () => document.removeEventListener('resume', listener);
+        },
+        subscribeSuspend(listener) {
+            if (typeof document === 'undefined')
+                return () => { };
+            document.addEventListener('freeze', listener);
+            return () => document.removeEventListener('freeze', listener);
+        },
+        subscribeThermalStateChange() {
+            // No thermal state API available on web; return a no-op unsubscriber.
+            return () => { };
+        },
+        subscribeUnlockScreen() {
+            // The Web Platform has no unlock-screen API; only native hosts can detect screen unlock.
+            return () => { };
+        },
+    };
+}
+// Stops delivery to `power` and forgets its subscription. Safe to call when not attached.
+export function detachPower(power) {
+    const unsubscribe = _subscriptions.get(power);
+    if (unsubscribe !== undefined) {
+        unsubscribe();
+        _subscriptions.delete(power);
+    }
+}
+// Releases `power` for garbage collection by detaching its backend subscription. The signals remain
+// plain GC-managed memory afterward.
+export function disposePower(power) {
+    detachPower(power);
+}
+export function enablePowerSignals() {
+    return createPower();
+}
+export function getPowerBackend() {
+    if (_backend === null)
+        _backend = createWebPowerBackend();
+    return _backend;
+}
+// Returns the battery health detail from the active backend, writing into `out` and returning it,
+// or returns null when the active backend does not support battery health reporting.
+export function getPowerBatteryHealth(out) {
+    return getPowerBackend().getBatteryHealth(out);
+}
+// Returns the current idle-state polling interval in milliseconds (default 5000).
+export function getPowerIdlePollingIntervalMs() {
+    return _idlePollingIntervalMs;
+}
+// Fills `out` with the current power snapshot and returns it.
+export function getPowerStatus(out) {
+    return getPowerBackend().getStatus(out);
+}
+// Returns the current system idle state at the given threshold in seconds.
+export function getPowerSystemIdleState(thresholdSeconds) {
+    return getPowerBackend().getSystemIdleState(thresholdSeconds);
+}
+// Returns the elapsed seconds since the last user input event, or -1 when unsupported.
+export function getPowerSystemIdleTime() {
+    return getPowerBackend().getSystemIdleTime();
+}
+// Returns the current thermal state from the active backend.
+export function getPowerThermalState() {
+    return getPowerBackend().getStatus(_scratch).thermalState;
+}
+// Returns true when a keep-awake lock is currently held by the active backend.
+export function hasPowerKeepAwake() {
+    return getPowerBackend().isKeepAwakeActive();
+}
+// Installs a native host power backend; pass null to fall back to the web default.
+export function setPowerBackend(backend) {
+    _backend = backend;
+}
+// Sets the interval at which attachPower polls the backend for idle state changes. The default is
+// 5000ms (5 seconds); set lower for more responsive idle detection at the cost of more frequent
+// backend calls. Only affects Power entities attached after this call.
+export function setPowerIdlePollingIntervalMs(intervalMs) {
+    _idlePollingIntervalMs = intervalMs;
+}
+// Requests or releases a keep-awake lock for the given mode; returns whether honored.
+// mode defaults to 'PreventDisplaySleep'.
+export function setPowerKeepAwake(enabled, mode) {
+    return getPowerBackend().setKeepAwake(enabled, mode);
+}
+let _backend = null;
+let _idlePollingIntervalMs = 5000;
+let _wakeLockSentinel = null;
+const _scratch = createPowerStatus();
+const _subscriptions = new WeakMap();
+function getWebBatteryManagerPromise() {
+    if (typeof navigator === 'undefined')
+        return null;
+    const nav = navigator;
+    if (typeof nav.getBattery !== 'function')
+        return null;
+    try {
+        return nav.getBattery();
+    }
+    catch {
+        return null;
+    }
+}
+//# sourceMappingURL=power.js.map

package/dist/power.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"power.js","sourceRoot":"","sources":["../src/power.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "@flighthq/power",
+  "version": "0.1.0",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "src/**/*.test.ts",
+    "!dist/**/*.test.js",
+    "!dist/**/*.test.d.ts",
+    "!dist/**/*.test.js.map",
+    "!dist/**/*.test.d.ts.map"
+  ],
+  "scripts": {
+    "build": "tsc -b",
+    "clean": "tsc -b --clean",
+    "test": "vitest run --config vitest.config.ts",
+    "test:watch": "vitest --watch --config vitest.config.ts",
+    "prepack": "npm run clean && npm run clean:dist && npm run build",
+    "clean:dist": "tsx ../../scripts/clean-package-dist.ts"
+  },
+  "dependencies": {
+    "@flighthq/signals": "0.1.0",
+    "@flighthq/types": "0.1.0"
+  },
+  "devDependencies": {
+    "typescript": "^5.3.0"
+  },
+  "description": "Battery level, charging state, low-power signals and screen keep-awake over a swappable web/native backend",
+  "sideEffects": false
+}

package/src/power.test.ts

@@ -0,0 +1,583 @@
+import { connectSignal } from '@flighthq/signals';
+import type { PowerBackend, PowerBatteryHealth, PowerStatus } from '@flighthq/types';
+
+import {
+  attachPower,
+  createPower,
+  createPowerBatteryHealth,
+  createPowerStatus,
+  createWebPowerBackend,
+  detachPower,
+  disposePower,
+  enablePowerSignals,
+  getPowerBackend,
+  getPowerBatteryHealth,
+  getPowerIdlePollingIntervalMs,
+  getPowerStatus,
+  getPowerSystemIdleState,
+  getPowerSystemIdleTime,
+  getPowerThermalState,
+  hasPowerKeepAwake,
+  setPowerBackend,
+  setPowerIdlePollingIntervalMs,
+  setPowerKeepAwake,
+} from './power';
+
+function fakeBackend(): PowerBackend & {
+  charging: boolean;
+  keepAwake: boolean;
+  fire: () => void;
+  fireLockScreen: () => void;
+  fireLowPowerModeChange: () => void;
+  fireResume: () => void;
+  fireSuspend: () => void;
+  fireThermalStateChange: () => void;
+  fireUnlockScreen: () => void;
+} {
+  let listener: (() => void) | null = null;
+  let lockListener: (() => void) | null = null;
+  let lowPowerModeListener: (() => void) | null = null;
+  let resumeListener: (() => void) | null = null;
+  let suspendListener: (() => void) | null = null;
+  let thermalListener: (() => void) | null = null;
+  let unlockListener: (() => void) | null = null;
+  return {
+    charging: false,
+    keepAwake: false,
+    getBatteryHealth(_out) {
+      return null;
+    },
+    isKeepAwakeActive() {
+      return this.keepAwake;
+    },
+    getStatus(out) {
+      out.batteryLevel = 0.5;
+      out.chargingTime = -1;
+      out.dischargingTime = 3600;
+      out.isBatteryLow = false;
+      out.isCharging = this.charging;
+      out.isLowPower = false;
+      out.isOnBattery = !this.charging;
+      out.thermalState = 'Nominal';
+      return out;
+    },
+    getSystemIdleState(_threshold) {
+      return 'Active';
+    },
+    getSystemIdleTime() {
+      return 42;
+    },
+    setKeepAwake(enabled) {
+      this.keepAwake = enabled;
+      return true;
+    },
+    subscribe(l) {
+      listener = l;
+      return () => {
+        listener = null;
+      };
+    },
+    subscribeLockScreen(l) {
+      lockListener = l;
+      return () => {
+        lockListener = null;
+      };
+    },
+    subscribeLowPowerModeChange(l) {
+      lowPowerModeListener = l;
+      return () => {
+        lowPowerModeListener = null;
+      };
+    },
+    subscribeResume(l) {
+      resumeListener = l;
+      return () => {
+        resumeListener = null;
+      };
+    },
+    subscribeSuspend(l) {
+      suspendListener = l;
+      return () => {
+        suspendListener = null;
+      };
+    },
+    subscribeThermalStateChange(l) {
+      thermalListener = l;
+      return () => {
+        thermalListener = null;
+      };
+    },
+    subscribeUnlockScreen(l) {
+      unlockListener = l;
+      return () => {
+        unlockListener = null;
+      };
+    },
+    fire() {
+      listener?.();
+    },
+    fireLockScreen() {
+      lockListener?.();
+    },
+    fireLowPowerModeChange() {
+      lowPowerModeListener?.();
+    },
+    fireResume() {
+      resumeListener?.();
+    },
+    fireSuspend() {
+      suspendListener?.();
+    },
+    fireThermalStateChange() {
+      thermalListener?.();
+    },
+    fireUnlockScreen() {
+      unlockListener?.();
+    },
+  };
+}
+
+afterEach(() => setPowerBackend(null));
+
+describe('attachPower', () => {
+  it('emits onChange and the charging transition signals', () => {
+    const backend = fakeBackend();
+    setPowerBackend(backend);
+    const power = createPower();
+    let changes = 0;
+    let charging = 0;
+    connectSignal(power.onChange, () => changes++);
+    connectSignal(power.onCharging, () => charging++);
+    attachPower(power);
+    backend.charging = true;
+    backend.fire();
+    expect(changes).toBe(1);
+    expect(charging).toBe(1);
+  });
+
+  it('emits onSuspend and onResume when the backend fires them', () => {
+    const backend = fakeBackend();
+    setPowerBackend(backend);
+    const power = createPower();
+    let suspends = 0;
+    let resumes = 0;
+    connectSignal(power.onSuspend, () => suspends++);
+    connectSignal(power.onResume, () => resumes++);
+    attachPower(power);
+    backend.fireSuspend();
+    backend.fireResume();
+    expect(suspends).toBe(1);
+    expect(resumes).toBe(1);
+  });
+
+  it('emits onLockScreen and onUnlockScreen when the backend fires them', () => {
+    const backend = fakeBackend();
+    setPowerBackend(backend);
+    const power = createPower();
+    let locks = 0;
+    let unlocks = 0;
+    connectSignal(power.onLockScreen, () => locks++);
+    connectSignal(power.onUnlockScreen, () => unlocks++);
+    attachPower(power);
+    backend.fireLockScreen();
+    backend.fireUnlockScreen();
+    expect(locks).toBe(1);
+    expect(unlocks).toBe(1);
+  });
+
+  it('emits onLowPowerModeChange when the backend fires it', () => {
+    const backend = fakeBackend();
+    setPowerBackend(backend);
+    const power = createPower();
+    let lowPowerChanges = 0;
+    connectSignal(power.onLowPowerModeChange, () => lowPowerChanges++);
+    attachPower(power);
+    backend.fireLowPowerModeChange();
+    expect(lowPowerChanges).toBe(1);
+  });
+
+  it('emits onThermalStateChange when the backend fires it', () => {
+    const backend = fakeBackend();
+    setPowerBackend(backend);
+    const power = createPower();
+    let thermalChanges = 0;
+    connectSignal(power.onThermalStateChange, () => thermalChanges++);
+    attachPower(power);
+    backend.fireThermalStateChange();
+    expect(thermalChanges).toBe(1);
+  });
+
+  it('is idempotent — a second attach tears down the first subscription', () => {
+    const backend = fakeBackend();
+    setPowerBackend(backend);
+    const power = createPower();
+    let changes = 0;
+    connectSignal(power.onChange, () => changes++);
+    attachPower(power);
+    attachPower(power);
+    backend.fire();
+    expect(changes).toBe(1);
+  });
+
+  it('polls onIdleStateChange when a listener is connected and state transitions', () => {
+    vi.useFakeTimers();
+    let idleState = 'Active';
+    const backend = fakeBackend();
+    backend.getSystemIdleState = () => idleState as ReturnType<typeof backend.getSystemIdleState>;
+    setPowerBackend(backend);
+    const power = createPower();
+    let idleChanges = 0;
+    connectSignal(power.onIdleStateChange, () => idleChanges++);
+    setPowerIdlePollingIntervalMs(100);
+    attachPower(power, 30);
+    // Change state and advance timer.
+    idleState = 'Idle';
+    vi.advanceTimersByTime(200);
+    expect(idleChanges).toBeGreaterThanOrEqual(1);
+    disposePower(power);
+    vi.useRealTimers();
+    // Restore default interval.
+    setPowerIdlePollingIntervalMs(5000);
+  });
+
+  it('does not emit onIdleStateChange when no listener is connected', () => {
+    vi.useFakeTimers();
+    let idleState = 'Active';
+    const backend = fakeBackend();
+    backend.getSystemIdleState = () => idleState as ReturnType<typeof backend.getSystemIdleState>;
+    setPowerBackend(backend);
+    const power = createPower();
+    // No listener connected.
+    setPowerIdlePollingIntervalMs(100);
+    attachPower(power, 30);
+    idleState = 'Idle';
+    vi.advanceTimersByTime(200);
+    // No signal has slots so no emission, no error.
+    expect(power.onIdleStateChange.data).toBeNull();
+    disposePower(power);
+    vi.useRealTimers();
+    setPowerIdlePollingIntervalMs(5000);
+  });
+
+  it('stops the idle polling interval after detach', () => {
+    vi.useFakeTimers();
+    let idleState = 'Active';
+    let pollCount = 0;
+    const backend = fakeBackend();
+    backend.getSystemIdleState = () => {
+      pollCount++;
+      return idleState as ReturnType<typeof backend.getSystemIdleState>;
+    };
+    setPowerBackend(backend);
+    const power = createPower();
+    connectSignal(power.onIdleStateChange, () => {});
+    setPowerIdlePollingIntervalMs(100);
+    attachPower(power, 30);
+    vi.advanceTimersByTime(150);
+    const countAfterAttach = pollCount;
+    detachPower(power);
+    idleState = 'Idle';
+    vi.advanceTimersByTime(300);
+    // Polling must stop after detach: poll count should not grow after detach.
+    expect(pollCount).toBe(countAfterAttach);
+    vi.useRealTimers();
+    setPowerIdlePollingIntervalMs(5000);
+  });
+});
+
+describe('createPower', () => {
+  it('creates an entity with all signals defined', () => {
+    const power = createPower();
+    expect(power.onChange).toBeDefined();
+    expect(power.onCharging).toBeDefined();
+    expect(power.onDischarging).toBeDefined();
+    expect(power.onIdleStateChange).toBeDefined();
+    expect(power.onLockScreen).toBeDefined();
+    expect(power.onLowPowerModeChange).toBeDefined();
+    expect(power.onResume).toBeDefined();
+    expect(power.onSuspend).toBeDefined();
+    expect(power.onThermalStateChange).toBeDefined();
+    expect(power.onUnlockScreen).toBeDefined();
+  });
+});
+
+describe('createPowerBatteryHealth', () => {
+  it('allocates a zeroed battery health with all sentinel values', () => {
+    const health = createPowerBatteryHealth();
+    expect(health.capacityWearLevel).toBe(-1);
+    expect(health.cycleCount).toBe(-1);
+    expect(health.healthState).toBe('Unknown');
+    expect(health.temperatureCelsius).toBe(-1);
+    expect(health.voltage).toBe(-1);
+  });
+});
+
+describe('createPowerStatus', () => {
+  it('allocates a zeroed status', () => {
+    const status = createPowerStatus();
+    expect(status.batteryLevel).toBe(-1);
+    expect(status.chargingTime).toBe(-1);
+    expect(status.dischargingTime).toBe(-1);
+    expect(status.isBatteryLow).toBe(false);
+    expect(status.isCharging).toBe(false);
+    expect(status.isLowPower).toBe(false);
+    expect(status.isOnBattery).toBe(false);
+    expect(status.thermalState).toBe('Unknown');
+  });
+});
+
+describe('createWebPowerBackend', () => {
+  it('isKeepAwakeActive returns false when no lock is held', () => {
+    expect(createWebPowerBackend().isKeepAwakeActive()).toBe(false);
+  });
+
+  it('reads a status without throwing', () => {
+    const out = createPowerStatus();
+    expect(typeof createWebPowerBackend().getStatus(out).isCharging).toBe('boolean');
+  });
+
+  it('getStatus is alias-safe when out is the scratch object', () => {
+    const backend = createWebPowerBackend();
+    const out = createPowerStatus();
+    const result = backend.getStatus(out);
+    expect(result).toBe(out);
+  });
+
+  it('getBatteryHealth returns null on web', () => {
+    const backend = createWebPowerBackend();
+    const out = createPowerBatteryHealth();
+    expect(backend.getBatteryHealth(out)).toBeNull();
+  });
+
+  it('getSystemIdleTime returns -1 on web', () => {
+    expect(createWebPowerBackend().getSystemIdleTime()).toBe(-1);
+  });
+
+  it('getSystemIdleState returns Unknown on web', () => {
+    expect(createWebPowerBackend().getSystemIdleState(5)).toBe('Unknown');
+  });
+
+  it('subscribeLockScreen and subscribeUnlockScreen return inert no-ops on the web', () => {
+    const backend = createWebPowerBackend();
+    expect(() => backend.subscribeLockScreen(() => {})()).not.toThrow();
+    expect(() => backend.subscribeUnlockScreen(() => {})()).not.toThrow();
+  });
+
+  it('subscribeLowPowerModeChange returns an inert no-op on the web', () => {
+    const backend = createWebPowerBackend();
+    expect(() => backend.subscribeLowPowerModeChange(() => {})()).not.toThrow();
+  });
+
+  it('subscribeThermalStateChange returns an inert no-op on the web', () => {
+    const backend = createWebPowerBackend();
+    expect(() => backend.subscribeThermalStateChange(() => {})()).not.toThrow();
+  });
+
+  it('subscribes without throwing when battery API is absent', () => {
+    const unsubscribe = createWebPowerBackend().subscribe(() => {});
+    expect(() => unsubscribe()).not.toThrow();
+  });
+
+  it('toggles keep-awake without throwing', () => {
+    expect(typeof createWebPowerBackend().setKeepAwake(true)).toBe('boolean');
+  });
+
+  it('setKeepAwake returns false for PreventAppSuspension mode (web unsupported)', () => {
+    expect(createWebPowerBackend().setKeepAwake(true, 'PreventAppSuspension')).toBe(false);
+  });
+
+  it('setKeepAwake honors PreventDisplaySleep mode (web default path)', () => {
+    // Web may not have wakeLock, but should not throw.
+    expect(() => createWebPowerBackend().setKeepAwake(true, 'PreventDisplaySleep')).not.toThrow();
+  });
+});
+
+describe('detachPower', () => {
+  it('stops further delivery', () => {
+    const backend = fakeBackend();
+    setPowerBackend(backend);
+    const power = createPower();
+    let changes = 0;
+    connectSignal(power.onChange, () => changes++);
+    attachPower(power);
+    detachPower(power);
+    backend.fire();
+    expect(changes).toBe(0);
+  });
+
+  it('is safe when called on an unattached power entity', () => {
+    const power = createPower();
+    expect(() => detachPower(power)).not.toThrow();
+  });
+});
+
+describe('disposePower', () => {
+  it('detaches the subscription', () => {
+    const backend = fakeBackend();
+    setPowerBackend(backend);
+    const power = createPower();
+    attachPower(power);
+    expect(() => disposePower(power)).not.toThrow();
+  });
+
+  it('is idempotent', () => {
+    const power = createPower();
+    expect(() => {
+      disposePower(power);
+      disposePower(power);
+    }).not.toThrow();
+  });
+});
+
+describe('enablePowerSignals', () => {
+  it('returns a Power entity with all signals defined', () => {
+    const power = enablePowerSignals();
+    expect(power.onChange).toBeDefined();
+    expect(power.onCharging).toBeDefined();
+    expect(power.onDischarging).toBeDefined();
+    expect(power.onIdleStateChange).toBeDefined();
+    expect(power.onLockScreen).toBeDefined();
+    expect(power.onLowPowerModeChange).toBeDefined();
+    expect(power.onResume).toBeDefined();
+    expect(power.onSuspend).toBeDefined();
+    expect(power.onThermalStateChange).toBeDefined();
+    expect(power.onUnlockScreen).toBeDefined();
+  });
+});
+
+describe('getPowerBackend', () => {
+  it('falls back to a web backend', () => {
+    expect(getPowerBackend()).not.toBeNull();
+  });
+});
+
+describe('getPowerBatteryHealth', () => {
+  it('returns null from the default web backend', () => {
+    const out = createPowerBatteryHealth();
+    expect(getPowerBatteryHealth(out)).toBeNull();
+  });
+
+  it('returns the out object from a backend that supports health', () => {
+    const health: PowerBatteryHealth = {
+      capacityWearLevel: 0.9,
+      cycleCount: 120,
+      healthState: 'Good',
+      temperatureCelsius: 30,
+      voltage: 12.1,
+    };
+    setPowerBackend({
+      ...fakeBackend(),
+      getBatteryHealth(out) {
+        out.capacityWearLevel = health.capacityWearLevel;
+        out.cycleCount = health.cycleCount;
+        out.healthState = health.healthState;
+        out.temperatureCelsius = health.temperatureCelsius;
+        out.voltage = health.voltage;
+        return out;
+      },
+    });
+    const out = createPowerBatteryHealth();
+    expect(getPowerBatteryHealth(out)).toBe(out);
+    expect(out.healthState).toBe('Good');
+    expect(out.cycleCount).toBe(120);
+  });
+});
+
+describe('getPowerIdlePollingIntervalMs', () => {
+  it('returns the default 5000ms interval', () => {
+    expect(getPowerIdlePollingIntervalMs()).toBe(5000);
+  });
+});
+
+describe('getPowerStatus', () => {
+  it('fills the out parameter from the backend', () => {
+    setPowerBackend(fakeBackend());
+    const out = createPowerStatus();
+    expect(getPowerStatus(out)).toBe(out);
+    expect(out.batteryLevel).toBe(0.5);
+  });
+
+  it('fills new fields from the backend', () => {
+    setPowerBackend(fakeBackend());
+    const out = createPowerStatus();
+    getPowerStatus(out);
+    expect(out.dischargingTime).toBe(3600);
+    expect(out.isOnBattery).toBe(true);
+    expect(out.thermalState).toBe('Nominal');
+  });
+});
+
+describe('getPowerSystemIdleState', () => {
+  it('delegates to the backend', () => {
+    setPowerBackend(fakeBackend());
+    expect(getPowerSystemIdleState(30)).toBe('Active');
+  });
+});
+
+describe('getPowerSystemIdleTime', () => {
+  it('delegates to the backend', () => {
+    setPowerBackend(fakeBackend());
+    expect(getPowerSystemIdleTime()).toBe(42);
+  });
+});
+
+describe('getPowerThermalState', () => {
+  it('returns the thermal state from the backend', () => {
+    setPowerBackend(fakeBackend());
+    expect(getPowerThermalState()).toBe('Nominal');
+  });
+});
+
+describe('hasPowerKeepAwake', () => {
+  it('returns false when no lock is held by the web backend', () => {
+    expect(hasPowerKeepAwake()).toBe(false);
+  });
+
+  it('delegates to the active backend isKeepAwakeActive', () => {
+    const backend = fakeBackend();
+    setPowerBackend(backend);
+    backend.keepAwake = false;
+    expect(hasPowerKeepAwake()).toBe(false);
+    backend.keepAwake = true;
+    expect(hasPowerKeepAwake()).toBe(true);
+  });
+});
+
+describe('setPowerBackend', () => {
+  it('clears back to the web fallback when passed null', () => {
+    setPowerBackend(fakeBackend());
+    setPowerBackend(null);
+    expect(getPowerBackend()).not.toBeNull();
+  });
+});
+
+describe('setPowerIdlePollingIntervalMs', () => {
+  it('updates the polling interval returned by getPowerIdlePollingIntervalMs', () => {
+    setPowerIdlePollingIntervalMs(1000);
+    expect(getPowerIdlePollingIntervalMs()).toBe(1000);
+    // Restore default.
+    setPowerIdlePollingIntervalMs(5000);
+  });
+});
+
+describe('setPowerKeepAwake', () => {
+  it('delegates to the backend and returns its result', () => {
+    const backend = fakeBackend();
+    setPowerBackend(backend);
+    expect(setPowerKeepAwake(true)).toBe(true);
+    expect(backend.keepAwake).toBe(true);
+  });
+
+  it('passes the mode to the backend', () => {
+    let capturedMode: string | undefined;
+    const backend = fakeBackend();
+    const originalSetKeepAwake = backend.setKeepAwake.bind(backend);
+    backend.setKeepAwake = (enabled, mode) => {
+      capturedMode = mode;
+      return originalSetKeepAwake(enabled, mode);
+    };
+    setPowerBackend(backend);
+    setPowerKeepAwake(true, 'PreventDisplaySleep');
+    expect(capturedMode).toBe('PreventDisplaySleep');
+  });
+});