@mulingai-npm/redis 3.40.35 → 3.40.36

package/dist/managers/mulingstream-listener-manager.d.ts

@@ -36,6 +36,28 @@ export declare class MulingstreamListenerManager {
         totalListeners: number;
         languageBreakdown: Record<string, number>;
     }>;
+    private capKey;
+    /**
+     * Cache the room's listener cap. Called by the speaker service at go-live and
+     * on reconnect; `ttlSeconds` should comfortably exceed a session so the key
+     * stays warm for the whole stream (it is re-set on every speaker (re)join).
+     * No-ops on a non-positive cap so a misconfigured plan never blocks everyone.
+     */
+    setRoomListenerCap(roomId: string, cap: number, ttlSeconds: number): Promise<void>;
+    /**
+     * Read the cached listener cap for a room. Returns null when no cap has been
+     * cached yet (e.g. the speaker isn't live), so the caller can apply its own
+     * default.
+     */
+    getRoomListenerCap(roomId: string): Promise<number | null>;
+    /**
+     * True when the room has reached (or exceeded) its listener cap. Only NEW
+     * joins should be gated on this — a rejoin already holds a seat.
+     * `fallbackCap` is used when no cap is cached yet (speaker not live); pass a
+     * generous value since listeners with no live speaker generate no pipeline
+     * load. Counting reuses the self-healing room set (stale members are pruned).
+     */
+    isRoomAtListenerCapacity(roomId: string, fallbackCap: number): Promise<boolean>;
     getListenerBySocketId(socketId: string): Promise<MulingstreamListenerData | null>;
     /**
      * Update the isListening state for a listener (audio play/pause).

package/dist/managers/mulingstream-listener-manager.js

@@ -239,6 +239,56 @@ class MulingstreamListenerManager {
             languageBreakdown
         };
     }
+    // ─── Per-room listener capacity (design B, 2026-07-09) ────────────────────
+    // The cap value is the room owner's plan `max_audience`, resolved ONCE by the
+    // speaker service when it goes live (it already fetches the plan entitlements)
+    // and cached here, so the listener join path enforces it with a pure Redis
+    // read — no billing gRPC on the hot path. Lives in the same
+    // MULINGSTREAM_LISTENER DB as the listener set, so one manager owns both the
+    // cap and the live count. NOT persisted in Postgres: a TTL'd cache means a
+    // plan change is picked up on the next speaker (re)join, nothing goes stale.
+    capKey(roomId) {
+        return `room:${roomId}:listener-cap`;
+    }
+    /**
+     * Cache the room's listener cap. Called by the speaker service at go-live and
+     * on reconnect; `ttlSeconds` should comfortably exceed a session so the key
+     * stays warm for the whole stream (it is re-set on every speaker (re)join).
+     * No-ops on a non-positive cap so a misconfigured plan never blocks everyone.
+     */
+    async setRoomListenerCap(roomId, cap, ttlSeconds) {
+        if (!Number.isFinite(cap) || cap <= 0)
+            return;
+        await this.redisClient.set(this.capKey(roomId), Math.floor(cap).toString());
+        await this.redisClient.expire(this.capKey(roomId), ttlSeconds);
+    }
+    /**
+     * Read the cached listener cap for a room. Returns null when no cap has been
+     * cached yet (e.g. the speaker isn't live), so the caller can apply its own
+     * default.
+     */
+    async getRoomListenerCap(roomId) {
+        const raw = await this.redisClient.get(this.capKey(roomId));
+        if (raw == null)
+            return null;
+        const cap = parseInt(raw, 10);
+        return Number.isFinite(cap) && cap > 0 ? cap : null;
+    }
+    /**
+     * True when the room has reached (or exceeded) its listener cap. Only NEW
+     * joins should be gated on this — a rejoin already holds a seat.
+     * `fallbackCap` is used when no cap is cached yet (speaker not live); pass a
+     * generous value since listeners with no live speaker generate no pipeline
+     * load. Counting reuses the self-healing room set (stale members are pruned).
+     */
+    async isRoomAtListenerCapacity(roomId, fallbackCap) {
+        var _a;
+        const cap = (_a = (await this.getRoomListenerCap(roomId))) !== null && _a !== void 0 ? _a : fallbackCap;
+        if (!Number.isFinite(cap) || cap <= 0)
+            return false;
+        const listeners = await this.getListenersByRoom(roomId);
+        return listeners.length >= cap;
+    }
     async getListenerBySocketId(socketId) {
         const keys = await this.redisClient.keys('listener:*');
         if (!keys || keys.length === 0) {

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@mulingai-npm/redis",
-    "version": "3.40.35",
+    "version": "3.40.36",
     "main": "dist/index.js",
     "types": "dist/index.d.ts",
     "repository": {