@flighthq/power 0.5.0-next.1944.cd6b6e7 → 0.5.1-edge.638.d4dbd4e

package/README.md

@@ -13,5 +13,5 @@ Import the supported application-facing API from `@flighthq/power`. The `@flight
 This package is part of the locked-version Flight SDK graph. Applications may instead install and import `@flighthq/sdk` when package-level tree shaking is sufficient.
 
 - [Flight project](https://github.com/flighthq/flight)
-- [Source for @flighthq/power@0.5.0-next.1944.cd6b6e7](https://github.com/flighthq/flight/tree/cd6b6e71eb472b3a4249830a7743333f019fa7b7/packages/power)
-- [License](https://github.com/flighthq/flight/blob/cd6b6e71eb472b3a4249830a7743333f019fa7b7/LICENSE.md)
+- [Source for @flighthq/power@0.5.1-edge.638.d4dbd4e](https://github.com/flighthq/flight/tree/d4dbd4e347dc8be10b180c85a766ab50333dcb51/packages/power)
+- [License](https://github.com/flighthq/flight/blob/d4dbd4e347dc8be10b180c85a766ab50333dcb51/LICENSE.md)

package/dist/index.d.ts

@@ -1,2 +1,2 @@
-export { attachPower, createPower, detachPower, disposePower, enablePowerSignals, explainPowerBackend, getPowerBatteryHealth, getPowerIdlePollingIntervalMs, getPowerStatus, getPowerSystemIdleState, getPowerSystemIdleTime, getPowerThermalState, hasPowerKeepAwake, setPowerIdlePollingIntervalMs, setPowerKeepAwake, } from './contract';
+export { acquirePowerKeepAwake, attachPower, createPower, destroyPowerKeepAwake, detachPower, disposePower, enablePowerSignals, getPowerBatteryHealth, getPowerIdlePollingIntervalMs, getPowerStatus, getPowerSystemIdleState, getPowerSystemIdleTime, getPowerThermalState, isPowerKeepAwakeActive, makePowerBatteryHealth, makePowerStatus, releasePowerKeepAwake, setPowerIdlePollingIntervalMs, } from './contract';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,WAAW,EACX,WAAW,EACX,WAAW,EACX,YAAY,EACZ,kBAAkB,EAClB,mBAAmB,EACnB,qBAAqB,EACrB,6BAA6B,EAC7B,cAAc,EACd,uBAAuB,EACvB,sBAAsB,EACtB,oBAAoB,EACpB,iBAAiB,EACjB,6BAA6B,EAC7B,iBAAiB,GAClB,MAAM,YAAY,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,qBAAqB,EACrB,WAAW,EACX,WAAW,EACX,qBAAqB,EACrB,WAAW,EACX,YAAY,EACZ,kBAAkB,EAClB,qBAAqB,EACrB,6BAA6B,EAC7B,cAAc,EACd,uBAAuB,EACvB,sBAAsB,EACtB,oBAAoB,EACpB,sBAAsB,EACtB,sBAAsB,EACtB,eAAe,EACf,qBAAqB,EACrB,6BAA6B,GAC9B,MAAM,YAAY,CAAC"}

package/dist/index.js

@@ -1,2 +1,2 @@
-export { attachPower, createPower, detachPower, disposePower, enablePowerSignals, explainPowerBackend, getPowerBatteryHealth, getPowerIdlePollingIntervalMs, getPowerStatus, getPowerSystemIdleState, getPowerSystemIdleTime, getPowerThermalState, hasPowerKeepAwake, setPowerIdlePollingIntervalMs, setPowerKeepAwake, } from './contract';
+export { acquirePowerKeepAwake, attachPower, createPower, destroyPowerKeepAwake, detachPower, disposePower, enablePowerSignals, getPowerBatteryHealth, getPowerIdlePollingIntervalMs, getPowerStatus, getPowerSystemIdleState, getPowerSystemIdleTime, getPowerThermalState, isPowerKeepAwakeActive, makePowerBatteryHealth, makePowerStatus, releasePowerKeepAwake, setPowerIdlePollingIntervalMs, } from './contract';
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,WAAW,EACX,WAAW,EACX,WAAW,EACX,YAAY,EACZ,kBAAkB,EAClB,mBAAmB,EACnB,qBAAqB,EACrB,6BAA6B,EAC7B,cAAc,EACd,uBAAuB,EACvB,sBAAsB,EACtB,oBAAoB,EACpB,iBAAiB,EACjB,6BAA6B,EAC7B,iBAAiB,GAClB,MAAM,YAAY,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,qBAAqB,EACrB,WAAW,EACX,WAAW,EACX,qBAAqB,EACrB,WAAW,EACX,YAAY,EACZ,kBAAkB,EAClB,qBAAqB,EACrB,6BAA6B,EAC7B,cAAc,EACd,uBAAuB,EACvB,sBAAsB,EACtB,oBAAoB,EACpB,sBAAsB,EACtB,sBAAsB,EACtB,eAAe,EACf,qBAAqB,EACrB,6BAA6B,GAC9B,MAAM,YAAY,CAAC"}

package/dist/power.d.ts

@@ -1,25 +1,26 @@
-import type { BackendExplanation } from '@flighthq/types/contract';
-import type { Power, PowerBackend, PowerBatteryHealth, PowerIdleState, PowerKeepAwakeMode, PowerStatus, PowerThermalState } from '@flighthq/types/contract';
-export declare function attachPower(power: Power, idleThresholdSeconds?: number): void;
+import type { HasPowerIdle, HasPowerKeepAwake, HasPowerStatus, HasPowerThermal, PowerAttachHost, Power, PowerBatteryHealth, PowerIdleState, PowerKeepAwakeAcquireResult, PowerKeepAwakeMode, PowerKeepAwakeReleaseResult, PowerStatus, PowerThermalState } from '@flighthq/types/contract';
+export declare function acquirePowerKeepAwake(host: HasPowerKeepAwake, mode?: PowerKeepAwakeMode): Promise<PowerKeepAwakeAcquireResult>;
+export declare function attachPower(host: PowerAttachHost, power: Power, idleThresholdSeconds?: number): void;
 export declare function createPower(): Power;
-export declare function createPowerBatteryHealth(): PowerBatteryHealth;
-export declare function createPowerStatus(): PowerStatus;
+export declare function destroyPowerKeepAwake(...hosts: readonly HasPowerKeepAwake[]): void;
 export declare function detachPower(power: Power): void;
 export declare function disposePower(power: Power): void;
 export declare function enablePowerSignals(power: Power): void;
-export declare function explainPowerBackend(): BackendExplanation;
-export declare function getPowerBackend(): PowerBackend;
-export declare function getPowerBatteryHealth(out: PowerBatteryHealth): PowerBatteryHealth | null;
+export declare function getPowerBatteryHealth(host: {
+    readonly power: {
+        readonly batteryHealth: {
+            getBatteryHealth(out: PowerBatteryHealth): PowerBatteryHealth;
+        };
+    };
+}, out: PowerBatteryHealth): PowerBatteryHealth;
 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 installPowerHostBackend(backend: PowerBackend): void;
-export declare function observePowerHostResult(operation: string, succeeded: boolean): void;
-export declare function resetPowerBackendForTest(): void;
-export declare function setPowerBackend(backend: PowerBackend | null): void;
+export declare function getPowerStatus(host: HasPowerStatus, out: PowerStatus): PowerStatus;
+export declare function getPowerSystemIdleState(host: HasPowerIdle, thresholdSeconds: number): PowerIdleState;
+export declare function getPowerSystemIdleTime(host: HasPowerIdle): number;
+export declare function getPowerThermalState(host: HasPowerThermal): PowerThermalState;
+export declare function isPowerKeepAwakeActive(host: HasPowerKeepAwake): boolean;
+export declare function makePowerBatteryHealth(): PowerBatteryHealth;
+export declare function makePowerStatus(): PowerStatus;
+export declare function releasePowerKeepAwake(host: HasPowerKeepAwake): Promise<PowerKeepAwakeReleaseResult>;
 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

@@ -1 +1 @@
-{"version":3,"file":"power.d.ts","sourceRoot":"","sources":["../src/power.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,0BAA0B,CAAC;AACnE,OAAO,KAAK,EACV,KAAK,EACL,YAAY,EACZ,kBAAkB,EAClB,cAAc,EACd,kBAAkB,EAClB,WAAW,EACX,iBAAiB,EAClB,MAAM,0BAA0B,CAAC;AASlC,wBAAgB,WAAW,CAAC,KAAK,EAAE,KAAK,EAAE,oBAAoB,SAAK,GAAG,IAAI,CAyDzE;AAID,wBAAgB,WAAW,IAAI,KAAK,CAanC;AAGD,wBAAgB,wBAAwB,IAAI,kBAAkB,CAQ7D;AAGD,wBAAgB,iBAAiB,IAAI,WAAW,CAW/C;AAGD,wBAAgB,WAAW,CAAC,KAAK,EAAE,KAAK,GAAG,IAAI,CAM9C;AAID,wBAAgB,YAAY,CAAC,KAAK,EAAE,KAAK,GAAG,IAAI,CAE/C;AAID,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,KAAK,GAAG,IAAI,CAWrD;AAED,wBAAgB,mBAAmB,IAAI,kBAAkB,CAaxD;AAED,wBAAgB,eAAe,IAAI,YAAY,CAE9C;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;AAED,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,YAAY,GAAG,IAAI,CAMnE;AAED,wBAAgB,sBAAsB,CAAC,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,OAAO,GAAG,IAAI,CAKlF;AAED,wBAAgB,wBAAwB,IAAI,IAAI,CAK/C;AAED,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"}
+{"version":3,"file":"power.d.ts","sourceRoot":"","sources":["../src/power.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,YAAY,EACZ,iBAAiB,EAEjB,cAAc,EACd,eAAe,EACf,eAAe,EACf,KAAK,EACL,kBAAkB,EAClB,cAAc,EACd,2BAA2B,EAC3B,kBAAkB,EAClB,2BAA2B,EAC3B,WAAW,EACX,iBAAiB,EAClB,MAAM,0BAA0B,CAAC;AASlC,wBAAgB,qBAAqB,CACnC,IAAI,EAAE,iBAAiB,EACvB,IAAI,GAAE,kBAA0C,GAC/C,OAAO,CAAC,2BAA2B,CAAC,CAEtC;AAQD,wBAAgB,WAAW,CAAC,IAAI,EAAE,eAAe,EAAE,KAAK,EAAE,KAAK,EAAE,oBAAoB,SAAK,GAAG,IAAI,CA+DhG;AAID,wBAAgB,WAAW,IAAI,KAAK,CAYnC;AAYD,wBAAgB,qBAAqB,CAAC,GAAG,KAAK,EAAE,SAAS,iBAAiB,EAAE,GAAG,IAAI,CAiBlF;AAED,wBAAgB,WAAW,CAAC,KAAK,EAAE,KAAK,GAAG,IAAI,CAa9C;AAGD,wBAAgB,YAAY,CAAC,KAAK,EAAE,KAAK,GAAG,IAAI,CAW/C;AAGD,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,KAAK,GAAG,IAAI,CAUrD;AAED,wBAAgB,qBAAqB,CACnC,IAAI,EAAE;IACJ,QAAQ,CAAC,KAAK,EAAE;QAAE,QAAQ,CAAC,aAAa,EAAE;YAAE,gBAAgB,CAAC,GAAG,EAAE,kBAAkB,GAAG,kBAAkB,CAAA;SAAE,CAAA;KAAE,CAAC;CAC/G,EACD,GAAG,EAAE,kBAAkB,GACtB,kBAAkB,CAEpB;AAED,wBAAgB,6BAA6B,IAAI,MAAM,CAEtD;AAED,wBAAgB,cAAc,CAAC,IAAI,EAAE,cAAc,EAAE,GAAG,EAAE,WAAW,GAAG,WAAW,CAElF;AAED,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,YAAY,EAAE,gBAAgB,EAAE,MAAM,GAAG,cAAc,CAEpG;AAED,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,YAAY,GAAG,MAAM,CAEjE;AAED,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,eAAe,GAAG,iBAAiB,CAE7E;AAED,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,iBAAiB,GAAG,OAAO,CAEvE;AAKD,wBAAgB,sBAAsB,IAAI,kBAAkB,CAQ3D;AAID,wBAAgB,eAAe,IAAI,WAAW,CAW7C;AAID,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,iBAAiB,GAAG,OAAO,CAAC,2BAA2B,CAAC,CAEnG;AAED,wBAAgB,6BAA6B,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI,CAEtE"}

package/dist/power.js

@@ -1,286 +1,243 @@
-import { createSignal, emitSignal, hasSignalSlots } from '@flighthq/signals/contract';
-// 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) {
+import { createEntity } from '@flighthq/entity/contract';
+import { clearSignal, createSignal, emitSignal, hasSignalSlots } from '@flighthq/signals/contract';
+// AN ATTEMPT IS NEVER AN OUTCOME. The previous seam recorded that an operation had been STARTED and
+// reported that as availability: a denied Wake Lock request was observed as 'available' because the
+// observation ran on the synchronous path before the promise settled. Every result here is produced
+// after the underlying operation has actually completed.
+// Acquires a keep-awake lock, resolving only once the provider has really taken it. `ok` means the
+// provider acquired its mechanism — not that the hardware can never sleep for other policy reasons.
+export function acquirePowerKeepAwake(host, mode = 'PreventDisplaySleep') {
+    return host.power.keepAwake.acquire(mode);
+}
+// Starts delivering the host's power events into `power`'s signals. Re-attaching detaches first, so one
+// entity never holds two live subscriptions.
+//
+// Each unsubscribe is ORIGIN-PINNED: it is kept beside the entity that opened it, so detaching one
+// entity ends exactly its own subscriptions. Teardown ATTEMPTS ALL of them even if one throws, because
+// abandoning the rest would leak every subscription after the first failure.
+export function attachPower(host, power, idleThresholdSeconds = 60) {
     detachPower(power);
-    const backend = getPowerBackend();
-    let wasCharging = backend.getStatus(_scratch).isCharging;
-    const unsubscribeChange = backend.subscribe(() => {
-        const status = backend.getStatus(_scratch);
-        if (power.onChange !== null)
-            emitSignal(power.onChange, status);
-        if (status.isCharging !== wasCharging) {
-            wasCharging = status.isCharging;
-            const transition = status.isCharging ? power.onCharging : power.onDischarging;
-            if (transition !== null)
-                emitSignal(transition);
-        }
-    });
-    const unsubscribeLockScreen = backend.subscribeLockScreen(() => {
-        if (power.onLockScreen !== null)
-            emitSignal(power.onLockScreen);
-    });
-    const unsubscribeLowPowerModeChange = backend.subscribeLowPowerModeChange(() => {
-        if (power.onLowPowerModeChange !== null)
-            emitSignal(power.onLowPowerModeChange);
-    });
-    const unsubscribeResume = backend.subscribeResume(() => {
-        if (power.onResume !== null)
-            emitSignal(power.onResume);
-    });
-    const unsubscribeSuspend = backend.subscribeSuspend(() => {
-        if (power.onSuspend !== null)
-            emitSignal(power.onSuspend);
-    });
-    const unsubscribeThermalStateChange = backend.subscribeThermalStateChange(() => {
-        if (power.onThermalStateChange !== null)
-            emitSignal(power.onThermalStateChange);
-    });
-    const unsubscribeUnlockScreen = backend.subscribeUnlockScreen(() => {
-        if (power.onUnlockScreen !== null)
-            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(() => {
-        const idleSignal = power.onIdleStateChange;
-        if (idleSignal === null || !hasSignalSlots(idleSignal))
-            return;
-        const current = backend.getSystemIdleState(idleThresholdSeconds);
-        if (current !== lastIdleState) {
-            lastIdleState = current;
-            emitSignal(idleSignal);
-        }
-    }, _idlePollingIntervalMs);
-    _subscriptions.set(power, () => {
-        unsubscribeChange();
-        unsubscribeLockScreen();
-        unsubscribeLowPowerModeChange();
-        unsubscribeResume();
-        unsubscribeSuspend();
-        unsubscribeThermalStateChange();
-        unsubscribeUnlockScreen();
-        clearInterval(idleIntervalId);
-    });
+    const teardowns = [];
+    const status = host.power.status;
+    const change = host.power.change;
+    if (change !== undefined) {
+        let wasCharging = status !== undefined ? status.getStatus(makePowerStatus()).isCharging : false;
+        teardowns.push(change.subscribe(() => {
+            // A FRESH value per event, never a shared reusable buffer: a listener may retain this payload
+            // and it must not mutate underneath on the next power event.
+            const current = status !== undefined ? status.getStatus(makePowerStatus()) : null;
+            if (current !== null && power.onChange !== null)
+                emitSignal(power.onChange, current);
+            if (current !== null && current.isCharging !== wasCharging) {
+                wasCharging = current.isCharging;
+                const transition = current.isCharging ? power.onCharging : power.onDischarging;
+                if (transition !== null)
+                    emitSignal(transition);
+            }
+        }));
+    }
+    const sessionLock = host.power.sessionLock;
+    if (sessionLock !== undefined) {
+        teardowns.push(sessionLock.subscribeLock(() => emitSignalWhenPresent(power.onLockScreen)));
+        teardowns.push(sessionLock.subscribeUnlock(() => emitSignalWhenPresent(power.onUnlockScreen)));
+    }
+    const suspension = host.power.suspension;
+    if (suspension !== undefined) {
+        teardowns.push(suspension.subscribeSuspend(() => emitSignalWhenPresent(power.onSuspend)));
+        teardowns.push(suspension.subscribeResume(() => emitSignalWhenPresent(power.onResume)));
+    }
+    const thermal = host.power.thermal;
+    if (thermal !== undefined) {
+        teardowns.push(thermal.subscribeThermalStateChange((state) => {
+            if (power.onThermalStateChange !== null)
+                emitSignal(power.onThermalStateChange, state);
+        }));
+    }
+    // Idle is polled because no host pushes idle transitions. The interval exists only when the host
+    // actually offers the idle slot: a host that would answer a constant 'Unknown' omits the slot, so
+    // nothing polls a value that provably cannot change.
+    const idle = host.power.idle;
+    if (idle !== undefined) {
+        let lastIdleState = idle.getIdleState(idleThresholdSeconds);
+        const idleIntervalId = setInterval(() => {
+            const idleSignal = power.onIdleStateChange;
+            if (idleSignal === null || !hasSignalSlots(idleSignal))
+                return;
+            const current = idle.getIdleState(idleThresholdSeconds);
+            if (current !== lastIdleState) {
+                lastIdleState = current;
+                emitSignal(idleSignal);
+            }
+        }, _idlePollingIntervalMs);
+        teardowns.push(() => clearInterval(idleIntervalId));
+    }
+    _subscriptions.set(power, teardowns);
 }
 // Allocates a Power event entity with its signals left null. Call enablePowerSignals to allocate the
-// signals to connect to, and attachPower to start delivering backend changes into them.
+// signals to connect to, and attachPower to start delivering host events into them.
 export function createPower() {
-    return {
+    return createEntity({
         onChange: null,
         onCharging: null,
         onDischarging: null,
         onIdleStateChange: null,
         onLockScreen: null,
-        onLowPowerModeChange: null,
         onResume: null,
         onSuspend: null,
         onThermalStateChange: null,
         onUnlockScreen: null,
-    };
-}
-// 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',
-    };
+// Stops delivery without discarding the entity. Runs every teardown this entity opened, ATTEMPTING ALL
+// of them: one throwing unsubscribe must not strand the rest. Does not touch the provider — that is
+// `destroy` on the host's slot, a separate lifecycle.
+// FINAL RELEASE for the one power slot that owns a whole-provider resource. Destroys every DISTINCT
+// keep-awake provider exactly once — alias-safe, because two hosts may share one provider object and
+// destroying it twice would double-release an OS lock.
+//
+// Attempt-all: every obligation is tried even after one throws, and the first error is rethrown once the
+// siblings have run. A provider whose destroy threw is RETAINED, so a later call retries only the
+// failures; the ones that succeeded are forgotten and never destroyed twice.
+export function destroyPowerKeepAwake(...hosts) {
+    const pending = new Set();
+    for (const host of hosts) {
+        const provider = host.power.keepAwake;
+        if (!_destroyedKeepAwake.has(provider))
+            pending.add(provider);
+    }
+    let failure = null;
+    for (const provider of pending) {
+        try {
+            if (provider.destroy !== undefined)
+                assertSyncVoid(provider.destroy());
+        }
+        catch (error) {
+            failure ??= error;
+            continue;
+        }
+        _destroyedKeepAwake.add(provider);
+    }
+    if (failure !== null)
+        throw failure;
 }
-// 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);
+    const teardowns = _subscriptions.get(power);
+    if (teardowns === undefined)
+        return;
+    _subscriptions.delete(power);
+    let failure = null;
+    for (const teardown of teardowns) {
+        try {
+            teardown();
+        }
+        catch (error) {
+            failure ??= error;
+        }
     }
+    if (failure !== null)
+        throw failure;
 }
-// Releases `power` for garbage collection by detaching its backend subscription. The signals remain
-// plain GC-managed memory afterward.
+// Terminal disposal: detaches and then clears the entity's signals, so it becomes GC-eligible.
 export function disposePower(power) {
     detachPower(power);
-}
-// Allocates any not-yet-allocated Power signals so callers can connect to them. Idempotent: signals
-// already allocated are left untouched. Pair with attachPower to begin delivery.
+    if (power.onChange !== null)
+        clearSignal(power.onChange);
+    if (power.onCharging !== null)
+        clearSignal(power.onCharging);
+    if (power.onDischarging !== null)
+        clearSignal(power.onDischarging);
+    if (power.onIdleStateChange !== null)
+        clearSignal(power.onIdleStateChange);
+    if (power.onLockScreen !== null)
+        clearSignal(power.onLockScreen);
+    if (power.onResume !== null)
+        clearSignal(power.onResume);
+    if (power.onSuspend !== null)
+        clearSignal(power.onSuspend);
+    if (power.onThermalStateChange !== null)
+        clearSignal(power.onThermalStateChange);
+    if (power.onUnlockScreen !== null)
+        clearSignal(power.onUnlockScreen);
+}
+// Allocates any not-yet-allocated Power signals so callers can connect to them. Idempotent.
 export function enablePowerSignals(power) {
-    if (power.onChange === null)
-        power.onChange = createSignal();
-    if (power.onCharging === null)
-        power.onCharging = createSignal();
-    if (power.onDischarging === null)
-        power.onDischarging = createSignal();
-    if (power.onIdleStateChange === null)
-        power.onIdleStateChange = createSignal();
-    if (power.onLockScreen === null)
-        power.onLockScreen = createSignal();
-    if (power.onLowPowerModeChange === null)
-        power.onLowPowerModeChange = createSignal();
-    if (power.onResume === null)
-        power.onResume = createSignal();
-    if (power.onSuspend === null)
-        power.onSuspend = createSignal();
-    if (power.onThermalStateChange === null)
-        power.onThermalStateChange = createSignal();
-    if (power.onUnlockScreen === null)
-        power.onUnlockScreen = createSignal();
+    power.onChange ??= createSignal();
+    power.onCharging ??= createSignal();
+    power.onDischarging ??= createSignal();
+    power.onIdleStateChange ??= createSignal();
+    power.onLockScreen ??= createSignal();
+    power.onResume ??= createSignal();
+    power.onSuspend ??= createSignal();
+    power.onThermalStateChange ??= createSignal();
+    power.onUnlockScreen ??= createSignal();
+}
+export function getPowerBatteryHealth(host, out) {
+    return host.power.batteryHealth.getBatteryHealth(out);
 }
-export function explainPowerBackend() {
-    if (_custom !== null) {
-        return { conflict: _hostConflict, layer: 'custom', operation: null, viability: 'unobserved' };
-    }
-    if (_host !== null) {
-        return {
-            conflict: _hostConflict,
-            layer: 'host',
-            operation: _hostObservation !== null ? _hostObservation.operation : null,
-            viability: _hostObservation !== null ? _hostObservation.viability : 'unobserved',
-        };
-    }
-    return { conflict: false, layer: 'host-not-enabled', operation: null, viability: 'unobserved' };
-}
-export function getPowerBackend() {
-    return _custom ?? _host ?? _sentinel;
-}
-// 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);
+export function getPowerStatus(host, out) {
+    return host.power.status.getStatus(out);
 }
-// Returns the elapsed seconds since the last user input event, or -1 when unsupported.
-export function getPowerSystemIdleTime() {
-    return getPowerBackend().getSystemIdleTime();
+export function getPowerSystemIdleState(host, thresholdSeconds) {
+    return host.power.idle.getIdleState(thresholdSeconds);
 }
-// Returns the current thermal state from the active backend.
-export function getPowerThermalState() {
-    return getPowerBackend().getStatus(_scratch).thermalState;
+export function getPowerSystemIdleTime(host) {
+    return host.power.idle.getIdleTimeSeconds();
 }
-// Returns true when a keep-awake lock is currently held by the active backend.
-export function hasPowerKeepAwake() {
-    return getPowerBackend().isKeepAwakeActive();
+export function getPowerThermalState(host) {
+    return host.power.thermal.getThermalState();
 }
-export function installPowerHostBackend(backend) {
-    if (_host !== null) {
-        if (_host !== backend)
-            _hostConflict = true;
-        return;
-    }
-    _host = backend;
+export function isPowerKeepAwakeActive(host) {
+    return host.power.keepAwake.isActive();
 }
-export function observePowerHostResult(operation, succeeded) {
-    _hostObservation = {
-        operation,
-        viability: succeeded ? 'available' : 'runtime-api-unavailable',
+// Allocates a PowerBatteryHealth value with the domain's complete unknown encoding. Not a create*: this
+// is a plain value the queries fill, with no identity — but it earns a function because the -1/'Unknown'
+// defaults are load-bearing and a literal `{}` would read as undefined where the domain expects -1.
+export function makePowerBatteryHealth() {
+    return {
+        capacityWearLevel: -1,
+        cycleCount: -1,
+        healthState: 'Unknown',
+        temperatureCelsius: -1,
+        voltage: -1,
     };
 }
-export function resetPowerBackendForTest() {
-    _custom = null;
-    _host = null;
-    _hostConflict = false;
-    _hostObservation = null;
+// Allocates a PowerStatus value with the domain's complete unknown encoding. Same reasoning as
+// makePowerBatteryHealth: a value, not an entity, but the defaults are load-bearing.
+export function makePowerStatus() {
+    return {
+        batteryLevel: -1,
+        chargingTime: -1,
+        dischargingTime: -1,
+        isBatteryLow: false,
+        isCharging: false,
+        isLowPower: false,
+        isOnBattery: false,
+        thermalState: 'Unknown',
+    };
 }
-export function setPowerBackend(backend) {
-    _custom = backend;
+// Releases a keep-awake lock, resolving only once the provider has really let it go. State is never
+// published before the awaited release succeeds.
+export function releasePowerKeepAwake(host) {
+    return host.power.keepAwake.release();
 }
-// 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;
+    _idlePollingIntervalMs = intervalMs > 0 ? intervalMs : 1;
 }
-// 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);
+function emitSignalWhenPresent(signal) {
+    if (signal !== null)
+        emitSignal(signal);
 }
-let _custom = null;
-let _host = null;
-let _hostConflict = false;
-let _hostObservation = null;
 let _idlePollingIntervalMs = 5000;
-const _scratch = createPowerStatus();
-const _sentinel = {
-    getBatteryHealth() {
-        return null;
-    },
-    getStatus(out) {
-        out.batteryLevel = -1;
-        out.chargingTime = -1;
-        out.dischargingTime = -1;
-        out.isBatteryLow = false;
-        out.isCharging = false;
-        out.isLowPower = false;
-        out.isOnBattery = false;
-        out.thermalState = 'Unknown';
-        return out;
-    },
-    getSystemIdleState() {
-        return 'Unknown';
-    },
-    getSystemIdleTime() {
-        return -1;
-    },
-    isKeepAwakeActive() {
-        return false;
-    },
-    setKeepAwake() {
-        return false;
-    },
-    subscribe() {
-        return () => { };
-    },
-    subscribeLockScreen() {
-        return () => { };
-    },
-    subscribeLowPowerModeChange() {
-        return () => { };
-    },
-    subscribeResume() {
-        return () => { };
-    },
-    subscribeSuspend() {
-        return () => { };
-    },
-    subscribeThermalStateChange() {
-        return () => { };
-    },
-    subscribeUnlockScreen() {
-        return () => { };
-    },
-};
+// Origin-pinned teardown bookkeeping: each entity's own unsubscribes, held beside the entity rather
+// than in a shared slot, so detaching one never ends another's subscriptions.
 const _subscriptions = new WeakMap();
+// Providers already finally-released. A destroy that THREW is deliberately absent, so the next call
+// retries exactly the failed obligations and never re-destroys a successful one.
+const _destroyedKeepAwake = new WeakSet();
+function assertSyncVoid(value) {
+    void value;
+}
 //# sourceMappingURL=power.js.map