@camstack/system 1.2.10 → 1.2.11

package/dist/builtins/snapshot/index.js

@@ -759,25 +759,31 @@ var SnapshotAddon = class SnapshotAddon extends require_dist.BaseAddon {
 		this.captureFlight.invalidatePrefix(`${input.deviceId}:`);
 	}
 	/**
-	* Non-throwing probe of the device's battery cap. Returns true only
-	* when a battery native is registered AND its current status says
-	* `sleeping: true`. Any error (no provider, native absent, getStatus
-	* missing, RPC timeout) is swallowed and treated as "awake" — we'd
-	* rather pay a wake-up than strand the caller on a cache that's
-	* semantically stale. Debug-logged for observability.
+	* Sleep state from the device-state MIRROR, not from a cap round-trip.
 	*
-	* Cheap: a battery provider serves this from its runtime-state slice,
-	* so the probe costs one RPC and zero camera traffic. Only consulted
-	* on the path that would otherwise CAPTURE — a fresh cache hit
-	* returns before we get here.
+	* `fetchDevice(id).state.battery` is a `SliceHandle` over the hub's
+	* runtime-state mirror: a local read, no RPC, no failure branch to get
+	* wrong. It is the same mirror that feeds the battery badge elsewhere
+	* in the UI, so if the operator can see "sleeping" on screen, this
+	* sees it too. (Both spec harnesses already model exactly this wiring
+	* — like the orphaned doc comment above, it outlived the gate it was
+	* built for.)
+	*
+	* `undefined` slice → the device has no battery state we know of →
+	* treated as awake. The caller has already established the device is
+	* battery-operated from its feature flags, so this only decides
+	* WHETHER IT IS ASLEEP, never whether it has a battery.
+	*
+	* Only consulted on the path that would otherwise CAPTURE — a fresh
+	* cache hit returns before we get here.
 	*/
 	async isDeviceSleeping(deviceId) {
 		try {
-			const raw = await this.ctx.api.battery.getStatus.query({ deviceId });
+			const raw = (await this.ctx.fetchDevice(deviceId)).state.battery.value;
 			const parsed = require_dist.BatteryStatusSchema.safeParse(raw);
 			return parsed.success && parsed.data.sleeping;
 		} catch (err) {
-			this.ctx.logger.debug("snapshot: battery sleep probe failed — assuming awake", {
+			this.ctx.logger.warn("snapshot: battery mirror read failed — assuming awake", {
 				tags: { deviceId },
 				meta: { error: require_dist.errMsg(err) }
 			});

package/dist/builtins/snapshot/index.mjs

@@ -754,25 +754,31 @@ var SnapshotAddon = class SnapshotAddon extends BaseAddon {
 		this.captureFlight.invalidatePrefix(`${input.deviceId}:`);
 	}
 	/**
-	* Non-throwing probe of the device's battery cap. Returns true only
-	* when a battery native is registered AND its current status says
-	* `sleeping: true`. Any error (no provider, native absent, getStatus
-	* missing, RPC timeout) is swallowed and treated as "awake" — we'd
-	* rather pay a wake-up than strand the caller on a cache that's
-	* semantically stale. Debug-logged for observability.
+	* Sleep state from the device-state MIRROR, not from a cap round-trip.
 	*
-	* Cheap: a battery provider serves this from its runtime-state slice,
-	* so the probe costs one RPC and zero camera traffic. Only consulted
-	* on the path that would otherwise CAPTURE — a fresh cache hit
-	* returns before we get here.
+	* `fetchDevice(id).state.battery` is a `SliceHandle` over the hub's
+	* runtime-state mirror: a local read, no RPC, no failure branch to get
+	* wrong. It is the same mirror that feeds the battery badge elsewhere
+	* in the UI, so if the operator can see "sleeping" on screen, this
+	* sees it too. (Both spec harnesses already model exactly this wiring
+	* — like the orphaned doc comment above, it outlived the gate it was
+	* built for.)
+	*
+	* `undefined` slice → the device has no battery state we know of →
+	* treated as awake. The caller has already established the device is
+	* battery-operated from its feature flags, so this only decides
+	* WHETHER IT IS ASLEEP, never whether it has a battery.
+	*
+	* Only consulted on the path that would otherwise CAPTURE — a fresh
+	* cache hit returns before we get here.
 	*/
 	async isDeviceSleeping(deviceId) {
 		try {
-			const raw = await this.ctx.api.battery.getStatus.query({ deviceId });
+			const raw = (await this.ctx.fetchDevice(deviceId)).state.battery.value;
 			const parsed = BatteryStatusSchema.safeParse(raw);
 			return parsed.success && parsed.data.sleeping;
 		} catch (err) {
-			this.ctx.logger.debug("snapshot: battery sleep probe failed — assuming awake", {
+			this.ctx.logger.warn("snapshot: battery mirror read failed — assuming awake", {
 				tags: { deviceId },
 				meta: { error: errMsg(err) }
 			});

package/dist/builtins/snapshot/snapshot.addon.d.ts

@@ -170,17 +170,23 @@ export declare class SnapshotAddon extends BaseAddon<SnapshotAddonConfig> {
     private runGrabWithResumeRetry;
     private invalidateCache;
     /**
-     * Non-throwing probe of the device's battery cap. Returns true only
-     * when a battery native is registered AND its current status says
-     * `sleeping: true`. Any error (no provider, native absent, getStatus
-     * missing, RPC timeout) is swallowed and treated as "awake" — we'd
-     * rather pay a wake-up than strand the caller on a cache that's
-     * semantically stale. Debug-logged for observability.
+     * Sleep state from the device-state MIRROR, not from a cap round-trip.
      *
-     * Cheap: a battery provider serves this from its runtime-state slice,
-     * so the probe costs one RPC and zero camera traffic. Only consulted
-     * on the path that would otherwise CAPTURE — a fresh cache hit
-     * returns before we get here.
+     * `fetchDevice(id).state.battery` is a `SliceHandle` over the hub's
+     * runtime-state mirror: a local read, no RPC, no failure branch to get
+     * wrong. It is the same mirror that feeds the battery badge elsewhere
+     * in the UI, so if the operator can see "sleeping" on screen, this
+     * sees it too. (Both spec harnesses already model exactly this wiring
+     * — like the orphaned doc comment above, it outlived the gate it was
+     * built for.)
+     *
+     * `undefined` slice → the device has no battery state we know of →
+     * treated as awake. The caller has already established the device is
+     * battery-operated from its feature flags, so this only decides
+     * WHETHER IT IS ASLEEP, never whether it has a battery.
+     *
+     * Only consulted on the path that would otherwise CAPTURE — a fresh
+     * cache hit returns before we get here.
      */
     private isDeviceSleeping;
     /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@camstack/system",
-  "version": "1.2.10",
+  "version": "1.2.11",
   "description": "Core addon for CamStack — builtins, pipeline, process management, auth, logging, events",
   "keywords": [
     "camstack",