@mulingai-npm/redis 3.36.1 → 3.37.1

package/dist/managers/chunk-sequencer-manager.d.ts

@@ -37,9 +37,10 @@ export declare class ChunkSequencerManager {
     private waitingRoomKey;
     /**
      * Get the next expected chunk number for a room/language
-     * Returns 1 if not initialized yet (first chunk)
+     * If not initialized, uses fallbackChunk (defaults to the incoming chunk number).
+     * This handles sessions where chunk numbers don't start at 1 (they increment globally).
      */
-    getExpectedChunk(roomId: string, language: string): Promise<number>;
+    getExpectedChunk(roomId: string, language: string, fallbackChunk?: number): Promise<number>;
     /**
      * Set the expected chunk number
      */

package/dist/managers/chunk-sequencer-manager.js

@@ -28,16 +28,17 @@ class ChunkSequencerManager {
     }
     /**
      * Get the next expected chunk number for a room/language
-     * Returns 1 if not initialized yet (first chunk)
+     * If not initialized, uses fallbackChunk (defaults to the incoming chunk number).
+     * This handles sessions where chunk numbers don't start at 1 (they increment globally).
      */
-    async getExpectedChunk(roomId, language) {
+    async getExpectedChunk(roomId, language, fallbackChunk) {
         const key = this.expectedChunkKey(roomId, language);
         const value = await this.redisClient.get(key);
         if (!value) {
-            // Initialize to 1 for first chunk
-            await this.redisClient.set(key, '1');
+            const initial = fallbackChunk !== null && fallbackChunk !== void 0 ? fallbackChunk : 1;
+            await this.redisClient.set(key, initial.toString());
             await this.redisClient.expire(key, 3600); // 1 hour TTL
-            return 1;
+            return initial;
         }
         return parseInt(value, 10);
     }

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

@@ -9,6 +9,7 @@ export type MulingstreamListenerData = {
     lastHeartbeat: number;
     language?: string;
     color?: string;
+    isListening?: boolean;
 };
 export declare class MulingstreamListenerManager {
     private redisClient;
@@ -29,4 +30,21 @@ export declare class MulingstreamListenerManager {
         languageBreakdown: Record<string, number>;
     }>;
     getListenerBySocketId(socketId: string): Promise<MulingstreamListenerData | null>;
+    /**
+     * Update the isListening state for a listener (audio play/pause).
+     */
+    setListeningState(listenerIdOrToken: string, isListening: boolean): Promise<MulingstreamListenerData | null>;
+    /**
+     * Returns unique languages that have at least one listener with isListening=true.
+     * Used by pipeline to determine which languages need TTS generation.
+     */
+    getLanguagesWithActiveListeners(roomId: string): Promise<string[]>;
+    /**
+     * Returns socket IDs for listeners of a language who have isListening=true (audio on).
+     */
+    getListeningSocketIdsByRoomLanguage(roomId: string, language: string): Promise<string[]>;
+    /**
+     * Returns socket IDs for listeners of a language who have isListening=false (audio off, reading text only).
+     */
+    getNonListeningSocketIdsByRoomLanguage(roomId: string, language: string): Promise<string[]>;
 }

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

@@ -45,7 +45,8 @@ class MulingstreamListenerManager {
             firstJoined: parseInt(data.firstJoined, 10),
             lastHeartbeat: parseInt(data.lastHeartbeat, 10),
             language: data.language || '',
-            color: data.color || ''
+            color: data.color || '',
+            isListening: data.isListening === 'true'
         };
     }
     // Creates a new listener.
@@ -69,7 +70,8 @@ class MulingstreamListenerManager {
             firstJoined: listenerData.firstJoined.toString(),
             lastHeartbeat: listenerData.lastHeartbeat.toString(),
             language: (_c = listenerData.language) !== null && _c !== void 0 ? _c : '',
-            color
+            color,
+            isListening: 'false'
         });
         // expire listener
         await this.redisClient.expire(`listener:${listenerId}`, EXPIRATION);
@@ -235,5 +237,56 @@ class MulingstreamListenerManager {
         }
         return null;
     }
+    /**
+     * Update the isListening state for a listener (audio play/pause).
+     */
+    async setListeningState(listenerIdOrToken, isListening) {
+        const listener = await this.getListener(listenerIdOrToken);
+        if (!listener) {
+            return null;
+        }
+        await this.redisClient.hset(`listener:${listener.listenerId}`, {
+            isListening: isListening.toString()
+        });
+        return { ...listener, isListening };
+    }
+    /**
+     * Returns unique languages that have at least one listener with isListening=true.
+     * Used by pipeline to determine which languages need TTS generation.
+     */
+    async getLanguagesWithActiveListeners(roomId) {
+        const listeners = await this.getListenersByRoom(roomId);
+        const languageCountMap = {};
+        for (const listener of listeners) {
+            if (!listener.language || !listener.language.trim())
+                continue;
+            if (!listener.isListening)
+                continue;
+            const lang = listener.language;
+            languageCountMap[lang] = (languageCountMap[lang] || 0) + 1;
+        }
+        const sortedEntries = Object.entries(languageCountMap).sort(([, countA], [, countB]) => countB - countA);
+        return sortedEntries.map(([language]) => language);
+    }
+    /**
+     * Returns socket IDs for listeners of a language who have isListening=true (audio on).
+     */
+    async getListeningSocketIdsByRoomLanguage(roomId, language) {
+        const listeners = await this.getListenersByRoom(roomId);
+        return listeners
+            .filter(l => l.language === language && l.isListening)
+            .map(l => l.socketId)
+            .filter((id) => !!id);
+    }
+    /**
+     * Returns socket IDs for listeners of a language who have isListening=false (audio off, reading text only).
+     */
+    async getNonListeningSocketIdsByRoomLanguage(roomId, language) {
+        const listeners = await this.getListenersByRoom(roomId);
+        return listeners
+            .filter(l => l.language === language && !l.isListening)
+            .map(l => l.socketId)
+            .filter((id) => !!id);
+    }
 }
 exports.MulingstreamListenerManager = MulingstreamListenerManager;

package/package.json

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