@mega-yfue/eufy-sdk 0.6.0-beta.46 → 0.6.0-beta.48

package/dist/index.js

@@ -3471,11 +3471,11 @@ function propertiesOf(members, ctx) {
 }
 var BOOL_VALUES = /* @__PURE__ */ new Set([true, false, 0, 1, "0", "1", "true", "false"]);
 function memberWrite(name, m, value, ctx) {
-  if (!inDomain(m, value))
-    throw new Error(rejection(name, m, value));
+  if (!inDomain(m, value, ctx))
+    throw new Error(rejection(name, m, value, ctx));
   const cmd = m.write?.(value, ctx);
   if (!cmd)
-    throw new Error(rejection(name, m, value));
+    throw new Error(rejection(name, m, value, ctx));
   const reflected = m.observation?.reflects(value, ctx);
   return m.observation && reflected ? observeCommand(cmd, {
     event: m.observation.event,
@@ -3487,10 +3487,11 @@ function memberWrite(name, m, value, ctx) {
     timeoutMs: m.observation.timeoutMs
   }) : cmd;
 }
-function writeDomain(m) {
-  return m.args?.[0]?.values ?? m.decodedValues ?? (m.enumValues && Object.keys(m.enumValues).map(Number));
+function writeDomain(m, ctx) {
+  const values = resolvedEnum(m, ctx).values;
+  return m.args?.[0]?.values ?? m.decodedValues ?? (values && Object.keys(values).map(Number));
 }
-function inDomain(m, value) {
+function inDomain(m, value, ctx) {
   if (m.type === "bool")
     return BOOL_VALUES.has(typeof value === "string" ? value.toLowerCase() : value);
   if (typeof value === "number") {
@@ -3499,11 +3500,11 @@ function inDomain(m, value) {
     if (m.max !== void 0 && value > m.max)
       return false;
   }
-  const domain = writeDomain(m)?.filter((v) => typeof v === typeof value);
+  const domain = writeDomain(m, ctx)?.filter((v) => typeof v === typeof value);
   return !domain?.length || domain.includes(value);
 }
-function rejection(name, m, value) {
-  const options = writeDomain(m);
+function rejection(name, m, value, ctx) {
+  const options = writeDomain(m, ctx);
   const domain = options?.length ? `one of ${options.join("/")}` : m.min !== void 0 && m.max !== void 0 ? `in ${m.min}..${m.max}` : m.min !== void 0 ? `>= ${m.min}` : void 0;
   return `${name}: ${JSON.stringify(value)} is not a valid value` + (domain ? ` (must be ${domain})` : "");
 }
@@ -4817,8 +4818,10 @@ function cellGated(members) {
   return Object.fromEntries(gated);
 }
 var notSensor = (ctx) => ctx.codec !== "sensor";
-function notOnSensor(members) {
+function notOnSensor(members, sensorOnly) {
   const gated = Object.entries(members).map(([name, m]) => {
+    if (sensorOnly.includes(name))
+      return [name, m];
     const own = m.available;
     const available = own ? (ctx) => notSensor(ctx) && own(ctx) : notSensor;
     return [name, { ...m, available }];
@@ -5054,12 +5057,26 @@ var CAMERA_BATTERY_MEMBERS = cellGated({
     provenance: "apk",
     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."
+  },
+  /**
+   * A sensor's battery is low. The app reads the entry sensor's 1552 and the motion sensor's 1601 into the
+   * same field (`sensor_is_low_power`, `asBoolean`), so one member reads whichever the sensor reports.
+   * Present on the `sensor` codec only: a camera or a lock reports a level instead.
+   */
+  batteryLow: {
+    param: 1552,
+    readAliases: [{ paramType: 1601 }],
+    type: "bool",
+    kind: "boolean",
+    provenance: "verified",
+    available: (ctx) => !notSensor(ctx),
+    description: "Sensor battery low (1552 entry sensor, 1601 motion sensor; sensor_is_low_power)."
   }
 });
-var BATTERY_MEMBERS = notOnSensor(CAMERA_BATTERY_MEMBERS);
+var BATTERY_MEMBERS = notOnSensor(CAMERA_BATTERY_MEMBERS, ["batteryLow"]);
 var BATTERY = {
   capability: "battery",
-  description: "Battery level, charging, health, temperature, and solar input.",
+  description: "Battery level, charging, health, temperature and solar input; a sensor's low-battery flag.",
   members: BATTERY_MEMBERS,
   properties: propertiesOf(BATTERY_MEMBERS),
   /** A reported battery-level param (1101) is the verified proof the device is battery-powered. */
@@ -5104,161 +5121,6 @@ function resolveWorkingModeValue(model, name) {
   return hit ? Number(hit[0]) : void 0;
 }
 
-// dist/model/capabilities/contact.js
-var CONTACT_CMD = {
-  /** Alarm sound/tone selection (app `APP_CMD_ALARM_SOUND_TYPE`). See {@link EntryAlarmTone}. */
-  ALARM_SOUND_TYPE: 1507,
-  /** Alarm volume (app `APP_CMD_ALARM_VOLUME_VALUE`). A device level 1-26, not a percentage. */
-  ALARM_VOLUME: 1508
-};
-var EntryAlarmTone = {
-  /** Silent — no alarm tone. */
-  None: 0,
-  Water: 1,
-  Classic: 2,
-  Light: 3,
-  Ding: 4
-};
-var ALARM_VOLUME_MIN = 1;
-var ALARM_VOLUME_MAX = 26;
-var SENSOR_STATUS_CMD = 1829;
-var CONTACT_PARAM = 1550;
-function statusParam(signal, paramType) {
-  if (signal.source !== "p2p-frame" || signal.json?.cmd !== SENSOR_STATUS_CMD)
-    return void 0;
-  const params = signal.json.payload?.params;
-  if (!Array.isArray(params))
-    return void 0;
-  const hit = params.find((p) => p?.param_type === paramType);
-  return hit?.param_value == null ? void 0 : String(hit.param_value);
-}
-function contactOpen(raw) {
-  return raw == null || raw === "" ? {} : { open: String(raw) === "1" };
-}
-var CONTACT_MEMBERS = {
-  /**
-   * The headline read: `true` when the door or window is open. Polarity is the V6 app's own
-   * `"1".equals(e)` — see `contactOpen`, which normalises every inbound source through one
-   * predicate so the poll, the push and the station notify cannot disagree about what open means.
-   * Reporting 1550 is also this capability's detection evidence, so a device with this getter is
-   * confirmed to be a contact sensor.
-   */
-  open: {
-    param: CONTACT_PARAM,
-    property: "contact",
-    type: "bool",
-    kind: "boolean",
-    provenance: "verified",
-    description: "Contact state, true=open (verified: param 1550 entry-sensor contact)."
-  },
-  /**
-   * Rejected, not clamped, outside the tone enum: a fire-and-forget write of a bogus tone would look like
-   * it worked. The wire is a direct-binary scalar `[ch][value][acct]` at signCode 8 — the app's own
-   * captured frame.
-   */
-  alarmSoundType: {
-    param: CONTACT_CMD.ALARM_SOUND_TYPE,
-    type: "enum",
-    kind: "enum",
-    enumValues: enumLabels(EntryAlarmTone),
-    provenance: "verified",
-    requires: [CONTACT_CMD.ALARM_SOUND_TYPE],
-    args: [{ name: "tone", kind: "enum", description: "Silent (0) or one of the four chimes." }],
-    description: "Entry-sensor alarm tone (1507): 0=None,1=Water,2=Classic,3=Light,4=Ding. Write verified live on a T90E0 (direct-binary [ch][value][acct]). See CONTACT_CMD.ALARM_SOUND_TYPE.",
-    write: (v, ctx) => {
-      const tone = coerceEnumValue(EntryAlarmTone, v);
-      return tone === void 0 ? void 0 : setScalar(CONTACT_CMD.ALARM_SOUND_TYPE, tone, ctx, "auto");
-    }
-  },
-  /**
-   * `1350` SET_PAYLOAD, `mChannel` = the device channel, `mValue3` 0, payload carrying the channel and a
-   * transaction stamp — the byte-shape of the app's own captured frame. Out of range is refused rather
-   * than clamped: the app's slider has no values outside it, so one is a caller error, not a nudge.
-   *
-   * Level-2 only, though the `mValue3` 0 would allow `"auto"`: an entry sensor's session IS its
-   * HomeBase's, which always holds a key — the second of `setPayload`'s two conditions, not an oversight
-   * of the first.
-   */
-  alarmVolume: {
-    param: CONTACT_CMD.ALARM_VOLUME,
-    type: "number",
-    kind: "scalar",
-    provenance: "verified",
-    requires: [CONTACT_CMD.ALARM_VOLUME],
-    min: ALARM_VOLUME_MIN,
-    max: ALARM_VOLUME_MAX,
-    args: [
-      {
-        name: "level",
-        kind: "scalar",
-        min: ALARM_VOLUME_MIN,
-        max: ALARM_VOLUME_MAX,
-        description: "A device level, not a percentage."
-      }
-    ],
-    description: "Entry-sensor alarm volume (1508), a device level 1-26 (NOT a percentage). Write verified live on a T90E0 (1350 SET_PAYLOAD {channel,volume,transaction}). See CONTACT_CMD.ALARM_VOLUME.",
-    write: (v, ctx) => {
-      const level = Number(v);
-      return Number.isInteger(level) && level >= ALARM_VOLUME_MIN && level <= ALARM_VOLUME_MAX ? setPayload(CONTACT_CMD.ALARM_VOLUME, { channel: ctx.channel, volume: level, transaction: String(Date.now()) }, ctx, 0) : void 0;
-    }
-  }
-};
-var CONTACT = {
-  capability: "contact",
-  description: "Entry (door/window) sensor: contact state and the built-in alarm tone/volume.",
-  members: CONTACT_MEMBERS,
-  properties: propertiesOf(CONTACT_MEMBERS),
-  /** A reported entry-sensor contact param (1550) is the verified proof of a contact sensor. */
-  detection: { evidenceParams: [1550] },
-  /**
-   * Inbound `contactState`: the contact param (1550) changing on a cloud poll (open/closed), AND the FCM
-   * door-sensor push (`CusPushEvent.DOOR_SENSOR` = 3) — verified live on a T8900 (both fire).
-   *
-   * Both sources carry the state under a different key, so each normalises to `open`: the poll's `to` is
-   * the 1550 param value, and the push's is the wire's single-letter `e`. Polarity for the push is the
-   * V6 app's own `CusPushMode.isSensorOpen()`, which is exactly `"1".equals(e)` — anything else,
-   * including absent, is closed — read under its `a == PUSH_DOOR_SENSOR_EVT` branch to choose the
-   * "sensor is opened" vs "sensor is closed" notification string.
-   */
-  events: [
-    {
-      source: "poll",
-      match: 1550,
-      emit: "contactState",
-      derive: (s) => contactOpen(s.source === "poll" ? s.to : void 0)
-    },
-    {
-      source: "push",
-      match: CusPushEvent.DOOR_SENSOR,
-      emit: "contactState",
-      derive: (s) => contactOpen(s.source === "push" ? s.payload?.["e"] : void 0)
-    }
-  ],
-  /**
-   * The contact is a settled state reported by three transports, so one door movement would otherwise
-   * be announced up to three times — the station notify, then the same value as an FCM push ~2 s
-   * later, then again on the next cloud poll.
-   */
-  stateEvents: [{ event: "contactState", field: "open" }],
-  /**
-   * The station's own notify — the fastest contact signal there is, and the only one that needs no
-   * cloud at all (see {@link SENSOR_STATUS_CMD} for the measured lead over the push).
-   *
-   * A declarative `events` row can't express this: those match a push event id or a poll param id,
-   * while the state here is nested inside a frame's `params` array under an inner command id. Hence
-   * the decode hook, which is the documented escape hatch for exactly that.
-   *
-   * Emits nothing when the notify carries no contact param, so a status frame reporting only battery
-   * or signal strength doesn't fabricate a contact event.
-   */
-  decodeEvent(signal) {
-    const raw = statusParam(signal, CONTACT_PARAM);
-    if (raw === void 0)
-      return null;
-    return { event: "contactState", payload: contactOpen(raw) };
-  }
-};
-
 // dist/model/device-family.js
 var INDOOR_CAMERA_TYPES = /* @__PURE__ */ new Set([
   DeviceType.INDOOR_CAMERA,
@@ -5902,7 +5764,7 @@ var CAMERA_CMD = {
    * (1013). (Some models omit full colour; enum in {@link NightVision}.)
    */
   NIGHT_VISION_TYPE: 1277,
-  /** T8442 infrared night vision on/off: direct L1 int-string, hardware verified (0/1). */
+  /** Night vision on a device reporting 2002: direct level-1 [channel][value]. */
   IC_NIGHT_VISION_TYPE: 1013,
   /**
    * Push-notification STYLE — how much a detection push carries: text alone, a thumbnail, or text
@@ -6013,10 +5875,12 @@ var SoundDetectionType = {
 var NightVision = {
   /** Off — never use infrared. */
   Off: 0,
-  /** Infrared / "B&W Auto" — black-and-white night vision. */
+  /** Infrared / "B&W Auto" — black-and-white night vision, switched on when it gets dark. */
   Infrared: 1,
   /** Full colour night vision (models with a spotlight / starlight sensor). */
-  FullColor: 2
+  FullColor: 2,
+  /** Infrared held on — black-and-white night vision, not switched by the light level. */
+  InfraredOn: 3
 };
 var RecordingQuality = {
   HD720: "HD (720P)",
@@ -6094,8 +5958,8 @@ function powerValue(on, ctx) {
 function isT8410HomeBase3(ctx) {
   return ctx.model === "T8410" && ctx.stationSerial?.startsWith("T8030") === true;
 }
-function isT8442(ctx) {
-  return ctx.model === "T8442";
+function readsNightVisionOn2002(ctx) {
+  return ctx.paramIds?.has(2002) === true && !ctx.paramIds.has(CAMERA_CMD.NIGHT_VISION_TYPE);
 }
 function usesHomeBasePowerPayload(ctx) {
   if (!isT8410HomeBase3(ctx) || !ctx.firmwareVersion || !/^\d+(?:\.\d+){2,3}$/.test(ctx.firmwareVersion))
@@ -6310,36 +6174,27 @@ var CAMERA_MEMBERS = {
       return style == null ? void 0 : setJson(CAMERA_CMD.PUSH_NOTIFY_TYPE, { value: style, transaction: String(Date.now()) }, ctx);
     }
   },
-  /**
-   * Three modes, and `FullColor` is the conditional one: a model without a spotlight or starlight
-   * sensor omits it, and the wire accepts the value regardless — the device's own reported set is the
-   * only statement of which of the three it has. `coerceEnumValue` rejects a value outside
-   * {@link NightVision} rather than coercing it. The payload key on the wire is `night_sion`.
-   *
-   * 1277 carries more than these three on some models: the V6 app's per-model mappings put modes on
-   * 3, 5, 6 and 8 as well, and which model takes which mapping is not in the app bundle. A reported value
-   * outside the published options reads as `undefined` rather than as an unnamed number.
-   */
+  /** Modes come from the thing description (`thing`); unlisted values read as `undefined`. */
   nightVision: {
     param: CAMERA_CMD.NIGHT_VISION_TYPE,
     type: "enum",
     kind: "enum",
-    enumValues: { 0: "Off", 1: "Infrared", 2: "Full Color" },
-    enumValuesFor: (ctx) => isT8442(ctx) ? { 0: "Off", 1: "Infrared" } : void 0,
+    enumValues: { 0: "Off", 1: "Infrared", 2: "Full Color", 3: "Infrared On" },
+    thing: ["nightvision_type_new", "nightvision_type"],
     provenance: "verified",
     available: isCameraCodec,
-    readAvailable: (ctx) => !isT8442(ctx),
-    readAliases: [{ paramType: 2002, available: isT8442 }],
-    description: "Night-vision mode: 0 = off, 1 = infrared (B&W), 2 = full colour where supported. T8425 uses NIGHT_VISION_TYPE 1277 (1350 SET_PAYLOAD, night_sion); T8442 reports 2002 and writes direct IC_NIGHT_VISION_TYPE 1013 (int-string, 0/1). Both wires verified live.",
+    readAvailable: (ctx) => !readsNightVisionOn2002(ctx),
+    readAliases: [{ paramType: 2002, available: readsNightVisionOn2002 }],
+    coerce: (raw) => raw === "true" ? 1 : raw === "false" ? 0 : Number(raw),
+    description: "Night-vision mode: 0 = off, 1 = infrared by light level, 2 = full colour, 3 = infrared held on. Written on 1277 (1350 SET_PAYLOAD, night_sion), or on 1013 as a bare [channel][value] when the device reports 2002.",
     write: (v, ctx) => {
       const nv = coerceEnumValue(NightVision, v);
       if (nv == null)
         return void 0;
-      if (isT8442(ctx)) {
-        if (nv === NightVision.FullColor)
-          throw new Error("nightVision: Full Color is not supported on T8442 (only Off/Infrared)");
-        return setScalar(CAMERA_CMD.IC_NIGHT_VISION_TYPE, nv, ctx, "int-string");
-      }
+      if (readsNightVisionOn2002(ctx))
+        return setScalar(CAMERA_CMD.IC_NIGHT_VISION_TYPE, nv, ctx, "int-pair");
+      if (nv === NightVision.InfraredOn)
+        throw new Error("nightVision: Infrared On has no verified write on this model");
       return setPayload(CAMERA_CMD.NIGHT_VISION_TYPE, { channel: ctx.channel, night_sion: nv }, ctx, 0, 0, "auto");
     }
   },
@@ -7573,29 +7428,330 @@ var PTZ = {
   }
 };
 
+// dist/model/capabilities/contact.js
+var CONTACT_CMD = {
+  /** Contact state (`APP_CMD_ENTRY_SENSOR_STATUS`, identifier `sensor_door_status`). */
+  STATUS: 1550,
+  /** Removed from its mount (`APP_CMD_DEV_DISASSEMBLE`, identifier `sensor_disassemble_status`). */
+  TAMPER: 61015,
+  /** Bypassed by the alarm (`APP_CMD_DEV_ENTRY_BYPASS`, identifier `sensor_door_bypass_status`). */
+  BYPASS: 61016,
+  /** Left-open alert (`APP_CMD_SENSOR_OPEN_STATUS_ALERT`, identifier `sensor_door_open_status_alert_config`). */
+  OPEN_ALERT: 1290,
+  /** Daily state check (`APP_CMD_SENSOR_DOOR_DAILY_CHECK`, identifier `sensor_door_daily_check_status_config`). */
+  DAILY_CHECK: 1291,
+  /** Alarm tone (`APP_CMD_ALARM_SOUND_TYPE`, identifier `device_alarm_sound_type`). */
+  ALARM_SOUND_TYPE: 1507,
+  /** Alarm volume (`APP_CMD_ALARM_VOLUME_VALUE`, identifier `alarm_volume_value`). */
+  ALARM_VOLUME: 1508
+};
+var SENSOR_STATUS_CMD = 1829;
+var OPEN_ALERT_MINUTES = [5, 10, 15, 30, 60];
+var ALARM_TONES = { None: 0, Water: 1, Classics: 2, Light: 3, Ding: 4 };
+var ALARM_VOLUME_MIN = 1;
+var ALARM_VOLUME_MAX = 26;
+var described = (identifier) => (ctx) => !ctx.things || identifier in ctx.things.properties;
+function statusParam(signal, paramType) {
+  if (signal.source !== "p2p-frame" || signal.json?.cmd !== SENSOR_STATUS_CMD)
+    return void 0;
+  const params = signal.json.payload?.params;
+  if (!Array.isArray(params))
+    return void 0;
+  const hit = params.find((p) => p?.param_type === paramType);
+  return hit?.param_value == null ? void 0 : String(hit.param_value);
+}
+function contactOpen(raw) {
+  return raw == null || raw === "" ? {} : { open: String(raw) === "1" };
+}
+function config(raw) {
+  if (typeof raw !== "string" || !raw)
+    return void 0;
+  try {
+    const parsed = JSON.parse(Buffer.from(raw, "base64").toString("utf8"));
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : void 0;
+  } catch {
+    return void 0;
+  }
+}
+var hhmm = (minutes) => `${String(Math.floor(minutes / 60)).padStart(2, "0")}:${String(minutes % 60).padStart(2, "0")}`;
+function minutesOf(time) {
+  const m = /^(\d{1,2}):(\d{2})$/.exec(time);
+  if (!m)
+    return void 0;
+  const [h, min] = [Number(m[1]), Number(m[2])];
+  return h < 24 && min < 60 ? h * 60 + min : void 0;
+}
+var CONTACT_MEMBERS = {
+  /**
+   * The headline read: `true` when the door or window is open. Every inbound source normalises through
+   * `contactOpen`, so the poll, the push and the station notify cannot disagree about what open means.
+   * Reporting 1550 is also this capability's detection evidence.
+   */
+  open: {
+    param: CONTACT_CMD.STATUS,
+    property: "contact",
+    type: "bool",
+    kind: "boolean",
+    provenance: "verified",
+    description: "Contact state, true=open (1550, sensor_door_status)."
+  },
+  /** The sensor was removed from its mount. Reported by a T8900; the meaning of a set value is the product bundle's. */
+  tampered: {
+    param: CONTACT_CMD.TAMPER,
+    type: "bool",
+    kind: "boolean",
+    provenance: "apk",
+    description: "Removed from its mount (61015, sensor_disassemble_status)."
+  },
+  /** The alarm currently skips this sensor. Reported by a T8900; the meaning of a set value is the product bundle's. */
+  bypassed: {
+    param: CONTACT_CMD.BYPASS,
+    type: "bool",
+    kind: "boolean",
+    provenance: "apk",
+    description: "Bypassed by the alarm (61016, sensor_door_bypass_status)."
+  },
+  /**
+   * The left-open alert config, whole as the sensor stores it (base64 JSON). Its two fields are the
+   * members below; both are set together by `setOpenAlert`, since one frame carries both.
+   */
+  openAlertConfig: {
+    param: CONTACT_CMD.OPEN_ALERT,
+    type: "string",
+    kind: "text",
+    provenance: "verified",
+    unexposed: true,
+    writtenElsewhere: true,
+    description: "Left-open alert config, base64 JSON {door_enable,door_time_point} (1290)."
+  },
+  /** Whether a notification fires when the door stays open longer than {@link CONTACT_MEMBERS.openAlertMinutes}. */
+  openAlert: {
+    readsFrom: "openAlertConfig",
+    type: "bool",
+    kind: "boolean",
+    provenance: "verified",
+    decode: (raw) => {
+      const c = config(raw);
+      return c === void 0 ? void 0 : asBool(c.door_enable);
+    },
+    description: "Left-open alert on (1290 door_enable). Set with setOpenAlert."
+  },
+  /** How long the door may stay open before the alert fires: one of 5, 10, 15, 30 or 60 minutes. */
+  openAlertMinutes: {
+    readsFrom: "openAlertConfig",
+    type: "number",
+    kind: "scalar",
+    provenance: "verified",
+    decode: (raw) => {
+      const n = Number(config(raw)?.door_time_point);
+      return Number.isInteger(n) ? n : void 0;
+    },
+    description: "Left-open alert delay, minutes: 5, 10, 15, 30 or 60 (1290 door_time_point)."
+  },
+  /** The daily state check config, whole (base64 JSON); its fields are the members below. */
+  dailyCheckConfig: {
+    param: CONTACT_CMD.DAILY_CHECK,
+    type: "string",
+    kind: "text",
+    provenance: "verified",
+    unexposed: true,
+    writtenElsewhere: true,
+    description: "Daily check config, base64 JSON {door_enable,door_time_interval} (1291)."
+  },
+  /** Whether the sensor's state is notified at each of {@link CONTACT_MEMBERS.dailyCheckTimes}. */
+  dailyCheck: {
+    readsFrom: "dailyCheckConfig",
+    type: "bool",
+    kind: "boolean",
+    provenance: "verified",
+    decode: (raw) => {
+      const c = config(raw);
+      return c === void 0 ? void 0 : asBool(c.door_enable);
+    },
+    description: "Daily state check on (1291 door_enable). Set with setDailyCheck."
+  },
+  /** The times of day the state is notified, `HH:MM` comma-separated in the order the sensor holds them. */
+  dailyCheckTimes: {
+    readsFrom: "dailyCheckConfig",
+    type: "string",
+    kind: "text",
+    provenance: "verified",
+    decode: (raw) => {
+      const times = config(raw)?.door_time_interval;
+      return Array.isArray(times) ? times.map((t) => hhmm(Number(t) || 0)).join(",") : void 0;
+    },
+    description: "Daily check times, HH:MM comma-separated (1291 door_time_interval, minutes since midnight)."
+  },
+  /**
+   * Turn the left-open alert on or off, with its delay. One frame carries both: `1350` SET_PAYLOAD,
+   * sub-command 1290, `{door_enable, door_time_point}` — the product's settings bundle's own frame.
+   * Verified live on a T8900: param 1290 read back the written value and the app showed it.
+   */
+  setOpenAlert: method(({ ctx, sink }) => async (on, minutes) => {
+    if (!OPEN_ALERT_MINUTES.includes(minutes)) {
+      throw new Error(`openAlertMinutes: ${String(minutes)} is not one of ${OPEN_ALERT_MINUTES.join(", ")}`);
+    }
+    await sink.dispatch(setPayload(CONTACT_CMD.OPEN_ALERT, { door_enable: asBool(on) ? 1 : 0, door_time_point: minutes }, ctx, 0));
+  }, "Set the left-open alert and its delay (5, 10, 15, 30 or 60 minutes), which share one wire."),
+  /**
+   * Turn the daily state check on or off, with its times of day. One frame carries both: `1350`
+   * SET_PAYLOAD, sub-command 1291, `{door_enable, door_time_interval}` with each time as minutes since
+   * midnight — the product's settings bundle's own frame.
+   * Verified live on a T8900: param 1291 read back the written times and the app showed them.
+   */
+  setDailyCheck: method(({ ctx, sink }) => async (on, times) => {
+    const minutes = times.map(minutesOf);
+    if (minutes.some((m) => m === void 0)) {
+      throw new Error(`dailyCheckTimes: ${times.join(",")} must all be HH:MM`);
+    }
+    await sink.dispatch(setPayload(CONTACT_CMD.DAILY_CHECK, { door_enable: asBool(on) ? 1 : 0, door_time_interval: minutes }, ctx, 0));
+  }, "Set the daily state check and its times of day (HH:MM), which share one wire."),
+  /**
+   * The built-in alarm tone, offered where the product's description lists it: a sensor may report the
+   * param while the app offers no such setting on it. Rejected, not clamped, outside the listed tones.
+   * Write: a direct-binary scalar `[ch][value][acct]` at signCode 8, captured live on a T90E0.
+   */
+  alarmSoundType: {
+    param: CONTACT_CMD.ALARM_SOUND_TYPE,
+    type: "enum",
+    kind: "enum",
+    enumValues: enumLabels(ALARM_TONES),
+    thing: ["device_alarm_sound_type"],
+    provenance: "verified",
+    available: described("device_alarm_sound_type"),
+    args: [{ name: "tone", kind: "enum", description: "Silent (0) or one of the four tones." }],
+    description: "Alarm tone (1507, device_alarm_sound_type): 0=None,1=Water,2=Classics,3=Light,4=Ding.",
+    write: (v, ctx) => {
+      const tone = coerceEnumValue(ALARM_TONES, v);
+      return tone === void 0 ? void 0 : setScalar(CONTACT_CMD.ALARM_SOUND_TYPE, tone, ctx, "auto");
+    }
+  },
+  /**
+   * The built-in alarm volume, a device level 1-26, offered where the product's description lists it.
+   * Write: `1350` SET_PAYLOAD with `mChannel` the device channel, `mValue3` 0, payload `{channel, volume,
+   * transaction}` — the app's own captured frame on a T90E0. Out of range is refused, not clamped.
+   */
+  alarmVolume: {
+    param: CONTACT_CMD.ALARM_VOLUME,
+    type: "number",
+    kind: "scalar",
+    provenance: "verified",
+    available: described("alarm_volume_value"),
+    min: ALARM_VOLUME_MIN,
+    max: ALARM_VOLUME_MAX,
+    args: [
+      { name: "level", kind: "scalar", min: ALARM_VOLUME_MIN, max: ALARM_VOLUME_MAX, description: "A device level." }
+    ],
+    description: "Alarm volume (1508, alarm_volume_value), a device level 1-26, not a percentage.",
+    write: (v, ctx) => {
+      const level = Number(v);
+      return Number.isInteger(level) && level >= ALARM_VOLUME_MIN && level <= ALARM_VOLUME_MAX ? setPayload(CONTACT_CMD.ALARM_VOLUME, { channel: ctx.channel, volume: level, transaction: String(Date.now()) }, ctx, 0) : void 0;
+    }
+  }
+};
+var CONTACT = {
+  capability: "contact",
+  description: "Entry (door/window) sensor: contact state, tamper and bypass, the left-open alert and the daily state check, and the built-in alarm where the product has one.",
+  members: CONTACT_MEMBERS,
+  properties: propertiesOf(CONTACT_MEMBERS),
+  /** A reported entry-sensor contact param (1550) is the verified proof of a contact sensor. */
+  detection: { evidenceParams: [CONTACT_CMD.STATUS] },
+  /**
+   * Inbound `contactState`: the contact param changing on a cloud poll, and the FCM door-sensor push
+   * (`CusPushEvent.DOOR_SENSOR`), whose state is the single-letter `e` — both verified live on a T8900.
+   */
+  events: [
+    {
+      source: "poll",
+      match: CONTACT_CMD.STATUS,
+      emit: "contactState",
+      derive: (s) => contactOpen(s.source === "poll" ? s.to : void 0)
+    },
+    {
+      source: "push",
+      match: CusPushEvent.DOOR_SENSOR,
+      emit: "contactState",
+      derive: (s) => contactOpen(s.source === "push" ? s.payload?.["e"] : void 0)
+    }
+  ],
+  /**
+   * One door movement reaches the SDK up to three times — the station notify, the same value as a push
+   * ~2 s later, then again on the next poll — so `contactState` is announced on a change only.
+   */
+  stateEvents: [{ event: "contactState", field: "open" }],
+  /**
+   * The station's own notify, the fastest contact signal and the only one that needs no cloud. A
+   * declarative `events` row matches a push id or a poll param, not a param nested in a frame's
+   * `params` array under an inner command, hence the decode hook. A notify without the contact param
+   * (battery or signal only) emits nothing.
+   */
+  decodeEvent(signal) {
+    const raw = statusParam(signal, CONTACT_CMD.STATUS);
+    if (raw === void 0)
+      return null;
+    return { event: "contactState", payload: contactOpen(raw) };
+  }
+};
+
 // dist/model/capabilities/leak.js
+var LEAK_PARAM = {
+  /** Water detected (`APP_CMD_WATER_SENSOR_WATER_STATE`, identifier `sensor_water_status`). */
+  WATER: 1820,
+  /** Temperature below the threshold (`APP_CMD_WATER_SENSOR_TEMPERATE_LOW`, `sensor_temperature_low_status`). */
+  LOW_TEMPERATURE: 1822,
+  /** Low-temperature alarm threshold, °F (`APP_CMD_WATER_SENSOR_TEMPERATURE_ALARM`). */
+  LOW_TEMPERATURE_THRESHOLD: 1873
+};
 var LEAK_MEMBERS = {
   /**
-   * The alarm flag, modelled as state even though the sensor announces a leak as a PUSH EVENT rather
-   * than by holding a param — so 1560 is a `guessed` placeholder and the evidence gate will normally
-   * leave this getter uninstalled. The push event is the reliable channel for a leak; this read is
-   * here so the flag has a home once a capture pins a real id.
+   * Water is detected. The app's own `event_sensor_water_detected_notify` is this param changing, so
+   * the state and the alert are one fact.
    */
   leakDetected: {
-    param: 1560,
+    param: LEAK_PARAM.WATER,
     type: "bool",
     kind: "boolean",
-    provenance: "guessed",
-    description: "Water-leak detected. UNVERIFIED: actually delivered as a push event, not a state param; placeholder id pending capture verification."
+    provenance: "apk",
+    description: "Water detected (1820, sensor_water_status)."
+  },
+  /** The temperature is below {@link LEAK_MEMBERS.lowTemperatureThreshold}: the freeze alarm. */
+  lowTemperature: {
+    param: LEAK_PARAM.LOW_TEMPERATURE,
+    type: "bool",
+    kind: "boolean",
+    provenance: "apk",
+    description: "Temperature below the alarm threshold (1822, sensor_temperature_low_status)."
+  },
+  /**
+   * The temperature, in °F, below which the freeze alarm fires: one of 32, 33, 35, 37 or 40 as the
+   * product's description lists them. The write is the bundle's `1350` SET_PAYLOAD on 1873, not yet run
+   * on a device, so no setter is installed.
+   */
+  lowTemperatureThreshold: {
+    param: LEAK_PARAM.LOW_TEMPERATURE_THRESHOLD,
+    type: "number",
+    kind: "enum",
+    enumValues: { 32: "32\xB0F", 33: "33\xB0F", 35: "35\xB0F", 37: "37\xB0F", 40: "40\xB0F" },
+    thing: ["sensor_low_temperature_alarm_threshold"],
+    provenance: "apk",
+    unverified: true,
+    description: "Freeze alarm threshold, \xB0F: 32, 33, 35, 37 or 40 (1873, sensor_low_temperature_alarm_threshold)."
   }
 };
 var LEAK = {
   capability: "leak",
-  description: "Water-leak / freeze sensor alarm state.",
+  description: "Water-leak and freeze sensor: water and low-temperature state, and the freeze threshold.",
   members: LEAK_MEMBERS,
   properties: propertiesOf(LEAK_MEMBERS),
-  // Leak sensors expose no stable state param; the model/name (water/leak/freeze) is the signal.
-  detection: { modelHints: [/water|leak|freeze/i] }
+  /**
+   * A reported water-state param (1820) proves a water sensor, as does a product description listing
+   * `sensor_water_status` — the app's own definition of one, which holds before the sensor has reported.
+   * Never the device's name: that is what its owner typed.
+   */
+  detection: {
+    evidenceParams: [LEAK_PARAM.WATER],
+    detect: (rec) => rec.things !== void 0 && "sensor_water_status" in rec.things.properties
+  }
 };
 
 // dist/model/capabilities/smoke.js
@@ -8153,16 +8309,16 @@ function armingCommand(mode, ctx) {
   }
   return setPayload(ARMING_CMD.SET_ARMING, { mode_type: ARMING_MODE_WIRE[mode], user_name: ctx.accountName }, ctx, 0, void 0, "auto");
 }
-function alarmDelayCommand(mode, config, ctx) {
+function alarmDelayCommand(mode, config2, ctx) {
   const data = {
     mode_id: ARMING_MODE_WIRE[mode],
     count_down_alarm: {
-      channel_list: config.countDownAlarm.channelList,
-      delay_time: config.countDownAlarm.delaySeconds
+      channel_list: config2.countDownAlarm.channelList,
+      delay_time: config2.countDownAlarm.delaySeconds
     },
-    count_down_arm: { channel_list: config.countDownArm.channelList, delay_time: config.countDownArm.delaySeconds },
-    devices: config.devices.map((d) => ({ action: d.action, device_channel: d.deviceChannel })),
-    siren_sensor_action: config.sirenSensorAction.map((d) => ({ action: d.action, device_channel: d.deviceChannel }))
+    count_down_arm: { channel_list: config2.countDownArm.channelList, delay_time: config2.countDownArm.delaySeconds },
+    devices: config2.devices.map((d) => ({ action: d.action, device_channel: d.deviceChannel })),
+    siren_sensor_action: config2.sirenSensorAction.map((d) => ({ action: d.action, device_channel: d.deviceChannel }))
   };
   return setJsonRaw(ARMING_CMD.SET_ALL_ACTION, data, ctx, STATION_CHANNEL2);
 }
@@ -8232,9 +8388,9 @@ var ARMING_MEMBERS = {
    * that integer in `mode_id` with no runtime validation and no readback, so a mode outside this union
    * would be the same unverified guess `setMode` refuses.
    */
-  setAlarmDelayConfig: method(({ ctx, sink }) => (mode, config) => {
+  setAlarmDelayConfig: method(({ ctx, sink }) => (mode, config2) => {
     try {
-      return sink.dispatch(alarmDelayCommand(mode, config, ctx));
+      return sink.dispatch(alarmDelayCommand(mode, config2, ctx));
     } catch (e) {
       return Promise.reject(e);
     }
@@ -12857,6 +13013,16 @@ var SECURITY_PARAMS = {
     type: "bool",
     provenance: "apk"
   },
+  1820: {
+    name: "waterSensorWaterState",
+    type: "bool",
+    provenance: "apk"
+  },
+  1822: {
+    name: "waterSensorTemperatureLow",
+    type: "bool",
+    provenance: "apk"
+  },
   1825: {
     name: "sirenSensorSetAlarmVol",
     type: "number",
@@ -12867,6 +13033,11 @@ var SECURITY_PARAMS = {
     type: "bool",
     provenance: "apk"
   },
+  1873: {
+    name: "waterSensorTemperatureAlarm",
+    type: "number",
+    provenance: "apk"
+  },
   2001: {
     name: "paramTypeOpenDevice",
     type: "string",
@@ -22106,7 +22277,7 @@ var Fmp4Muxer = class {
     return box("stbl", box("stsd", Buffer.concat([u32(0), u32(1), this.sampleEntry()])), box("stts", Buffer.concat([u32(0), u32(0)])), box("stsc", Buffer.concat([u32(0), u32(0)])), box("stsz", Buffer.concat([u32(0), u32(0), u32(0)])), box("stco", Buffer.concat([u32(0), u32(0)])));
   }
   sampleEntry() {
-    const { sample, config } = CODEC_BOXES[this.codec];
+    const { sample, config: config2 } = CODEC_BOXES[this.codec];
     const head = Buffer.alloc(78);
     head.writeUInt16BE(1, 6);
     head.writeUInt16BE(this.width, 24);
@@ -22116,7 +22287,7 @@ var Fmp4Muxer = class {
     head.writeUInt16BE(1, 40);
     head.writeUInt16BE(24, 74);
     head.writeInt16BE(-1, 76);
-    const cfg = box(config, this.codec === "h264" ? this.avcC() : this.hvcC());
+    const cfg = box(config2, this.codec === "h264" ? this.avcC() : this.hvcC());
     return box(sample, Buffer.concat([head, cfg]));
   }
   avcC() {
@@ -22263,8 +22434,8 @@ var Fmp4Muxer = class {
     return box("mp4a", head, this.esds());
   }
   esds() {
-    const config = this.audioConfig ?? Buffer.from([20, 8]);
-    const specific = descriptor(5, config);
+    const config2 = this.audioConfig ?? Buffer.from([20, 8]);
+    const specific = descriptor(5, config2);
     const decoder = descriptor(4, Buffer.concat([Buffer.from([64, 21, 0, 0, 0]), u32(64e3), u32(32e3), specific]));
     const sl = descriptor(6, Buffer.from([2]));
     return box("esds", u32(0), descriptor(3, Buffer.concat([u16(2), Buffer.from([0]), decoder, sl])));
@@ -22497,6 +22668,7 @@ function stationChannels(devices) {
 
 // dist/transport/p2p/command-router.js
 var DIRECT_CMD_SENDS = 5;
+var STATION_TABLE_QUERY = Buffer.from("ff00000087030000", "hex");
 var LEVEL2_GRACE_MS = 25e3;
 var KEEP_LEVEL1_SESSION_MODELS = /* @__PURE__ */ new Set(["T8423"]);
 var P2P_STATION_WAITS = {
@@ -22881,7 +23053,10 @@ var P2PCommandRouter = class _P2PCommandRouter {
         return;
       this.tearDownStation(stationSn);
     });
-    session.on("level2Ready", ({ cipherId }) => this.deps.onLevel2Ready(stationSn, cipherId));
+    session.on("level2Ready", ({ cipherId }) => {
+      session.sendRawLevel2Bytes(STATION_TABLE_QUERY, 0, P2P_ENVELOPE.GET_CAMERA_INFO, 8);
+      this.deps.onLevel2Ready(stationSn, cipherId);
+    });
     session.on("peerAnswer", (atMs) => {
       if (this.manager.get(stationSn) === session)
         this.deps.onPeerAnswer?.(stationSn, atMs);
@@ -23717,11 +23892,11 @@ var P2PCommandRouter = class _P2PCommandRouter {
    * Resolve a scalar `"set-param"` intent to a concrete P2P frame — the ONE place that maps a
    * capability's *what* (param + value + {@link ScalarForm}) to the *how* (encryption level + wire):
    * `"auto"` defers the level to {@link sendBySessionLevel} — the ONE decision point — while
-   * `"int-string"` pins L1 and `"direct-binary"` pins L2.
+   * `"int-string"` and `"int-pair"` pin L1 and `"direct-binary"` pins L2.
    */
   async resolveScalarParam(sn, param, value, form) {
-    if (form === "int-string") {
-      await this.sendIntStringCommand(sn, param, value);
+    if (form === "int-string" || form === "int-pair") {
+      await this.sendIntStringCommand(sn, param, value, form);
       return;
     }
     if (form === "direct-binary") {
@@ -24348,10 +24523,10 @@ var P2PCommandRouter = class _P2PCommandRouter {
    * SoloCam-spotlight / Cam2C-3). No level-2 key needed (standalone level-1 ECB). Fire-and-forget,
    * repeated for RF resilience.
    */
-  async sendIntStringCommand(sn, outerCmd, value) {
+  async sendIntStringCommand(sn, outerCmd, value, form) {
     const { session, channel, accountId } = await this.resolveSession(sn);
     for (let i = 0; i < DIRECT_CMD_SENDS; i++) {
-      session.sendIntStringCommand(outerCmd, value, channel, accountId, channel);
+      session.sendIntStringCommand(outerCmd, value, channel, form === "int-pair" ? "" : accountId, channel);
       await sleep2(200);
     }
   }
@@ -24371,9 +24546,8 @@ var P2PCommandRouter = class _P2PCommandRouter {
       mValue3: 0,
       payload: { switch: enabled ? 1 : 0 }
     }), "utf-8");
-    const camInfoPre = Buffer.from("ff00000087030000", "hex");
     const gap = () => sleep2(150);
-    session.sendRawLevel2Bytes(camInfoPre, 255, P2P_ENVELOPE.GET_CAMERA_INFO, 8);
+    session.sendRawLevel2Bytes(STATION_TABLE_QUERY, 255, P2P_ENVELOPE.GET_CAMERA_INFO, 8);
     await gap();
     for (let i = 0; i < 2; i++) {
       session.sendRawLevel2Bytes(setJson2, 0, P2P_ENVELOPE.SET_PAYLOAD, 8);
@@ -24383,7 +24557,7 @@ var P2PCommandRouter = class _P2PCommandRouter {
       session.sendRawLevel2Bytes(setJson2, channel, P2P_ENVELOPE.SET_PAYLOAD, 8);
       await gap();
     }
-    session.sendRawLevel2Bytes(camInfoPre, 0, P2P_ENVELOPE.GET_CAMERA_INFO, 8);
+    session.sendRawLevel2Bytes(STATION_TABLE_QUERY, 0, P2P_ENVELOPE.GET_CAMERA_INFO, 8);
   }
   /**
    * Route a control command (`{commandType, data}`) to a device over P2P: HomeBase-attached →
@@ -25136,7 +25310,7 @@ async function loadNativePeerFactory() {
     const message = UNBUILT_ARCHES.has(process.arch) ? `the WebRTC transport for a HomeBase S1 Pro (T9000) needs 'node-datachannel', which has no build for ${process.arch}; a 64-bit OS is needed to drive a T9000` : "the WebRTC transport for a HomeBase S1 Pro (T9000) could not load 'node-datachannel'";
     throw new Error(message, { cause: err });
   }
-  return (name, config) => new ndc.PeerConnection(name, config);
+  return (name, config2) => new ndc.PeerConnection(name, config2);
 }
 var ANSWER_TIMEOUT_MS = 15e3;
 var RtcPeer = class extends EventEmitter9 {
@@ -25168,13 +25342,13 @@ var RtcPeer = class extends EventEmitter9 {
     if (this.pc)
       return;
     const createPeer = this.opts.createPeer ?? await loadNativePeerFactory();
-    const config = {
+    const config2 = {
       iceServers: turnServers(turn),
       iceTransportPolicy: this.opts.iceTransportPolicy ?? "relay",
       maxMessageSize: ANKER_MAX_MESSAGE_SIZE,
       enableIceTcp: true
     };
-    const pc = createPeer("eufy-sdk", config);
+    const pc = createPeer("eufy-sdk", config2);
     this.pc = pc;
     pc.onLocalDescription((sdp, type) => {
       if (String(type).toLowerCase() === "answer" && this.localAnswer) {
@@ -27753,15 +27927,15 @@ var TuyaClient = class {
   endpoint;
   http;
   session;
-  constructor(config = {}) {
-    this.signer = config.signer ?? new HmacSigner();
-    this.env = config.env ?? DEFAULT_TUYA_ENV;
-    this.endpoint = config.endpoint;
-    this.http = config.http;
+  constructor(config2 = {}) {
+    this.signer = config2.signer ?? new HmacSigner();
+    this.env = config2.env ?? DEFAULT_TUYA_ENV;
+    this.endpoint = config2.endpoint;
+    this.http = config2.http;
     this.session = {
-      sid: config.sid ?? "",
-      deviceId: config.deviceId ?? genDeviceId(),
-      chKey: config.chKey ?? TUYA_CHKEY
+      sid: config2.sid ?? "",
+      deviceId: config2.deviceId ?? genDeviceId(),
+      chKey: config2.chKey ?? TUYA_CHKEY
     };
   }
   /** The current per-install session identity (sid empty until {@link login}). */
@@ -27924,9 +28098,9 @@ var TuyaCommandRouter = class {
    * `virtualId`, or the device's serial when the record carries none of them.
    */
   snMap = /* @__PURE__ */ new Map();
-  constructor(config = {}) {
-    this.allowUnverified = config.allowUnverified ?? false;
-    this.http = config.http;
+  constructor(config2 = {}) {
+    this.allowUnverified = config2.allowUnverified ?? false;
+    this.http = config2.http;
   }
   /**
    * Supply credentials for lazy Tuya login. Called by the facade after a successful mega login.
@@ -30804,7 +30978,7 @@ var EufyMega = class _EufyMega extends EventEmitter14 {
           return false;
         if (!device)
           return true;
-        device.applyParams(record.params ?? {});
+        this.applyAndAnnounce(device, rawValue === void 0 ? {} : { [refresh.param]: String(rawValue) });
         return this.matchesObservation(device.getProperty(refresh.property)?.value, refresh, before);
       };
       if (refresh.expected !== void 0 && settled())
@@ -33653,7 +33827,6 @@ export {
   EMPTY_DP_CATALOG,
   EUFYLIFE_LOCAL_KEY_HEX,
   EUFY_MEGA_LOCAL_KEY_HEX,
-  EntryAlarmTone,
   EufyCloudErrorCode,
   EufyMega,
   FCM,