@camstack/sdk 1.2.8 → 1.2.10

package/dist/__tests__/subscribe-event-multiplex.spec.d.ts

@@ -0,0 +1,13 @@
+/**
+ * `subscribeEvent` fans one WS subscription out to N listeners.
+ *
+ * Measured on the viewer's boot: ~40 tRPC subscriptions before first paint,
+ * of which 24 were twelve camera cards subscribing to the SAME two motion
+ * categories and filtering by deviceId inside their own callbacks. Each was a
+ * separate handshake on a transport that does not batch.
+ *
+ * The tests exercise the real `System` with a stubbed tRPC client, so
+ * what is asserted is the number of `live.onEvent.subscribe` calls the SDK
+ * actually makes — not a mock of the deduping itself.
+ */
+export {};

package/dist/index.cjs

@@ -683,6 +683,17 @@ var System = class {
 	token;
 	_trpcClient;
 	_wsClient = null;
+	/**
+	* One underlying `live.onEvent` subscription per DISTINCT category, fanned
+	* out to every listener.
+	*
+	* Measured on the viewer's boot: ~40 subscriptions, of which 24 were twelve
+	* cameras subscribing to the SAME two motion categories and filtering by
+	* deviceId in their own callbacks. Each was its own WS handshake on a
+	* transport that does not batch. Deduping here needs no protocol change and
+	* no cooperation from callers — `subscribeEvent` keeps its exact shape.
+	*/
+	_eventSubs = /* @__PURE__ */ new Map();
 	mirror = null;
 	mirrorInit = null;
 	connected = false;
@@ -826,6 +837,7 @@ var System = class {
 		this.emitConnectionEvent("connecting");
 		this._wsClient?.close();
 		this.disposeMirror();
+		this.resetEventSubs();
 		this.connected = false;
 		this.connectedPromise = null;
 		this._trpcClient = this.buildTrpcClient();
@@ -1222,19 +1234,59 @@ var System = class {
 	* (`@camstack/types`) — passing a raw string works for forward-compat
 	* but loses type safety. The SDK forwards the value verbatim to the
 	* server's `live.onEvent` subscription.
+	*
+	* **N callers on one category share ONE subscription.** The caller's shape
+	* is unchanged, and it is not asked to coordinate: twelve camera cards each
+	* subscribing to the motion category and filtering by deviceId is the normal
+	* pattern, and it used to open twelve WS subscriptions.
 	*/
 	subscribeEvent(category, cb) {
-		const sub = this._trpcClient.live.onEvent.subscribe({ category }, { onData: (event) => {
-			try {
-				cb(event);
-			} catch {}
-		} });
+		const listener = cb;
+		let entry = this._eventSubs.get(category);
+		if (entry === void 0) {
+			const listeners = /* @__PURE__ */ new Set();
+			const sub = this._trpcClient.live.onEvent.subscribe({ category }, { onData: (event) => {
+				for (const fn of [...listeners]) try {
+					fn(event);
+				} catch {}
+			} });
+			entry = {
+				listeners,
+				unsubscribe: () => {
+					try {
+						sub.unsubscribe();
+					} catch {}
+				}
+			};
+			this._eventSubs.set(category, entry);
+		}
+		entry.listeners.add(listener);
+		let released = false;
 		return () => {
-			try {
-				sub.unsubscribe();
-			} catch {}
+			if (released) return;
+			released = true;
+			const current = this._eventSubs.get(category);
+			if (current === void 0) return;
+			current.listeners.delete(listener);
+			if (current.listeners.size === 0) {
+				current.unsubscribe();
+				this._eventSubs.delete(category);
+			}
 		};
 	}
+	/**
+	* Drop every shared subscription.
+	*
+	* Called when the tRPC client is rebuilt: the handles above belong to the
+	* OLD client and unsubscribing them is meaningless, while keeping them in
+	* the map would make the next `subscribeEvent` attach a listener to a dead
+	* socket and go silent — the worst outcome, because it looks like "no
+	* events happened".
+	*/
+	resetEventSubs() {
+		for (const entry of this._eventSubs.values()) entry.unsubscribe();
+		this._eventSubs.clear();
+	}
 	/** Direct tRPC client. Read once per call; rebuilt on `reconnect()`. */
 	get trpcClient() {
 		return this._trpcClient;

package/dist/index.js

@@ -682,6 +682,17 @@ var System = class {
 	token;
 	_trpcClient;
 	_wsClient = null;
+	/**
+	* One underlying `live.onEvent` subscription per DISTINCT category, fanned
+	* out to every listener.
+	*
+	* Measured on the viewer's boot: ~40 subscriptions, of which 24 were twelve
+	* cameras subscribing to the SAME two motion categories and filtering by
+	* deviceId in their own callbacks. Each was its own WS handshake on a
+	* transport that does not batch. Deduping here needs no protocol change and
+	* no cooperation from callers — `subscribeEvent` keeps its exact shape.
+	*/
+	_eventSubs = /* @__PURE__ */ new Map();
 	mirror = null;
 	mirrorInit = null;
 	connected = false;
@@ -825,6 +836,7 @@ var System = class {
 		this.emitConnectionEvent("connecting");
 		this._wsClient?.close();
 		this.disposeMirror();
+		this.resetEventSubs();
 		this.connected = false;
 		this.connectedPromise = null;
 		this._trpcClient = this.buildTrpcClient();
@@ -1221,19 +1233,59 @@ var System = class {
 	* (`@camstack/types`) — passing a raw string works for forward-compat
 	* but loses type safety. The SDK forwards the value verbatim to the
 	* server's `live.onEvent` subscription.
+	*
+	* **N callers on one category share ONE subscription.** The caller's shape
+	* is unchanged, and it is not asked to coordinate: twelve camera cards each
+	* subscribing to the motion category and filtering by deviceId is the normal
+	* pattern, and it used to open twelve WS subscriptions.
 	*/
 	subscribeEvent(category, cb) {
-		const sub = this._trpcClient.live.onEvent.subscribe({ category }, { onData: (event) => {
-			try {
-				cb(event);
-			} catch {}
-		} });
+		const listener = cb;
+		let entry = this._eventSubs.get(category);
+		if (entry === void 0) {
+			const listeners = /* @__PURE__ */ new Set();
+			const sub = this._trpcClient.live.onEvent.subscribe({ category }, { onData: (event) => {
+				for (const fn of [...listeners]) try {
+					fn(event);
+				} catch {}
+			} });
+			entry = {
+				listeners,
+				unsubscribe: () => {
+					try {
+						sub.unsubscribe();
+					} catch {}
+				}
+			};
+			this._eventSubs.set(category, entry);
+		}
+		entry.listeners.add(listener);
+		let released = false;
 		return () => {
-			try {
-				sub.unsubscribe();
-			} catch {}
+			if (released) return;
+			released = true;
+			const current = this._eventSubs.get(category);
+			if (current === void 0) return;
+			current.listeners.delete(listener);
+			if (current.listeners.size === 0) {
+				current.unsubscribe();
+				this._eventSubs.delete(category);
+			}
 		};
 	}
+	/**
+	* Drop every shared subscription.
+	*
+	* Called when the tRPC client is rebuilt: the handles above belong to the
+	* OLD client and unsubscribing them is meaningless, while keeping them in
+	* the map would make the next `subscribeEvent` attach a listener to a dead
+	* socket and go silent — the worst outcome, because it looks like "no
+	* events happened".
+	*/
+	resetEventSubs() {
+		for (const entry of this._eventSubs.values()) entry.unsubscribe();
+		this._eventSubs.clear();
+	}
 	/** Direct tRPC client. Read once per call; rebuilt on `reconnect()`. */
 	get trpcClient() {
 		return this._trpcClient;

package/dist/system.d.ts

@@ -75,6 +75,17 @@ export declare class System {
     private token;
     private _trpcClient;
     private _wsClient;
+    /**
+     * One underlying `live.onEvent` subscription per DISTINCT category, fanned
+     * out to every listener.
+     *
+     * Measured on the viewer's boot: ~40 subscriptions, of which 24 were twelve
+     * cameras subscribing to the SAME two motion categories and filtering by
+     * deviceId in their own callbacks. Each was its own WS handshake on a
+     * transport that does not batch. Deduping here needs no protocol change and
+     * no cooperation from callers — `subscribeEvent` keeps its exact shape.
+     */
+    private readonly _eventSubs;
     private mirror;
     private mirrorInit;
     private connected;
@@ -382,8 +393,23 @@ export declare class System {
      * (`@camstack/types`) — passing a raw string works for forward-compat
      * but loses type safety. The SDK forwards the value verbatim to the
      * server's `live.onEvent` subscription.
+     *
+     * **N callers on one category share ONE subscription.** The caller's shape
+     * is unchanged, and it is not asked to coordinate: twelve camera cards each
+     * subscribing to the motion category and filtering by deviceId is the normal
+     * pattern, and it used to open twelve WS subscriptions.
      */
     subscribeEvent<TData = unknown>(category: string, cb: SystemLiveEventListener<TData>): () => void;
+    /**
+     * Drop every shared subscription.
+     *
+     * Called when the tRPC client is rebuilt: the handles above belong to the
+     * OLD client and unsubscribing them is meaningless, while keeping them in
+     * the map would make the next `subscribeEvent` attach a listener to a dead
+     * socket and go silent — the worst outcome, because it looks like "no
+     * events happened".
+     */
+    private resetEventSubs;
     /** Direct tRPC client. Read once per call; rebuilt on `reconnect()`. */
     get trpcClient(): TrpcClient;
     /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@camstack/sdk",
-  "version": "1.2.8",
+  "version": "1.2.10",
   "type": "module",
   "main": "dist/index.cjs",
   "module": "dist/index.js",