@mega-yfue/eufy-sdk 0.5.0-beta.7 → 0.5.0-beta.9

package/dist/client/eufy-mega.d.ts

@@ -234,6 +234,11 @@ export declare class EufyMega extends EventEmitter {
      *
      * The evidence set is widened, never replaced: the ids come back through the cloud record, and a
      * record that omits a realtime-only id would otherwise un-know it and re-trigger on the next report.
+     *
+     * The device is re-resolved against the fresh record before binding. A property gated on a
+     * realtime-only param enters the schema only once that param is evidence, and the value that made it
+     * evidence was stored before the property existed, so the record's realtime params are applied again
+     * to land it under the property's name.
      */
     private rebindReads;
     /** The distinct credential scopes the current MQTT roster needs — no devices on a scope, no connection. */
@@ -835,11 +840,14 @@ export declare class EufyMega extends EventEmitter {
      */
     setProperty(sn: string, name: string, value: boolean | number | string): Promise<void>;
     /**
-     * Restart a HomeBase.
+     * Restart a station: a HomeBase, or a camera-family device that is its own station.
      *
-     * **HomeBases only** — restart is a hub operation, so a non-HomeBase serial (a camera, an NVR)
-     * throws rather than doing nothing. The hub drops its connection and returns after a minute or two,
-     * so everything behind it is briefly offline. Verified on real hardware.
+     * The restart is `RESTART_HUB` on the station's broadcast channel, so it reaches whatever owns the
+     * P2P session. A standalone camera or doorbell owns its own session and is the station it restarts.
+     * A camera attached to a HomeBase is not — the same frame would restart its HomeBase — so its serial
+     * throws, as does any non-camera serial, rather than doing nothing. The device drops its connection
+     * and returns after a minute or two; a HomeBase takes everything behind it offline meanwhile.
+     * Verified on real hardware against a HomeBase and a standalone indoor camera.
      */
     reboot(sn: string): Promise<void>;
     /**
@@ -857,6 +865,7 @@ export declare class EufyMega extends EventEmitter {
      * exactly the reads it has.
      */
     private fetchDpCatalog;
+    /** The {@link CommandContext} for a device, built from `known` when that record is already in hand. */
     private commandContext;
     /**
      * **Generic P2P request/reply query** — sends a `SET_PAYLOAD` sub-command and resolves with the

package/dist/index.js

@@ -11179,8 +11179,10 @@ function resolveDevice(rec) {
 }
 function resolveProperties(rec, codec, capabilities) {
   const paramIds = /* @__PURE__ */ new Set();
-  if (rec.params && typeof rec.params === "object") {
-    for (const k of Object.keys(rec.params)) {
+  for (const reported of [rec.params, rec.dpParams]) {
+    if (!reported || typeof reported !== "object")
+      continue;
+    for (const k of Object.keys(reported)) {
       const n = Number(k);
       if (Number.isFinite(n))
         paramIds.add(n);
@@ -16249,6 +16251,21 @@ var P2PSession = class _P2PSession extends EventEmitter2 {
     this.send(this.connectAddress, RequestMessageType.DATA, data);
     return true;
   }
+  /**
+   * The level-1 twin of {@link sendRawLevel2Bytes}: the plaintext `payload` sealed AES-128-ECB under the
+   * level-1 key, signCode 1 — the seal of the level-1 media start. Returns `false` when not connected.
+   */
+  sendRawLevel1Bytes(payload, channel, outerCmd) {
+    if (!this.connectAddress)
+      return false;
+    const data = Buffer.concat([
+      buildCommandHeader(this.seqNumber, outerCmd),
+      buildRawCommandPayload(encryptP2PData(paddingP2PData(payload), this.level1Key), channel, 1)
+    ]);
+    this.seqNumber = this.seqNumber + 1 & 65535;
+    this.send(this.connectAddress, RequestMessageType.DATA, data);
+    return true;
+  }
   /**
    * Stop the realtime media stream (`CMD_STOP_REALTIME_MEDIA`, 1004) on a camera `channel`, in the shape
    * its runtime topology takes, as {@link startLiveMedia} selects its start:
@@ -21197,14 +21214,20 @@ var P2PCommandRouter = class _P2PCommandRouter {
     }
   }
   /**
-   * Restart a HomeBase. `RESTART_HUB` (1034) is a station-scalar on the broadcast channel 255: a
-   * level-2 frame whose body is `[u32 value][account_id padded]` — the same shape as the hub
-   * alarm-volume control. ✅ Wire-confirmed byte-exact from a capture of the app's own Restart
-   * (2026-08-03) and HW-tested: the captured frame carried value `0` and rebooted the hub. Replays
-   * like every other level-2 control, so a single dropped datagram doesn't lose it.
+   * Restart the station that owns `sn`'s P2P session. `RESTART_HUB` (1034) is a station-scalar on the
+   * broadcast channel 255 whose body is `[u32 value][account_id padded]`, value `0`. ✅ Wire-confirmed
+   * byte-exact as a level-2 frame from a capture of the app's own HomeBase Restart (2026-08-03).
+   *
+   * The seal follows the session, as {@link sendBySessionLevel} defines it: a keyed session takes the
+   * level-2 frame, a keyless one — a standalone camera, which never negotiates a key — the same body
+   * sealed level-1. Both are replayed {@link DIRECT_CMD_SENDS}× at 200ms, as every other unacknowledged
+   * control here is.
    */
   async rebootStation(sn) {
-    await this.replayLevel2Send(sn, `reboot ${sn}`, ({ session, accountId }) => session.sendRawLevel2Bytes(buildDirectBinaryBody(0, accountId), 255, P2P_ENVELOPE.RESTART_HUB, 8));
+    await this.sendBySessionLevel(sn, {
+      l2: (resolved) => this.replayLevel2Send(sn, `reboot ${sn}`, ({ session, accountId }) => session.sendRawLevel2Bytes(buildDirectBinaryBody(0, accountId), 255, P2P_ENVELOPE.RESTART_HUB, 8), resolved),
+      l1: (resolved) => this.replayLevel2Send(sn, `reboot ${sn}`, ({ session, accountId }) => session.sendRawLevel1Bytes(buildDirectBinaryBody(0, accountId), 255, P2P_ENVELOPE.RESTART_HUB), resolved)
+    });
   }
   /**
    * A {@link MediaProvider} bound to one serial — resolves the session then calls `p2p/media`.
@@ -25983,13 +26006,22 @@ var EufyMega = class extends EventEmitter9 {
    *
    * The evidence set is widened, never replaced: the ids come back through the cloud record, and a
    * record that omits a realtime-only id would otherwise un-know it and re-trigger on the next report.
+   *
+   * The device is re-resolved against the fresh record before binding. A property gated on a
+   * realtime-only param enters the schema only once that param is evidence, and the value that made it
+   * evidence was stored before the property existed, so the record's realtime params are applied again
+   * to land it under the property's name.
    */
   async rebindReads(sn) {
     const dev = this.liveDevices.get(sn)?.deref();
     if (!dev)
       return;
     try {
-      const ctx = await this.commandContext(sn);
+      const rec = await this.registry.record(sn);
+      dev.reresolve(rec);
+      if (rec.dpParams)
+        this.applyAndAnnounce(dev, rec.dpParams);
+      const ctx = await this.commandContext(sn, rec);
       dev.bindActions(ctx, this.commandSinkFor(sn), this.mediaProviderFor(sn), this.ff09SettingsReaderFor(sn, ctx), rawDpCodec);
       this.boundParamIds.set(sn, /* @__PURE__ */ new Set([...this.boundParamIds.get(sn) ?? [], ...ctx.paramIds]));
       this.emit("deviceState", this.deviceState(sn));
@@ -27310,16 +27342,20 @@ var EufyMega = class extends EventEmitter9 {
     await this.commandSinkFor(sn).dispatch(cmd);
   }
   /**
-   * Restart a HomeBase.
+   * Restart a station: a HomeBase, or a camera-family device that is its own station.
    *
-   * **HomeBases only** — restart is a hub operation, so a non-HomeBase serial (a camera, an NVR)
-   * throws rather than doing nothing. The hub drops its connection and returns after a minute or two,
-   * so everything behind it is briefly offline. Verified on real hardware.
+   * The restart is `RESTART_HUB` on the station's broadcast channel, so it reaches whatever owns the
+   * P2P session. A standalone camera or doorbell owns its own session and is the station it restarts.
+   * A camera attached to a HomeBase is not — the same frame would restart its HomeBase — so its serial
+   * throws, as does any non-camera serial, rather than doing nothing. The device drops its connection
+   * and returns after a minute or two; a HomeBase takes everything behind it offline meanwhile.
+   * Verified on real hardware against a HomeBase and a standalone indoor camera.
    */
   async reboot(sn) {
     const ctx = await this.commandContext(sn);
-    if (!isHomeBase({ deviceType: ctx.deviceType, model: ctx.model })) {
-      throw new Error(`reboot: ${sn} is not a HomeBase (deviceType ${ctx.deviceType ?? "?"}, model ${ctx.model ?? "?"}) \u2014 restart is a hub-only operation`);
+    const standaloneCamera = ctx.codec === "camera" && this.p2p.stationKeyOf(sn) === sn;
+    if (!isHomeBase({ deviceType: ctx.deviceType, model: ctx.model }) && !standaloneCamera) {
+      throw new Error(`reboot: ${sn} is neither a HomeBase nor a standalone camera (deviceType ${ctx.deviceType ?? "?"}, model ${ctx.model ?? "?"}) \u2014 restart addresses the station that owns the P2P session`);
     }
     await this.p2p.rebootStation(sn);
   }
@@ -27351,8 +27387,9 @@ var EufyMega = class extends EventEmitter9 {
       return EMPTY_DP_CATALOG;
     }
   }
-  async commandContext(sn) {
-    const rec = await this.registry.record(sn);
+  /** The {@link CommandContext} for a device, built from `known` when that record is already in hand. */
+  async commandContext(sn, known) {
+    const rec = known ?? await this.registry.record(sn);
     const dev = this.registry.require(sn);
     const raw = dev.raw ?? {};
     const rawChannel = raw.device_channel;