@mega-yfue/eufy-sdk 0.4.0-beta.0 → 0.4.0-beta.10

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;
     /**
@@ -134,7 +136,10 @@ export declare class P2PSession extends EventEmitter {
     private cloudLookup?;
     /** Local outbound IPv4 reported inside LOOKUP_WITH_KEY requests. */
     private selfHost?;
-    /** In-flight multi-datagram frame per data channel (see onData). */
+    /**
+     * In-flight multi-datagram frame per data channel (see reassemble): the payload gathered so far under its
+     * parsed header, or, without a header, the start of a frame header cut by the datagram boundary.
+     */
     private readonly pendingByDataType;
     /** Last delivered datagram sequence number per data type. */
     private readonly lastSeqByType;
@@ -271,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
@@ -643,7 +656,13 @@ export declare class P2PSession extends EventEmitter {
      */
     private abandonHole;
     private clearReorderTimer;
-    /** Reassemble one in-sequence datagram body into logical frames. */
+    /**
+     * Reassemble one in-sequence datagram body into logical frames.
+     *
+     * Frames are packed back to back, so a frame header can itself be cut by a datagram boundary. The start
+     * of a header left at the end of a datagram is carried into the next one rather than discarded; dropping
+     * it would lose that frame and every frame after it until a datagram happened to begin on a header.
+     */
     private reassemble;
     /**
      * Forget where each data type's sequence numbering had reached, and drop any half-reassembled frame.

package/dist/transport/p2p/shared-live-source.d.ts

@@ -16,7 +16,7 @@ export interface SharedLiveSourceOptions {
     makeStream: (ctx: {
         reassertWanted: () => boolean;
     }) => LiveStreamHandle;
-    /** No-consumer grace before teardown (default 8000ms). Distinct from the stream's keepalive. */
+    /** No-consumer grace before teardown (default 8000ms; 0 schedules teardown next tick). Distinct from the stream's keepalive. */
     lingerMs?: number;
     /** Per-consumer bounded queue depth; overflow → drop-to-keyframe (default 900 ≈ 30s @ 30fps). */
     maxQueue?: number;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mega-yfue/eufy-sdk",
-  "version": "0.4.0-beta.0",
+  "version": "0.4.0-beta.10",
   "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",
@@ -77,10 +77,10 @@
     "protobufjs": "^8.8.0"
   },
   "devDependencies": {
-    "@types/node": "^26.6.2",
+    "@types/node": "^26.6.3",
     "esbuild": "^0.28.2",
     "prettier": "^3.9.9",
     "typescript": "^7.0.2",
-    "vitest": "^5.0.1"
+    "vitest": "^5.0.2"
   }
 }