@mega-yfue/eufy-sdk 0.4.0-beta.4 → 0.4.0-beta.6

package/dist/transport/mqtt/secure-mqtt.d.ts

@@ -99,28 +99,35 @@ export declare class SecureMqtt extends EventEmitter implements RealtimeTranspor
     private open;
     /**
      * Subscribe every inbound leg this device's line uses (see `topics.ts` — one `/res` for most lines,
-     * four topics for `eufy_life`).
+     * four topics for `eufy_life` and the clean line).
      *
-     * The grants are INSPECTED, not assumed: AWS IoT answers a policy-denied filter with a
-     * SUBACK_FAILURE (`0x80`) grant rather than failing the SUBSCRIBE, so subscribing with a credential
-     * whose scope doesn't cover the topic looks identical to success and then delivers nothing. A denied
-     * topic is reported via `error` naming the credential scope; only an all-denied device throws, so a
-     * line that grants its state channel but refuses (say) the OTA leg still works.
+     * The grants are INSPECTED, not assumed: AWS IoT refuses a policy-denied filter with a
+     * {@link SUBACK_FAILURE} grant rather than failing the connection. A denied topic is reported via
+     * `error` naming the credential scope; only an all-denied device throws, so a line that grants its
+     * state channel but refuses (say) a business leg still works.
      */
     subscribeDevice(device: EufyDevice): Promise<void>;
     /**
      * Subscribe to explicit topic filters, returning the topics that were granted. A scope-denied filter
-     * comes back with SUBACK_FAILURE rather than an error (AWS IoT quirk), so it is dropped from the result
-     * instead of throwing — callers that need every leg check the returned list. Used by lines whose topic
-     * vocabulary isn't the eufy `subscribeTopics` shape (e.g. Anker Solix `dt/{app}/{pn}/{sn}`).
+     * is dropped from the result instead of throwing — callers that need every leg check the returned
+     * list. Used by lines whose topic vocabulary isn't the eufy `subscribeTopics` shape (e.g. Anker Solix
+     * `dt/{app}/{pn}/{sn}`).
      */
     subscribe(topics: string[]): Promise<string[]>;
     /**
-     * Split SUBACK grants into granted vs scope-denied topics. AWS IoT marks a policy-denied filter with a
-     * SUBACK_FAILURE (`0x80`) grant rather than failing the SUBSCRIBE, so the two subscribe paths share
-     * this split and layer their own policy (drop vs report) on top.
+     * Subscribe each filter in a SUBSCRIBE of its own and split the outcome into granted vs refused.
+     *
+     * One request per filter because the MQTT engine treats a SUBACK as all-or-nothing: one refused grant
+     * rejects the whole request, and it forgets EVERY filter of that request for resubscription after a
+     * reconnect — so a batch holding one denied leg would lose the granted legs on the next drop. Alone,
+     * a refused filter costs only itself. A rejection that carries no SUBACK is a transport failure and
+     * is thrown.
+     *
+     * The cost is one SUBSCRIBE and one SUBACK per filter instead of one per device — four for a
+     * four-leg line. They are sent concurrently, so the wall-clock cost is one round trip. Folding them
+     * back into one request brings back the lost resubscription.
      */
-    private partitionGrants;
+    private subscribeEach;
     /**
      * Publish a raw payload to an MQTT topic (the command leg — `cmd/{app}/{pn}/{sn}/req`). The `body`
      * is a pre-built envelope the caller supplies (the command router builds it). QoS 1 by default (the

package/dist/transport/p2p/p2p-session.d.ts

@@ -95,6 +95,8 @@ export declare class P2PSession extends EventEmitter {
     private connected;
     private connecting;
     private closed;
+    /** Whether a short receive buffer has been reported, so a reconnect does not repeat the same warning. */
+    private receiveBufferReported;
     private connectAddress?;
     private seqNumber;
     /**
@@ -274,6 +276,14 @@ export declare class P2PSession extends EventEmitter {
      */
     private decryptLevel2;
     get isConnected(): boolean;
+    /**
+     * Ask the OS for {@link RECEIVE_BUFFER_BYTES} on a bound socket, and warn once per session when it grants
+     * less or refuses.
+     *
+     * The request is made here rather than through `createSocket`'s `recvBufferSize`: Node applies that option
+     * inside the bind callback, where a refusal is thrown out of reach of this session and ends the process.
+     */
+    private requestReceiveBuffer;
     /** Open the socket and start the lookup → hole-punch handshake. */
     connect(): Promise<void>;
     /** Cached across every `P2PSession` in this process — the local outbound IPv4 doesn't vary by

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mega-yfue/eufy-sdk",
-  "version": "0.4.0-beta.4",
+  "version": "0.4.0-beta.6",
   "description": "One typed TypeScript client for the Anker eufy v6 cloud — capability-driven devices, realtime events over P2P/MQTT/push, and live media",
   "license": "Apache-2.0",
   "author": "mega-yfue",