@mulingai-npm/redis 2.12.2 → 2.12.4

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

@@ -1,486 +1,486 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MulingstreamChunkManager = void 0;
-const EXPIRATION = 12 * 60 * 60; // 12 hours in seconds
-const ROOM_ARRAY_LENGTH = 50; // keep only the last 5 elements
-class MulingstreamChunkManager {
-    constructor(redisClient) {
-        this.redisClient = redisClient;
-    }
-    getTimeout(audioStart, audioEnd) {
-        const audioChunkLength = audioEnd - audioStart;
-        if (audioChunkLength < 1000) {
-            return 1500;
-        }
-        else if (audioChunkLength >= 1000 && audioChunkLength < 3000) {
-            return 3000;
-        }
-        else if (audioChunkLength >= 3000 && audioChunkLength < 5000) {
-            return 7000;
-        }
-        else if (audioChunkLength >= 5000 && audioChunkLength < 8000) {
-            return 10000;
-        }
-        else if (audioChunkLength >= 8000 && audioChunkLength < 12000) {
-            return 15000;
-        }
-        else if (audioChunkLength >= 12000 && audioChunkLength < 20000) {
-            return 20000;
-        }
-        else {
-            return 30000;
-        }
-    }
-    /**
-     * Initializes a room in Redis as an empty JSON array.
-     * If the key [roomId] already exists, we do NOT overwrite it.
-     * Returns true if room was created, false if room already existed.
-     */
-    async initRoom(roomId) {
-        // Check if the key already exists (JSON.GET)
-        const isRoomExisting = await this.redisClient.jsonGet(`[${roomId}]`, '.');
-        if (isRoomExisting !== null) {
-            return false;
-        }
-        // Create an empty array at the root
-        await this.redisClient.jsonSet(`[${roomId}]`, '.', []);
-        await this.redisClient.expire(`[${roomId}]`, EXPIRATION);
-        return true;
-    }
-    /**
-     * Returns all rooms. This is naive if you store many other keys in Redis,
-     * because we search keys for pattern "[*]".
-     * Adjust as needed if you have a separate naming prefix.
-     */
-    async getRooms() {
-        // e.g., if we store everything as [foo], [bar], etc., we do:
-        const rooms = await this.redisClient.keys('\\[*\\]');
-        // This returns the raw keys, e.g. ['[myRoom]', '[anotherRoom]']
-        // We might want to strip off the brackets:
-        return rooms.map((k) => k.replace(/^\[|\]$/g, ''));
-    }
-    /**
-     * Returns the entire array of chunks for the given roomId,
-     * or null if the room doesn't exist in Redis.
-     */
-    async getMulingstreamChunksByRoom(roomId) {
-        // JSON.GET [roomId] .
-        const chunks = await this.redisClient.jsonGet(`[${roomId}]`, '.');
-        if (chunks === null) {
-            return null;
-        }
-        return chunks;
-    }
-    async getRoomById(roomId) {
-        return this.getMulingstreamChunksByRoom(roomId);
-    }
-    async addMulingstreamChunk(params) {
-        var _a;
-        const { roomId, chunkNumber, language, start, end, duration, isFirst, isLast, theme, sttProviders, targetLanguages, shortCodeTargetLanguages } = params;
-        /* ---------- build chunk skeleton ---------- */
-        const audioChunk = {
-            start,
-            end,
-            duration,
-            isFirst,
-            isLast,
-            theme,
-            processingStart: Date.now()
-        };
-        const stt = {};
-        for (const p of sttProviders) {
-            stt[p] = { transcription: '', status: 'INIT' };
-        }
-        const translation = {};
-        const tts = {};
-        for (const lang of shortCodeTargetLanguages) {
-            translation[lang] = { translation: '', status: 'INIT' };
-            tts[lang] = { ttsAudioPath: '', status: 'INIT', isEmitted: false, totalCheck: 0 };
-        }
-        const newChunk = {
-            roomId,
-            chunkNumber,
-            language,
-            sttProviders,
-            targetLanguages,
-            shortCodeTargetLanguages,
-            finalTranscription: '',
-            sttStatus: 'INIT',
-            createdAt: Date.now(),
-            audioChunk,
-            stt,
-            translation,
-            tts
-        };
-        /* ---------- pull existing room array ---------- */
-        let chunks = (_a = (await this.redisClient.jsonGet(`[${roomId}]`, '.'))) !== null && _a !== void 0 ? _a : [];
-        /* ---------- reset the room if this is the first chunk ---------- */
-        if (chunkNumber === 1) {
-            chunks = []; // start fresh
-        }
-        /* ---------- insert / replace ---------- */
-        const idx = chunks.findIndex((c) => c.chunkNumber === chunkNumber);
-        if (idx !== -1) {
-            chunks[idx] = newChunk;
-        }
-        else {
-            chunks.push(newChunk);
-            if (chunks.length > ROOM_ARRAY_LENGTH)
-                chunks.shift();
-        }
-        /* ---------- persist ---------- */
-        await this.redisClient.jsonSet(`[${roomId}]`, '.', chunks);
-        await this.redisClient.expire(`[${roomId}]`, EXPIRATION);
-    }
-    /**
-     * Given roomId and chunkNumber, return the single chunk from the array
-     * or null if not found.
-     */
-    async getMulingstreamChunkById(roomId, chunkNumber) {
-        // Retrieve the entire array
-        const chunks = await this.getMulingstreamChunksByRoom(roomId);
-        if (!chunks)
-            return null;
-        // Find by chunkNumber
-        const chunk = chunks.find((c) => c.chunkNumber === chunkNumber);
-        return chunk || null;
-    }
-    /**
-     * Update STT fields for a given chunk.
-     * If transcription or sttStatus is null, skip that field.
-     */
-    async updateStt(roomId, chunkNumber, sttProvider, options) {
-        const chunks = await this.getMulingstreamChunksByRoom(roomId);
-        if (!chunks)
-            return false;
-        // Find the chunk
-        const chunkIndex = chunks.findIndex((c) => c.chunkNumber === chunkNumber);
-        if (chunkIndex === -1)
-            return false;
-        const chunk = chunks[chunkIndex];
-        // If this stt provider doesn't exist, ignore
-        if (!chunk.stt[sttProvider])
-            return false;
-        // Update
-        if (options.transcription != null) {
-            chunk.stt[sttProvider].transcription = options.transcription;
-        }
-        if (options.sttStatus != null) {
-            chunk.stt[sttProvider].status = options.sttStatus;
-        }
-        // Write back
-        chunks[chunkIndex] = chunk;
-        await this.redisClient.jsonSet(`[${roomId}]`, '.', chunks);
-        return true;
-    }
-    async updateSttObject(roomId, chunkNumber, newStt) {
-        // Fetch all chunks in the room
-        const chunks = await this.getMulingstreamChunksByRoom(roomId);
-        if (!chunks) {
-            return false;
-        }
-        // Locate the target chunk
-        const idx = chunks.findIndex((c) => c.chunkNumber === chunkNumber);
-        if (idx === -1) {
-            return false;
-        }
-        // Replace the stt object
-        chunks[idx].stt = newStt;
-        // Persist back to Redis
-        await this.redisClient.jsonSet(`[${roomId}]`, '.', chunks);
-        return true;
-    }
-    async discardStt(roomId, chunkNumber) {
-        // Fetch all chunks in this room
-        const chunks = await this.getMulingstreamChunksByRoom(roomId);
-        if (!chunks) {
-            return false;
-        }
-        // Locate the desired chunk
-        const idx = chunks.findIndex((c) => c.chunkNumber === chunkNumber);
-        if (idx === -1) {
-            return false;
-        }
-        const chunk = chunks[idx];
-        // Reset every STT provider entry
-        for (const provider of Object.keys(chunk.stt)) {
-            chunk.stt[provider].transcription = '';
-            chunk.stt[provider].status = 'DISCARDED';
-        }
-        // Reset aggregate STT fields
-        chunk.finalTranscription = '';
-        chunk.sttStatus = 'DISCARDED';
-        // Persist back to Redis
-        chunks[idx] = chunk;
-        await this.redisClient.jsonSet(`[${roomId}]`, '.', chunks);
-        return true;
-    }
-    async updateFinalTranscription(roomId, chunkNumber, options) {
-        // 1) fetch room’s chunks
-        const chunks = await this.getMulingstreamChunksByRoom(roomId);
-        if (!chunks)
-            return null;
-        // 2) locate the chunk
-        const idx = chunks.findIndex((c) => c.chunkNumber === chunkNumber);
-        if (idx === -1)
-            return null;
-        // 3) apply updates only when the key is present
-        if (options.transcription !== undefined) {
-            chunks[idx].finalTranscription = options.transcription;
-        }
-        if (options.sttStatus !== undefined) {
-            chunks[idx].sttStatus = options.sttStatus;
-        }
-        // 4) persist and return
-        await this.redisClient.jsonSet(`[${roomId}]`, '.', chunks);
-        return chunks[idx];
-    }
-    /**
-     * Discards all post-STT steps for a given chunk:
-     * sets all translation[].status & tts[].status to "DISCARDED".
-     */
-    async discardPostStt(roomId, chunkNumber) {
-        const chunks = await this.getMulingstreamChunksByRoom(roomId);
-        if (!chunks)
-            return false;
-        // Find chunk
-        const chunkIndex = chunks.findIndex((c) => c.chunkNumber === chunkNumber);
-        if (chunkIndex === -1)
-            return false;
-        // Discard translation & TTS statuses
-        const chunk = chunks[chunkIndex];
-        for (const lang of Object.keys(chunk.translation)) {
-            chunk.translation[lang].status = 'DISCARDED';
-        }
-        for (const lang of Object.keys(chunk.tts)) {
-            chunk.tts[lang].status = 'DISCARDED';
-        }
-        chunks[chunkIndex] = chunk;
-        await this.redisClient.jsonSet(`[${roomId}]`, '.', chunks);
-        return true;
-    }
-    /**
-     * Discards a specific language in both translation and tts for a chunk.
-     */
-    async discardLanguage(roomId, chunkNumber, language) {
-        const chunks = await this.getMulingstreamChunksByRoom(roomId);
-        if (!chunks)
-            return false;
-        const chunkIndex = chunks.findIndex((c) => c.chunkNumber === chunkNumber);
-        if (chunkIndex === -1)
-            return false;
-        const chunk = chunks[chunkIndex];
-        if (chunk.translation[language]) {
-            chunk.translation[language].status = 'DISCARDED';
-        }
-        if (chunk.tts[language]) {
-            chunk.tts[language].status = 'DISCARDED';
-        }
-        chunks[chunkIndex] = chunk;
-        await this.redisClient.jsonSet(`[${roomId}]`, '.', chunks);
-        return true;
-    }
-    async discardLanguages(roomId, chunkNumber, options) {
-        // 1) fetch room’s chunks
-        const chunks = await this.getMulingstreamChunksByRoom(roomId);
-        if (!chunks)
-            return null;
-        // 2) locate the chunk
-        const idx = chunks.findIndex((c) => c.chunkNumber === chunkNumber);
-        if (idx === -1)
-            return null;
-        const chunk = chunks[idx];
-        // 3) discard translation languages still in INIT
-        if (options.translation) {
-            for (const lang of options.translation) {
-                const entry = chunk.translation[lang];
-                if (entry && entry.status === 'INIT') {
-                    entry.status = 'DISCARDED';
-                }
-            }
-        }
-        // 4) discard TTS languages still in INIT
-        if (options.tts) {
-            for (const lang of options.tts) {
-                const entry = chunk.tts[lang];
-                if (entry && entry.status === 'INIT') {
-                    entry.status = 'DISCARDED';
-                }
-            }
-        }
-        // 5) persist and return
-        chunks[idx] = chunk;
-        await this.redisClient.jsonSet(`[${roomId}]`, '.', chunks);
-        return chunk;
-    }
-    async updateTranslation(roomId, chunkNumber, language, options) {
-        // 1) fetch the room’s chunks
-        const chunks = await this.getMulingstreamChunksByRoom(roomId);
-        if (!chunks)
-            return null;
-        // 2) locate the chunk
-        const idx = chunks.findIndex((c) => c.chunkNumber === chunkNumber);
-        if (idx === -1)
-            return null;
-        const chunk = chunks[idx];
-        // 3) ensure the requested language exists
-        if (!chunk.translation[language])
-            return null;
-        // 4) apply updates only for provided keys
-        if (options.translation !== undefined) {
-            chunk.translation[language].translation = options.translation;
-        }
-        if (options.status !== undefined) {
-            chunk.translation[language].status = options.status;
-        }
-        // 5) persist and return
-        chunks[idx] = chunk;
-        await this.redisClient.jsonSet(`[${roomId}]`, '.', chunks);
-        return chunk;
-    }
-    async updateTranslationInBulk(roomId, chunkNumber, translations, status = 'READY') {
-        // 1) fetch the room array
-        const chunks = await this.getMulingstreamChunksByRoom(roomId);
-        if (!chunks) {
-            return null;
-        }
-        // 2) locate the target chunk
-        const chunkIdx = chunks.findIndex((c) => c.chunkNumber === chunkNumber);
-        if (chunkIdx === -1) {
-            return null;
-        }
-        const chunk = chunks[chunkIdx];
-        // 3) apply updates only for the languages provided
-        for (const [lang, translationText] of Object.entries(translations)) {
-            if (!chunk.translation[lang]) {
-                continue;
-            }
-            chunk.translation[lang].translation = translationText;
-            chunk.translation[lang].status = status;
-        }
-        // 4) write the full room array back to Redis
-        chunks[chunkIdx] = chunk;
-        await this.redisClient.jsonSet(`[${roomId}]`, '.', chunks);
-        return chunk;
-    }
-    async updateTts(roomId, chunkNumber, language, options) {
-        // 1) fetch the room’s chunks
-        const chunks = await this.getMulingstreamChunksByRoom(roomId);
-        if (!chunks)
-            return null;
-        // 2) locate the chunk
-        const idx = chunks.findIndex((c) => c.chunkNumber === chunkNumber);
-        if (idx === -1)
-            return null;
-        const chunk = chunks[idx];
-        // 3) ensure the language exists in the TTS map
-        if (!chunk.tts[language])
-            return null;
-        // 4) apply only the provided keys
-        if (options.ttsAudioPath !== undefined) {
-            chunk.tts[language].ttsAudioPath = options.ttsAudioPath;
-        }
-        if (options.status !== undefined) {
-            chunk.tts[language].status = options.status;
-        }
-        if (options.isEmitted !== undefined) {
-            chunk.tts[language].isEmitted = options.isEmitted;
-        }
-        if (options.totalCheck !== undefined) {
-            chunk.tts[language].totalCheck = options.totalCheck;
-        }
-        // 5) persist and return the updated chunk
-        chunks[idx] = chunk;
-        await this.redisClient.jsonSet(`[${roomId}]`, '.', chunks);
-        return chunk;
-    }
-    async increaseTotalCheck(roomId, chunkNumber, language) {
-        const chunks = await this.getMulingstreamChunksByRoom(roomId);
-        if (!chunks) {
-            return null;
-        }
-        const idx = chunks.findIndex((c) => c.chunkNumber === chunkNumber);
-        if (idx === -1) {
-            return null;
-        }
-        const chunk = chunks[idx];
-        if (!chunk.tts[language]) {
-            return null;
-        }
-        chunk.tts[language].totalCheck += 1;
-        chunks[idx] = chunk;
-        await this.redisClient.jsonSet(`[${roomId}]`, '.', chunks);
-        return chunk;
-    }
-    async areTranslationsProcessed(roomId, chunkNumber) {
-        const chunk = await this.getMulingstreamChunkById(roomId, chunkNumber);
-        if (!chunk) {
-            return false;
-        }
-        return Object.values(chunk.translation).every((t) => t.status !== 'INIT');
-    }
-    async getAllReadyTts(roomId, language) {
-        const chunks = await this.getMulingstreamChunksByRoom(roomId);
-        if (!(chunks === null || chunks === void 0 ? void 0 : chunks.length))
-            return [];
-        // chunks are received in consecutive order already, no need for sorting for now (maybe in the future we have more speaker in a room, so we may need sorting)
-        // chunks.sort((a, b) => a.chunkNumber - b.chunkNumber);
-        /* ---- isolate the tail where the language exists ---- */
-        let lastLangIdx = -1;
-        for (let i = chunks.length - 1; i >= 0; i--) {
-            if (chunks[i].tts[language]) {
-                lastLangIdx = i;
-                break;
-            }
-        }
-        if (lastLangIdx === -1)
-            return [];
-        let firstLangIdx = lastLangIdx;
-        for (let i = lastLangIdx - 1; i >= 0; i--) {
-            if (!chunks[i].tts[language])
-                break;
-            firstLangIdx = i;
-        }
-        const window = chunks.slice(firstLangIdx, lastLangIdx + 1);
-        /* ---- find last USED / DISCARDED in that window ---- */
-        let lastDone = -1;
-        for (let i = window.length - 1; i >= 0; i--) {
-            const st = window[i].tts[language].status;
-            if (st === 'USED' || st === 'DISCARDED') {
-                lastDone = i;
-                break;
-            }
-        }
-        const ready = [];
-        let blocked = false;
-        const now = Date.now();
-        for (let i = lastDone + 1; i < window.length; i++) {
-            const entry = window[i].tts[language];
-            const audioChunk = window[i].audioChunk;
-            if (entry.status === 'INIT') {
-                const timeout = this.getTimeout(audioChunk.start, audioChunk.end);
-                console.log('AUDIO LENGTH: ', audioChunk.end - audioChunk.start, ' TIMEOUT BASED ON AUDIO LENGTH: ', timeout, ' SINCE CREATED UNTIL NOW: ', now - window[i].createdAt);
-                if (now - window[i].createdAt > timeout) {
-                    entry.status = 'DISCARDED';
-                }
-                else {
-                    blocked = true;
-                }
-                continue;
-            }
-            if (entry.status === 'READY') {
-                if (blocked)
-                    break; // earlier INIT still pending
-                ready.push(window[i]);
-                continue;
-            }
-            break; // unexpected USED / DISCARDED
-        }
-        // persist any DISCARDED changes we made
-        if (ready.length === 0 || blocked) {
-            await this.redisClient.jsonSet(`[${roomId}]`, '.', chunks);
-        }
-        return ready;
-    }
-}
-exports.MulingstreamChunkManager = MulingstreamChunkManager;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MulingstreamChunkManager = void 0;
+const EXPIRATION = 12 * 60 * 60; // 12 hours in seconds
+const ROOM_ARRAY_LENGTH = 50; // keep only the last 5 elements
+class MulingstreamChunkManager {
+    constructor(redisClient) {
+        this.redisClient = redisClient;
+    }
+    getTimeout(audioStart, audioEnd) {
+        const audioChunkLength = audioEnd - audioStart;
+        if (audioChunkLength < 1000) {
+            return 1500;
+        }
+        else if (audioChunkLength >= 1000 && audioChunkLength < 3000) {
+            return 3000;
+        }
+        else if (audioChunkLength >= 3000 && audioChunkLength < 5000) {
+            return 7000;
+        }
+        else if (audioChunkLength >= 5000 && audioChunkLength < 8000) {
+            return 10000;
+        }
+        else if (audioChunkLength >= 8000 && audioChunkLength < 12000) {
+            return 15000;
+        }
+        else if (audioChunkLength >= 12000 && audioChunkLength < 20000) {
+            return 20000;
+        }
+        else {
+            return 30000;
+        }
+    }
+    /**
+     * Initializes a room in Redis as an empty JSON array.
+     * If the key [roomId] already exists, we do NOT overwrite it.
+     * Returns true if room was created, false if room already existed.
+     */
+    async initRoom(roomId) {
+        // Check if the key already exists (JSON.GET)
+        const isRoomExisting = await this.redisClient.jsonGet(`[${roomId}]`, '.');
+        if (isRoomExisting !== null) {
+            return false;
+        }
+        // Create an empty array at the root
+        await this.redisClient.jsonSet(`[${roomId}]`, '.', []);
+        await this.redisClient.expire(`[${roomId}]`, EXPIRATION);
+        return true;
+    }
+    /**
+     * Returns all rooms. This is naive if you store many other keys in Redis,
+     * because we search keys for pattern "[*]".
+     * Adjust as needed if you have a separate naming prefix.
+     */
+    async getRooms() {
+        // e.g., if we store everything as [foo], [bar], etc., we do:
+        const rooms = await this.redisClient.keys('\\[*\\]');
+        // This returns the raw keys, e.g. ['[myRoom]', '[anotherRoom]']
+        // We might want to strip off the brackets:
+        return rooms.map((k) => k.replace(/^\[|\]$/g, ''));
+    }
+    /**
+     * Returns the entire array of chunks for the given roomId,
+     * or null if the room doesn't exist in Redis.
+     */
+    async getMulingstreamChunksByRoom(roomId) {
+        // JSON.GET [roomId] .
+        const chunks = await this.redisClient.jsonGet(`[${roomId}]`, '.');
+        if (chunks === null) {
+            return null;
+        }
+        return chunks;
+    }
+    async getRoomById(roomId) {
+        return this.getMulingstreamChunksByRoom(roomId);
+    }
+    async addMulingstreamChunk(params) {
+        var _a;
+        const { roomId, chunkNumber, language, start, end, duration, isFirst, isLast, theme, sttProviders, targetLanguages, shortCodeTargetLanguages } = params;
+        /* ---------- build chunk skeleton ---------- */
+        const audioChunk = {
+            start,
+            end,
+            duration,
+            isFirst,
+            isLast,
+            theme,
+            processingStart: Date.now()
+        };
+        const stt = {};
+        for (const p of sttProviders) {
+            stt[p] = { transcription: '', status: 'INIT' };
+        }
+        const translation = {};
+        const tts = {};
+        for (const lang of shortCodeTargetLanguages) {
+            translation[lang] = { translation: '', status: 'INIT' };
+            tts[lang] = { ttsAudioPath: '', status: 'INIT', isEmitted: false, totalCheck: 0 };
+        }
+        const newChunk = {
+            roomId,
+            chunkNumber,
+            language,
+            sttProviders,
+            targetLanguages,
+            shortCodeTargetLanguages,
+            finalTranscription: '',
+            sttStatus: 'INIT',
+            createdAt: Date.now(),
+            audioChunk,
+            stt,
+            translation,
+            tts
+        };
+        /* ---------- pull existing room array ---------- */
+        let chunks = (_a = (await this.redisClient.jsonGet(`[${roomId}]`, '.'))) !== null && _a !== void 0 ? _a : [];
+        /* ---------- reset the room if this is the first chunk ---------- */
+        if (chunkNumber === 1) {
+            chunks = []; // start fresh
+        }
+        /* ---------- insert / replace ---------- */
+        const idx = chunks.findIndex((c) => c.chunkNumber === chunkNumber);
+        if (idx !== -1) {
+            chunks[idx] = newChunk;
+        }
+        else {
+            chunks.push(newChunk);
+            if (chunks.length > ROOM_ARRAY_LENGTH)
+                chunks.shift();
+        }
+        /* ---------- persist ---------- */
+        await this.redisClient.jsonSet(`[${roomId}]`, '.', chunks);
+        await this.redisClient.expire(`[${roomId}]`, EXPIRATION);
+    }
+    /**
+     * Given roomId and chunkNumber, return the single chunk from the array
+     * or null if not found.
+     */
+    async getMulingstreamChunkById(roomId, chunkNumber) {
+        // Retrieve the entire array
+        const chunks = await this.getMulingstreamChunksByRoom(roomId);
+        if (!chunks)
+            return null;
+        // Find by chunkNumber
+        const chunk = chunks.find((c) => c.chunkNumber === chunkNumber);
+        return chunk || null;
+    }
+    /**
+     * Update STT fields for a given chunk.
+     * If transcription or sttStatus is null, skip that field.
+     */
+    async updateStt(roomId, chunkNumber, sttProvider, options) {
+        const chunks = await this.getMulingstreamChunksByRoom(roomId);
+        if (!chunks)
+            return false;
+        // Find the chunk
+        const chunkIndex = chunks.findIndex((c) => c.chunkNumber === chunkNumber);
+        if (chunkIndex === -1)
+            return false;
+        const chunk = chunks[chunkIndex];
+        // If this stt provider doesn't exist, ignore
+        if (!chunk.stt[sttProvider])
+            return false;
+        // Update
+        if (options.transcription != null) {
+            chunk.stt[sttProvider].transcription = options.transcription;
+        }
+        if (options.sttStatus != null) {
+            chunk.stt[sttProvider].status = options.sttStatus;
+        }
+        // Write back
+        chunks[chunkIndex] = chunk;
+        await this.redisClient.jsonSet(`[${roomId}]`, '.', chunks);
+        return true;
+    }
+    async updateSttObject(roomId, chunkNumber, newStt) {
+        // Fetch all chunks in the room
+        const chunks = await this.getMulingstreamChunksByRoom(roomId);
+        if (!chunks) {
+            return false;
+        }
+        // Locate the target chunk
+        const idx = chunks.findIndex((c) => c.chunkNumber === chunkNumber);
+        if (idx === -1) {
+            return false;
+        }
+        // Replace the stt object
+        chunks[idx].stt = newStt;
+        // Persist back to Redis
+        await this.redisClient.jsonSet(`[${roomId}]`, '.', chunks);
+        return true;
+    }
+    async discardStt(roomId, chunkNumber) {
+        // Fetch all chunks in this room
+        const chunks = await this.getMulingstreamChunksByRoom(roomId);
+        if (!chunks) {
+            return false;
+        }
+        // Locate the desired chunk
+        const idx = chunks.findIndex((c) => c.chunkNumber === chunkNumber);
+        if (idx === -1) {
+            return false;
+        }
+        const chunk = chunks[idx];
+        // Reset every STT provider entry
+        for (const provider of Object.keys(chunk.stt)) {
+            chunk.stt[provider].transcription = '';
+            chunk.stt[provider].status = 'DISCARDED';
+        }
+        // Reset aggregate STT fields
+        chunk.finalTranscription = '';
+        chunk.sttStatus = 'DISCARDED';
+        // Persist back to Redis
+        chunks[idx] = chunk;
+        await this.redisClient.jsonSet(`[${roomId}]`, '.', chunks);
+        return true;
+    }
+    async updateFinalTranscription(roomId, chunkNumber, options) {
+        // 1) fetch room’s chunks
+        const chunks = await this.getMulingstreamChunksByRoom(roomId);
+        if (!chunks)
+            return null;
+        // 2) locate the chunk
+        const idx = chunks.findIndex((c) => c.chunkNumber === chunkNumber);
+        if (idx === -1)
+            return null;
+        // 3) apply updates only when the key is present
+        if (options.transcription !== undefined) {
+            chunks[idx].finalTranscription = options.transcription;
+        }
+        if (options.sttStatus !== undefined) {
+            chunks[idx].sttStatus = options.sttStatus;
+        }
+        // 4) persist and return
+        await this.redisClient.jsonSet(`[${roomId}]`, '.', chunks);
+        return chunks[idx];
+    }
+    /**
+     * Discards all post-STT steps for a given chunk:
+     * sets all translation[].status & tts[].status to "DISCARDED".
+     */
+    async discardPostStt(roomId, chunkNumber) {
+        const chunks = await this.getMulingstreamChunksByRoom(roomId);
+        if (!chunks)
+            return false;
+        // Find chunk
+        const chunkIndex = chunks.findIndex((c) => c.chunkNumber === chunkNumber);
+        if (chunkIndex === -1)
+            return false;
+        // Discard translation & TTS statuses
+        const chunk = chunks[chunkIndex];
+        for (const lang of Object.keys(chunk.translation)) {
+            chunk.translation[lang].status = 'DISCARDED';
+        }
+        for (const lang of Object.keys(chunk.tts)) {
+            chunk.tts[lang].status = 'DISCARDED';
+        }
+        chunks[chunkIndex] = chunk;
+        await this.redisClient.jsonSet(`[${roomId}]`, '.', chunks);
+        return true;
+    }
+    /**
+     * Discards a specific language in both translation and tts for a chunk.
+     */
+    async discardLanguage(roomId, chunkNumber, language) {
+        const chunks = await this.getMulingstreamChunksByRoom(roomId);
+        if (!chunks)
+            return false;
+        const chunkIndex = chunks.findIndex((c) => c.chunkNumber === chunkNumber);
+        if (chunkIndex === -1)
+            return false;
+        const chunk = chunks[chunkIndex];
+        if (chunk.translation[language]) {
+            chunk.translation[language].status = 'DISCARDED';
+        }
+        if (chunk.tts[language]) {
+            chunk.tts[language].status = 'DISCARDED';
+        }
+        chunks[chunkIndex] = chunk;
+        await this.redisClient.jsonSet(`[${roomId}]`, '.', chunks);
+        return true;
+    }
+    async discardLanguages(roomId, chunkNumber, options) {
+        // 1) fetch room’s chunks
+        const chunks = await this.getMulingstreamChunksByRoom(roomId);
+        if (!chunks)
+            return null;
+        // 2) locate the chunk
+        const idx = chunks.findIndex((c) => c.chunkNumber === chunkNumber);
+        if (idx === -1)
+            return null;
+        const chunk = chunks[idx];
+        // 3) discard translation languages still in INIT
+        if (options.translation) {
+            for (const lang of options.translation) {
+                const entry = chunk.translation[lang];
+                if (entry && entry.status === 'INIT') {
+                    entry.status = 'DISCARDED';
+                }
+            }
+        }
+        // 4) discard TTS languages still in INIT
+        if (options.tts) {
+            for (const lang of options.tts) {
+                const entry = chunk.tts[lang];
+                if (entry && entry.status === 'INIT') {
+                    entry.status = 'DISCARDED';
+                }
+            }
+        }
+        // 5) persist and return
+        chunks[idx] = chunk;
+        await this.redisClient.jsonSet(`[${roomId}]`, '.', chunks);
+        return chunk;
+    }
+    async updateTranslation(roomId, chunkNumber, language, options) {
+        // 1) fetch the room’s chunks
+        const chunks = await this.getMulingstreamChunksByRoom(roomId);
+        if (!chunks)
+            return null;
+        // 2) locate the chunk
+        const idx = chunks.findIndex((c) => c.chunkNumber === chunkNumber);
+        if (idx === -1)
+            return null;
+        const chunk = chunks[idx];
+        // 3) ensure the requested language exists
+        if (!chunk.translation[language])
+            return null;
+        // 4) apply updates only for provided keys
+        if (options.translation !== undefined) {
+            chunk.translation[language].translation = options.translation;
+        }
+        if (options.status !== undefined) {
+            chunk.translation[language].status = options.status;
+        }
+        // 5) persist and return
+        chunks[idx] = chunk;
+        await this.redisClient.jsonSet(`[${roomId}]`, '.', chunks);
+        return chunk;
+    }
+    async updateTranslationInBulk(roomId, chunkNumber, translations, status = 'READY') {
+        // 1) fetch the room array
+        const chunks = await this.getMulingstreamChunksByRoom(roomId);
+        if (!chunks) {
+            return null;
+        }
+        // 2) locate the target chunk
+        const chunkIdx = chunks.findIndex((c) => c.chunkNumber === chunkNumber);
+        if (chunkIdx === -1) {
+            return null;
+        }
+        const chunk = chunks[chunkIdx];
+        // 3) apply updates only for the languages provided
+        for (const [lang, translationText] of Object.entries(translations)) {
+            if (!chunk.translation[lang]) {
+                continue;
+            }
+            chunk.translation[lang].translation = translationText;
+            chunk.translation[lang].status = status;
+        }
+        // 4) write the full room array back to Redis
+        chunks[chunkIdx] = chunk;
+        await this.redisClient.jsonSet(`[${roomId}]`, '.', chunks);
+        return chunk;
+    }
+    async updateTts(roomId, chunkNumber, language, options) {
+        // 1) fetch the room’s chunks
+        const chunks = await this.getMulingstreamChunksByRoom(roomId);
+        if (!chunks)
+            return null;
+        // 2) locate the chunk
+        const idx = chunks.findIndex((c) => c.chunkNumber === chunkNumber);
+        if (idx === -1)
+            return null;
+        const chunk = chunks[idx];
+        // 3) ensure the language exists in the TTS map
+        if (!chunk.tts[language])
+            return null;
+        // 4) apply only the provided keys
+        if (options.ttsAudioPath !== undefined) {
+            chunk.tts[language].ttsAudioPath = options.ttsAudioPath;
+        }
+        if (options.status !== undefined) {
+            chunk.tts[language].status = options.status;
+        }
+        if (options.isEmitted !== undefined) {
+            chunk.tts[language].isEmitted = options.isEmitted;
+        }
+        if (options.totalCheck !== undefined) {
+            chunk.tts[language].totalCheck = options.totalCheck;
+        }
+        // 5) persist and return the updated chunk
+        chunks[idx] = chunk;
+        await this.redisClient.jsonSet(`[${roomId}]`, '.', chunks);
+        return chunk;
+    }
+    async increaseTotalCheck(roomId, chunkNumber, language) {
+        const chunks = await this.getMulingstreamChunksByRoom(roomId);
+        if (!chunks) {
+            return null;
+        }
+        const idx = chunks.findIndex((c) => c.chunkNumber === chunkNumber);
+        if (idx === -1) {
+            return null;
+        }
+        const chunk = chunks[idx];
+        if (!chunk.tts[language]) {
+            return null;
+        }
+        chunk.tts[language].totalCheck += 1;
+        chunks[idx] = chunk;
+        await this.redisClient.jsonSet(`[${roomId}]`, '.', chunks);
+        return chunk;
+    }
+    async areTranslationsProcessed(roomId, chunkNumber) {
+        const chunk = await this.getMulingstreamChunkById(roomId, chunkNumber);
+        if (!chunk) {
+            return false;
+        }
+        return Object.values(chunk.translation).every((t) => t.status !== 'INIT');
+    }
+    async getAllReadyTts(roomId, language) {
+        const chunks = await this.getMulingstreamChunksByRoom(roomId);
+        if (!(chunks === null || chunks === void 0 ? void 0 : chunks.length))
+            return [];
+        // chunks are received in consecutive order already, no need for sorting for now (maybe in the future we have more speaker in a room, so we may need sorting)
+        // chunks.sort((a, b) => a.chunkNumber - b.chunkNumber);
+        /* ---- isolate the tail where the language exists ---- */
+        let lastLangIdx = -1;
+        for (let i = chunks.length - 1; i >= 0; i--) {
+            if (chunks[i].tts[language]) {
+                lastLangIdx = i;
+                break;
+            }
+        }
+        if (lastLangIdx === -1)
+            return [];
+        let firstLangIdx = lastLangIdx;
+        for (let i = lastLangIdx - 1; i >= 0; i--) {
+            if (!chunks[i].tts[language])
+                break;
+            firstLangIdx = i;
+        }
+        const window = chunks.slice(firstLangIdx, lastLangIdx + 1);
+        /* ---- find last USED / DISCARDED in that window ---- */
+        let lastDone = -1;
+        for (let i = window.length - 1; i >= 0; i--) {
+            const st = window[i].tts[language].status;
+            if (st === 'USED' || st === 'DISCARDED') {
+                lastDone = i;
+                break;
+            }
+        }
+        const ready = [];
+        let blocked = false;
+        const now = Date.now();
+        for (let i = lastDone + 1; i < window.length; i++) {
+            const entry = window[i].tts[language];
+            const audioChunk = window[i].audioChunk;
+            if (entry.status === 'INIT') {
+                const timeout = this.getTimeout(audioChunk.start, audioChunk.end);
+                console.log('AUDIO LENGTH: ', audioChunk.end - audioChunk.start, ' TIMEOUT BASED ON AUDIO LENGTH: ', timeout, ' SINCE CREATED UNTIL NOW: ', now - window[i].createdAt);
+                if (now - window[i].createdAt > timeout) {
+                    entry.status = 'DISCARDED';
+                }
+                else {
+                    blocked = true;
+                }
+                continue;
+            }
+            if (entry.status === 'READY') {
+                if (blocked)
+                    break; // earlier INIT still pending
+                ready.push(window[i]);
+                continue;
+            }
+            break; // unexpected USED / DISCARDED
+        }
+        // persist any DISCARDED changes we made
+        if (ready.length === 0 || blocked) {
+            await this.redisClient.jsonSet(`[${roomId}]`, '.', chunks);
+        }
+        return ready;
+    }
+}
+exports.MulingstreamChunkManager = MulingstreamChunkManager;