@mega-yfue/eufy-sdk 0.2.0-beta.28 → 0.2.0-beta.29

package/dist/model/solix-device.d.ts

@@ -123,12 +123,13 @@ export declare function discoverSolixDevices(client: SolixDeviceReader, opts?: {
 }): Promise<SolixDevice[]>;
 /**
  * Reduce a site "scene" snapshot to per-device telemetry readings — the BACKSTOP counterpart to the
- * realtime `ff09` decode. It emits only the fields the scene reliably carries that the fast MQTT frame
- * does NOT: `batteryTemperature` (the realtime frame's BMS blob is empty, so `solixReadings` withholds
- * it) and `batterySoc` (a cross-check/seed for the `0xa3` SOC). Each reading is shaped exactly like a
- * `SolixMqtt` `reading` event — `{ deviceSn, values }` — so a caller can feed it straight into
+ * realtime `ff09` decode. It emits the fields the scene reliably carries that the fast MQTT frame does
+ * NOT: `batteryTemperature` (the realtime frame's BMS blob is empty, so `solixReadings` withholds it),
+ * `batterySoc` (a cross-check/seed for the `0xa3` SOC), and `expansionPacks` — the count of ATTACHED
+ * add-on battery packs (0 on a standalone main unit). Each reading is shaped exactly like a `SolixMqtt`
+ * `reading` event — `{ deviceSn, values }` — so a caller can feed it straight into
  * {@link SolixDevice.applyReading} and broadcast it on the same path as a live frame. Entries with no
- * usable value are dropped, so a poll during a gap emits nothing rather than clobbering live values.
+ * usable value are dropped.
  */
 export declare function solarbankSceneReadings(scene: SolixSiteScene): {
     deviceSn: string;

package/dist/transport/p2p/command-router.d.ts

@@ -163,8 +163,6 @@ export declare class P2PCommandRouter {
     closeAll(): Promise<void>;
     /** This serial's loaded record, or `undefined` — the one place the cached list is searched by serial. */
     private recordFor;
-    /** The parent-station key a device's session lives under (its HomeBase, or itself if standalone). */
-    private stationKeyFor;
     /**
      * The parent-station serial a device serial's session lives under — the single source of truth for
      * session keying, used by the facade (e.g. to pre-warm the right station for an event). Returns the

package/dist/transport/p2p/live-trace.d.ts

@@ -180,6 +180,15 @@ export type LiveTrace =
     stationAdmin: "self" | "other" | "unstated";
     stationModel?: string;
 }
+/**
+ * The call's device has no usable channel on the station it resolved: its record states none (`missing`), or
+ * another device attached to the same station states the same one (`shared`). The call is refused with
+ * `DeviceChannelUnresolvedError` and nothing is sent.
+ */
+ | {
+    phase: "station-channel-unresolved";
+    issue: "missing" | "shared";
+}
 /** A shared source began warming, with the interval it re-issues on and the deadline it fails at. */
  | {
     phase: "warming";

package/dist/transport/p2p/station-channels.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Station topology and per-station channel addressing, from the device records alone.
+ *
+ * Both sides of the P2P wire key on a device's channel within its station: a media start and every
+ * per-channel command address it, and an inbound frame is attributed to the device on its channel. Resolving
+ * it once, here, keeps the two sides from ever disagreeing about which device a channel means.
+ *
+ * @module transport/p2p/station-channels
+ * @internal
+ */
+import type { EufyDevice } from "../../core/types.js";
+/**
+ * The station a device's traffic belongs to, from its cloud record and its own serial.
+ *
+ * `parent_sn` carries the parent on a HomeBase-attached device. `station_sn` is frequently absent there —
+ * empty on every attached sensor of a T8010 — and serves only as a fallback. An empty string states no
+ * station.
+ *
+ * A device naming no parent answers its own serial, so every device has a station.
+ */
+export declare function resolvedStationSn(raw: Record<string, unknown>, sn: string): string;
+/**
+ * The parent station a device's traffic belongs to — the session key the router opens and the station the
+ * frame resolver attributes by.
+ *
+ * `parent_sn` on the cloud record is the field that is actually populated for a HomeBase-attached device, so
+ * it wins; `stationSn` is frequently absent (observed empty on every attached sensor of a T8010), so keying on
+ * it alone silently resolves an attached device to ITSELF and no frame ever matches. Answering the device's
+ * OWN serial is what "stands alone" means.
+ */
+export declare function stationOf(dev: EufyDevice): string;
+/**
+ * A device's channel within its station, or why it has none. `shared` keeps the channel it `claimed`, so a
+ * frame arriving on it is known to belong to one of the claimants rather than to the station.
+ */
+export type StationChannel = {
+    channel: number;
+} | {
+    issue: "missing";
+} | {
+    issue: "shared";
+    claimed: number;
+};
+/**
+ * The channel each device is addressed by within its station.
+ *
+ * A standalone device is its own station, addressed by the channel its record states, or 0. An attached
+ * device has a channel only when its record states one that no other device attached to the same station
+ * also states. A missing channel names no device, and a channel two attached devices both state cannot say
+ * which of them it means, so either resolves to an issue rather than to a channel: guessing would address
+ * another device, streaming its video or attributing its frames under this serial. Every attached device
+ * counts towards a clash, whatever its kind, and the answer does not depend on list order.
+ */
+export declare function stationChannels(devices: readonly EufyDevice[]): Map<string, StationChannel>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mega-yfue/eufy-sdk",
-  "version": "0.2.0-beta.28",
+  "version": "0.2.0-beta.29",
   "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",