@mega-yfue/eufy-sdk 0.2.0-beta.11 → 0.2.0-beta.12

package/dist/index.js

@@ -3972,12 +3972,32 @@ function decodePowerSource(raw) {
 function recordSetting(param, value, ctx) {
   return setStationScalar(param, value, ctx.channel);
 }
-var MAINS_CAMERA_MODELS = ["T8425", "T8419"];
+var MAINS_CAMERA_MODELS = ["T8425", "T8419", "T8410"];
 var notMainsCamera = (ctx) => {
   const model = (ctx.model ?? "").toUpperCase();
   return !MAINS_CAMERA_MODELS.some((prefix) => model.startsWith(prefix));
 };
-var BATTERY_MEMBERS = {
+var CELL_PARAMS = [
+  BATTERY_PARAM.BATTERY,
+  BATTERY_PARAM.BATTERY_STATUS,
+  BATTERY_PARAM.BATTERY_TEMP,
+  BATTERY_PARAM.BATTERY_HEALTH,
+  BATTERY_PARAM.SOLAR_INTENSITY,
+  BATTERY_PARAM.SOLAR_CONNECT_24H,
+  BATTERY_PARAM.BATTERY_POWER_DATAS
+];
+function cellGated(members) {
+  const gated = Object.entries(members).map(([name, m]) => {
+    const param = m.param;
+    if (typeof param !== "number" || !CELL_PARAMS.includes(param))
+      return [name, m];
+    const own = m.available;
+    const available = own ? (ctx) => notMainsCamera(ctx) && own(ctx) : notMainsCamera;
+    return [name, { ...m, available }];
+  });
+  return Object.fromEntries(gated);
+}
+var BATTERY_MEMBERS = cellGated({
   /**
    * The headline percentage, and this capability's detection evidence: reporting 1101 is what proves a
    * device is battery-powered, which is also the fact `MediaProvider` reads to decide a stream needs a
@@ -3990,7 +4010,6 @@ var BATTERY_MEMBERS = {
     unit: "%",
     kind: "percent",
     provenance: "verified",
-    available: notMainsCamera,
     description: "Battery level 0-100 (verified: param 1101)."
   },
   /**
@@ -4003,7 +4022,6 @@ var BATTERY_MEMBERS = {
     type: "bool",
     kind: "boolean",
     provenance: "apk",
-    available: notMainsCamera,
     coerce: (v) => {
       const n = Number(v);
       return n !== 0 && n !== 2;
@@ -4174,6 +4192,11 @@ var BATTERY_MEMBERS = {
    * Reported, so it stays in the schema and answers through `getProperty` — but given no typed getter:
    * the payload's fields have never been decoded, and a getter would hand back an opaque blob typed as
    * though it meant something.
+   *
+   * `unexposed` is NOT a substitute for the cell gate. It suppresses the fluent GETTER; `propertiesOf`
+   * filters `writeOnly` and `available` and deliberately not `unexposed`, because a schema entry
+   * reachable through `getProperty` is the whole point of the mark. So a cell param needs
+   * {@link CELL_PARAMS} either way, or a mains camera publishes "battery power history" and answers it.
    */
   batteryPowerStats: {
     param: BATTERY_PARAM.BATTERY_POWER_DATAS,
@@ -4199,7 +4222,7 @@ var BATTERY_MEMBERS = {
     unexposed: true,
     description: "Raw GET_CAMERA_INFO value (1103), meaning unevidenced \u2014 read live as the constant 5 on a T8170 at 92% and a T8171 at 27%, so it is NOT a low-battery flag."
   }
-};
+});
 var BATTERY = {
   capability: "battery",
   description: "Battery level, charging, health, temperature, and solar input.",
@@ -10093,6 +10116,16 @@ function getCapabilityModule(cap) {
   return BY_CAP.get(cap);
 }
 var CAPABILITY_MODULES = Object.fromEntries(MODULES.map((m) => [m.capability, m]));
+function claimedParams(caps) {
+  const claimed = /* @__PURE__ */ new Set();
+  for (const cap of caps)
+    for (const spec of getCapabilityModule(cap)?.properties ?? []) {
+      claimed.add(spec.paramType);
+      for (const alias of spec.readAliases ?? [])
+        claimed.add(alias.paramType);
+    }
+  return claimed;
+}
 function mergeProperties(caps, ctx) {
   const seen = /* @__PURE__ */ new Set();
   const merged = [];
@@ -12384,6 +12417,11 @@ var Device = class _Device {
    * different wire ids across device families still resolves to one named value.
    */
   specByParam;
+  /**
+   * Params a resolved capability declares that this device's schema does not carry — withheld by a
+   * member's gate, so not named from the param dictionary either. See {@link Device.applyParams}.
+   */
+  withheld = /* @__PURE__ */ new Set();
   /** Which param namespace this device's ids live in (clean DPs vs security P2P). */
   namespace;
   /** The record's `device_name` as stated, before the {@link modelName} fallback is applied. */
@@ -12450,6 +12488,7 @@ var Device = class _Device {
           byParam.set(a.paramType, { spec: p, invert: a.invert ?? false });
     }
     this.specByParam = byParam;
+    this.withheld = new Set([...claimedParams(resolved.capabilities)].filter((pt) => !byParam.has(pt)));
     this.namespace = namespaceForCodec(resolved.codec);
     this.installAccessors();
   }
@@ -12612,6 +12651,16 @@ var Device = class _Device {
    * Apply a raw param map (cloud record or P2P notification). Known params update their named
    * property; unrecognised params are retained as `unknown_<paramType>` so nothing is lost.
    *
+   * Naming precedence: this device's own `PropertySpec` (curated), then the param dictionary for its
+   * namespace, then the `unknown_<paramType>` passthrough. The dictionary def is consulted even where a
+   * spec exists, because `encoding` lives there.
+   *
+   * A param a resolved capability's gate WITHHELD takes the passthrough instead of its dictionary name.
+   * The gate decided the read does not describe this device, the dictionary names it what the member
+   * would have, and republishing it there hands a caller a reading indistinguishable from one the device
+   * really answered. A capability that never resolved withholds nothing: a param arriving before its
+   * capability is still the device's own, and keeps its dictionary name.
+   *
    * @param params param_type → raw value.
    * @param ts observation time (epoch ms); defaults to `Date.now()`.
    * @returns the list of property names whose value changed.
@@ -12624,7 +12673,7 @@ var Device = class _Device {
         continue;
       const hit = this.specByParam.get(pt);
       const spec = hit?.spec;
-      const def = paramDef(this.namespace, pt);
+      const def = this.withheld.has(pt) ? void 0 : paramDef(this.namespace, pt);
       const name = spec ? spec.name : def ? def.name : `${UNKNOWN_PARAM_PREFIX}${pt}`;
       const value = def?.encoding ? decodeEncoded(rawVal, def.encoding) : spec ? coerce(spec, rawVal, hit.invert, this.logger) : def ? coerceByType(def.type, rawVal, def.name, this.logger) : String(rawVal);
       const prev = this.state.get(name);
@@ -26700,6 +26749,7 @@ export {
   buildRealtimeInit,
   captureSnapshotFromShared,
   cellAtPoint,
+  claimedParams,
   clamp,
   classify,
   classifyDevice,