@mulingai-npm/redis 3.1.1 → 3.2.0

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

@@ -1,382 +1,366 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MulingstreamChunkManager = void 0;
-const uuid_1 = require("uuid");
-/* -------------------------------------------------------------------------- */
-/*                                Constants                                   */
-/* -------------------------------------------------------------------------- */
-const EXPIRATION = 12 * 60 * 60; // 12 h
-const ROOM_ARRAY_LENGTH = 50; // keep last 50 chunks
-/* -------------------------------------------------------------------------- */
-/*                               Main class                                   */
-/* -------------------------------------------------------------------------- */
-class MulingstreamChunkManager {
-    constructor(redisClient) {
-        this.redisClient = redisClient;
-    }
-    /* ----------------------------- key helpers ----------------------------- */
-    roomZsetKey(roomId) {
-        return `room:${roomId}:chunks`;
-    }
-    chunkHashKey(chunkId) {
-        return `chunk:${chunkId}`;
-    }
-    generateChunkId(roomId, chunkNumber) {
-        return `[${roomId}]-[${chunkNumber}]-[${(0, uuid_1.v4)()}]`;
-    }
-    /* --------------------------- (de)serialization -------------------------- */
-    serialize(value) {
-        return JSON.stringify(value);
-    }
-    deserialize(v) {
-        return v ? JSON.parse(v) : undefined;
-    }
-    hashToChunk(h) {
-        return {
-            chunkId: h.chunkId,
-            roomId: h.roomId,
-            chunkNumber: parseInt(h.chunkNumber, 10),
-            language: h.language,
-            sttProviders: this.deserialize(h.sttProviders),
-            targetLanguages: this.deserialize(h.targetLanguages),
-            shortCodeTargetLanguages: this.deserialize(h.shortCodeTargetLanguages),
-            finalTranscription: h.finalTranscription,
-            sttStatus: h.sttStatus,
-            createdAt: parseInt(h.createdAt, 10),
-            audioChunk: this.deserialize(h.audioChunk),
-            stt: this.deserialize(h.stt),
-            translation: this.deserialize(h.translation),
-            tts: this.deserialize(h.tts)
-        };
-    }
-    /* ------------------------------ timeouts ------------------------------- */
-    getTimeout(start, end) {
-        // const len = end - start;
-        // if (len < 1_000) return 1_500;
-        // if (len < 3_000) return 3_000;
-        // if (len < 5_000) return 7_000;
-        // if (len < 8_000) return 10_000;
-        // if (len < 12_000) return 15_000;
-        // if (len < 20_000) return 20_000;
-        return 30000;
-    }
-    /* ---------------------------------------------------------------------- */
-    /*                           Public API (same)                            */
-    /* ---------------------------------------------------------------------- */
-    /* Room helpers ---------------------------------------------------------- */
-    async initRoom(roomId) {
-        const exists = await this.redisClient.exists(this.roomZsetKey(roomId));
-        if (exists)
-            return false;
-        await this.redisClient.expire(this.roomZsetKey(roomId), EXPIRATION);
-        return true;
-    }
-    async getRooms() {
-        const keys = await this.redisClient.keys('room:*:chunks');
-        return keys.map((k) => k.replace(/^room:(.*):chunks$/, '$1'));
-    }
-    async getMulingstreamChunksByRoom(roomId) {
-        const ids = await this.redisClient.zrange(this.roomZsetKey(roomId), 0, -1);
-        if (!ids.length)
-            return null;
-        const pipe = this.redisClient.pipeline();
-        ids.forEach((cid) => pipe.hgetall(this.chunkHashKey(cid)));
-        const res = await pipe.exec();
-        if (!res)
-            return null;
-        return res === null || res === void 0 ? void 0 : res.map(([, d]) => this.hashToChunk(d));
-    }
-    getRoomById(roomId) {
-        return this.getMulingstreamChunksByRoom(roomId);
-    }
-    /* ------------------------- chunk insertion ---------------------------- */
-    async addMulingstreamChunk(params) {
-        var _a, _b;
-        const { roomId, chunkNumber, language, start, end, duration, isFirst, isLast, theme, sttProviders, targetLanguages, shortCodeTargetLanguages } = params;
-        /* ---------- reset room on first chunk ---------- */
-        if (chunkNumber === 1) {
-            const old = await this.redisClient.zrange(this.roomZsetKey(roomId), 0, -1);
-            if (old.length) {
-                const p = this.redisClient.pipeline();
-                old.forEach((cid) => p.unlink(this.chunkHashKey(cid)));
-                p.del(this.roomZsetKey(roomId));
-                await p.exec();
-            }
-        }
-        else {
-            // remove older duplicate with same chunkNumber
-            const dup = await this.redisClient.zrangebyscore(this.roomZsetKey(roomId), chunkNumber, chunkNumber);
-            if (dup.length) {
-                const p = this.redisClient.pipeline();
-                dup.forEach((cid) => p.unlink(this.chunkHashKey(cid)));
-                p.zrem(this.roomZsetKey(roomId), ...dup);
-                await p.exec();
-            }
-        }
-        /* ---------- build new chunk ---------- */
-        const chunkId = this.generateChunkId(roomId, chunkNumber);
-        const audioChunk = { start, end, duration, isFirst, isLast, theme, processingStart: Date.now() };
-        const stt = {};
-        sttProviders.forEach((p) => (stt[p] = { transcription: '', status: 'INIT' }));
-        const translation = {};
-        const tts = {};
-        shortCodeTargetLanguages.forEach((l) => {
-            translation[l] = { translation: '', status: 'INIT' };
-            tts[l] = { ttsAudioPath: '', status: 'INIT', isEmitted: false, totalCheck: 0 };
-        });
-        const hash = {
-            chunkId,
-            roomId,
-            chunkNumber: String(chunkNumber),
-            language,
-            sttProviders: this.serialize(sttProviders),
-            targetLanguages: this.serialize(targetLanguages),
-            shortCodeTargetLanguages: this.serialize(shortCodeTargetLanguages),
-            finalTranscription: '',
-            sttStatus: 'INIT',
-            createdAt: String(Date.now()),
-            audioChunk: this.serialize(audioChunk),
-            stt: this.serialize(stt),
-            translation: this.serialize(translation),
-            tts: this.serialize(tts)
-        };
-        /* ---------- write + trim (pipeline) ---------- */
-        const pipe = this.redisClient.pipeline();
-        pipe.hset(this.chunkHashKey(chunkId), hash);
-        pipe.expire(this.chunkHashKey(chunkId), EXPIRATION);
-        pipe.zadd(this.roomZsetKey(roomId), chunkNumber, chunkId);
-        pipe.expire(this.roomZsetKey(roomId), EXPIRATION);
-        pipe.zrange(this.roomZsetKey(roomId), 0, -ROOM_ARRAY_LENGTH - 1, 'WITHSCORES');
-        const execResults = await pipe.exec();
-        /* execResults can be null or shorter than expected — fall back to an empty list */
-        const oldPairs = ((_b = (_a = execResults === null || execResults === void 0 ? void 0 : execResults[4]) === null || _a === void 0 ? void 0 : _a[1]) !== null && _b !== void 0 ? _b : []); // [id1, score1, id2, score2, ...]
-        if (Array.isArray(oldPairs) && oldPairs.length) {
-            const oldIds = [];
-            for (let i = 0; i < oldPairs.length; i += 2)
-                oldIds.push(oldPairs[i]);
-            const trim = this.redisClient.pipeline();
-            trim.zrem(this.roomZsetKey(roomId), ...oldIds);
-            oldIds.forEach((cid) => trim.unlink(this.chunkHashKey(cid)));
-            await trim.exec();
-        }
-    }
-    /* --------------------------- helper lookup ---------------------------- */
-    async getChunkId(roomId, n) {
-        const ids = await this.redisClient.zrangebyscore(this.roomZsetKey(roomId), n, n);
-        return ids.length ? ids[0] : null;
-    }
-    async getMulingstreamChunkById(roomId, n) {
-        const cid = await this.getChunkId(roomId, n);
-        if (!cid)
-            return null;
-        const raw = await this.redisClient.hgetall(this.chunkHashKey(cid));
-        return raw.chunkId ? this.hashToChunk(raw) : null;
-    }
-    /* ------------------------------ Updaters ------------------------------ */
-    /* helper to fetch-mutate-save one chunk */
-    async withChunk(roomId, n, fn) {
-        const cid = await this.getChunkId(roomId, n);
-        if (!cid)
-            return null;
-        const key = this.chunkHashKey(cid);
-        const raw = await this.redisClient.hgetall(key);
-        if (!raw.chunkId)
-            return null;
-        const chunk = this.hashToChunk(raw);
-        const out = await fn(chunk);
-        const p = this.redisClient.pipeline();
-        p.hset(key, {
-            finalTranscription: chunk.finalTranscription,
-            sttStatus: chunk.sttStatus,
-            stt: this.serialize(chunk.stt),
-            translation: this.serialize(chunk.translation),
-            tts: this.serialize(chunk.tts)
-        });
-        p.expire(key, EXPIRATION);
-        await p.exec();
-        return out;
-    }
-    /* ---- specific update methods (same signatures as before) ---- */
-    async updateStt(roomId, n, provider, opt) {
-        return ((await this.withChunk(roomId, n, (c) => {
-            if (!c.stt[provider])
-                return false;
-            if (opt.transcription !== undefined)
-                c.stt[provider].transcription = opt.transcription;
-            if (opt.sttStatus !== undefined)
-                c.stt[provider].status = opt.sttStatus;
-            return true;
-        })) === true);
-    }
-    async updateSttObject(roomId, n, newStt) {
-        return ((await this.withChunk(roomId, n, (c) => {
-            c.stt = newStt;
-            return true;
-        })) === true);
-    }
-    async discardStt(roomId, n) {
-        return ((await this.withChunk(roomId, n, (c) => {
-            Object.keys(c.stt).forEach((p) => {
-                c.stt[p].transcription = '';
-                c.stt[p].status = 'DISCARDED';
-            });
-            c.finalTranscription = '';
-            c.sttStatus = 'DISCARDED';
-            return true;
-        })) === true);
-    }
-    async updateFinalTranscription(roomId, n, opt) {
-        return this.withChunk(roomId, n, (c) => {
-            if (opt.transcription !== undefined)
-                c.finalTranscription = opt.transcription;
-            if (opt.sttStatus !== undefined)
-                c.sttStatus = opt.sttStatus;
-            return c;
-        });
-    }
-    async discardPostStt(roomId, n) {
-        return ((await this.withChunk(roomId, n, (c) => {
-            Object.values(c.translation).forEach((t) => (t.status = 'DISCARDED'));
-            Object.values(c.tts).forEach((t) => (t.status = 'DISCARDED'));
-            return true;
-        })) === true);
-    }
-    async discardLanguage(roomId, n, lang) {
-        return ((await this.withChunk(roomId, n, (c) => {
-            if (c.translation[lang])
-                c.translation[lang].status = 'DISCARDED';
-            if (c.tts[lang])
-                c.tts[lang].status = 'DISCARDED';
-            return true;
-        })) === true);
-    }
-    async discardLanguages(roomId, n, opt) {
-        return this.withChunk(roomId, n, (c) => {
-            var _a, _b;
-            (_a = opt.translation) === null || _a === void 0 ? void 0 : _a.forEach((l) => {
-                const e = c.translation[l];
-                if (e && e.status === 'INIT')
-                    e.status = 'DISCARDED';
-            });
-            (_b = opt.tts) === null || _b === void 0 ? void 0 : _b.forEach((l) => {
-                const e = c.tts[l];
-                if (e && e.status === 'INIT')
-                    e.status = 'DISCARDED';
-            });
-            return c;
-        });
-    }
-    async updateTranslation(roomId, n, lang, opt) {
-        return this.withChunk(roomId, n, (c) => {
-            const e = c.translation[lang];
-            if (!e)
-                return null;
-            if (opt.translation !== undefined)
-                e.translation = opt.translation;
-            if (opt.status !== undefined)
-                e.status = opt.status;
-            return c;
-        });
-    }
-    async updateTranslationInBulk(roomId, n, dict, status = 'READY') {
-        return this.withChunk(roomId, n, (c) => {
-            Object.entries(dict).forEach(([l, txt]) => {
-                if (!c.translation[l])
-                    return;
-                c.translation[l].translation = txt;
-                c.translation[l].status = status;
-            });
-            return c;
-        });
-    }
-    async updateTts(roomId, n, lang, opt) {
-        return this.withChunk(roomId, n, (c) => {
-            const e = c.tts[lang];
-            if (!e)
-                return null;
-            if (opt.ttsAudioPath !== undefined)
-                e.ttsAudioPath = opt.ttsAudioPath;
-            if (opt.status !== undefined)
-                e.status = opt.status;
-            if (opt.isEmitted !== undefined)
-                e.isEmitted = opt.isEmitted;
-            if (opt.totalCheck !== undefined)
-                e.totalCheck = opt.totalCheck;
-            return c;
-        });
-    }
-    async increaseTotalCheck(roomId, n, lang) {
-        return this.withChunk(roomId, n, (c) => {
-            if (!c.tts[lang])
-                return null;
-            c.tts[lang].totalCheck += 1;
-            return c;
-        });
-    }
-    async areTranslationsProcessed(roomId, n) {
-        const c = await this.getMulingstreamChunkById(roomId, n);
-        return !!c && Object.values(c.translation).every((t) => t.status !== 'INIT');
-    }
-    /* -------------------------- READY-TTS sequence ------------------------- */
-    async getAllReadyTts(roomId, lang) {
-        var _a;
-        const chunks = (_a = (await this.getMulingstreamChunksByRoom(roomId))) !== null && _a !== void 0 ? _a : [];
-        if (!chunks.length)
-            return [];
-        chunks.sort((a, b) => a.chunkNumber - b.chunkNumber);
-        /* isolate window where lang exists */
-        let lastIdx = -1;
-        for (let i = chunks.length - 1; i >= 0; i--)
-            if (chunks[i].tts[lang]) {
-                lastIdx = i;
-                break;
-            }
-        if (lastIdx === -1)
-            return [];
-        let firstIdx = lastIdx;
-        for (let i = lastIdx - 1; i >= 0; i--) {
-            if (!chunks[i].tts[lang])
-                break;
-            firstIdx = i;
-        }
-        const window = chunks.slice(firstIdx, lastIdx + 1);
-        /* find last USED/DISCARDED */
-        let lastDone = -1;
-        for (let i = window.length - 1; i >= 0; i--) {
-            const s = window[i].tts[lang].status;
-            if (s === 'USED' || s === '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[lang];
-            const audio = window[i].audioChunk;
-            if (entry.status === 'INIT') {
-                if (now - window[i].createdAt > this.getTimeout(audio.start, audio.end))
-                    entry.status = 'DISCARDED';
-                else
-                    blocked = true;
-                continue;
-            }
-            if (entry.status === 'READY') {
-                if (blocked)
-                    break;
-                ready.push(window[i]);
-                continue;
-            }
-            break; // got USED/DISCARDED unexpectedly
-        }
-        /* persist DISCARDED changes (if any) */
-        if (!ready.length || blocked) {
-            const p = this.redisClient.pipeline();
-            window.forEach((c) => p.hset(this.chunkHashKey(c.chunkId), { tts: this.serialize(c.tts) }));
-            await p.exec();
-        }
-        return ready;
-    }
-}
-exports.MulingstreamChunkManager = MulingstreamChunkManager;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MulingstreamChunkManager = void 0;
+const uuid_1 = require("uuid");
+/* -------------------------------------------------------------------------- */
+/*                                Constants                                   */
+/* -------------------------------------------------------------------------- */
+const EXPIRATION = 12 * 60 * 60; // 12 h
+const ROOM_ARRAY_LENGTH = 50; // keep last 50 chunks
+/* -------------------------------------------------------------------------- */
+/*                               Main class                                   */
+/* -------------------------------------------------------------------------- */
+class MulingstreamChunkManager {
+    constructor(redisClient) {
+        this.redisClient = redisClient;
+    }
+    /* ----------------------------- key helpers ----------------------------- */
+    roomZsetKey(roomId) {
+        return `room:${roomId}:chunks`;
+    }
+    chunkHashKey(chunkId) {
+        return `chunk:${chunkId}`;
+    }
+    generateChunkId(roomId, chunkNumber) {
+        return `[${roomId}]-[${chunkNumber}]-[${(0, uuid_1.v4)()}]`;
+    }
+    /* --------------------------- (de)serialization -------------------------- */
+    serialize(value) {
+        return JSON.stringify(value);
+    }
+    deserialize(v) {
+        return v ? JSON.parse(v) : undefined;
+    }
+    hashToChunk(h) {
+        return {
+            chunkId: h.chunkId,
+            roomId: h.roomId,
+            chunkNumber: parseInt(h.chunkNumber, 10),
+            language: h.language,
+            sttProviders: this.deserialize(h.sttProviders),
+            targetLanguages: this.deserialize(h.targetLanguages),
+            shortCodeTargetLanguages: this.deserialize(h.shortCodeTargetLanguages),
+            finalTranscription: h.finalTranscription,
+            sttStatus: h.sttStatus,
+            createdAt: parseInt(h.createdAt, 10),
+            audioChunk: this.deserialize(h.audioChunk),
+            stt: this.deserialize(h.stt),
+            translation: this.deserialize(h.translation),
+            tts: this.deserialize(h.tts)
+        };
+    }
+    /* ------------------------------ timeouts ------------------------------- */
+    getTimeout(start, end) {
+        return 30000;
+    }
+    /* ---------------------------------------------------------------------- */
+    /*                           Public API (same)                            */
+    /* ---------------------------------------------------------------------- */
+    /* Room helpers ---------------------------------------------------------- */
+    async initRoom(roomId) {
+        const exists = await this.redisClient.exists(this.roomZsetKey(roomId));
+        if (exists)
+            return false;
+        await this.redisClient.expire(this.roomZsetKey(roomId), EXPIRATION);
+        return true;
+    }
+    async getRooms() {
+        const keys = await this.redisClient.keys('room:*:chunks');
+        return keys.map((k) => k.replace(/^room:(.*):chunks$/, '$1'));
+    }
+    async getMulingstreamChunksByRoom(roomId) {
+        const ids = await this.redisClient.zrange(this.roomZsetKey(roomId), 0, -1);
+        if (!ids.length)
+            return null;
+        const pipe = this.redisClient.pipeline();
+        ids.forEach((cid) => pipe.hgetall(this.chunkHashKey(cid)));
+        const res = await pipe.exec();
+        if (!res)
+            return null;
+        return res === null || res === void 0 ? void 0 : res.map(([, d]) => this.hashToChunk(d));
+    }
+    getRoomById(roomId) {
+        return this.getMulingstreamChunksByRoom(roomId);
+    }
+    /* ------------------------- chunk insertion ---------------------------- */
+    async addMulingstreamChunk(params) {
+        var _a, _b;
+        const { roomId, chunkNumber, language, start, end, duration, isFirst, isLast, theme, sttProviders, targetLanguages, shortCodeTargetLanguages } = params;
+        if (chunkNumber === 1) {
+            const old = await this.redisClient.zrange(this.roomZsetKey(roomId), 0, -1);
+            if (old.length) {
+                const p = this.redisClient.pipeline();
+                old.forEach((cid) => p.unlink(this.chunkHashKey(cid)));
+                p.del(this.roomZsetKey(roomId));
+                await p.exec();
+            }
+        }
+        else {
+            const dup = await this.redisClient.zrangebyscore(this.roomZsetKey(roomId), chunkNumber, chunkNumber);
+            if (dup.length) {
+                const p = this.redisClient.pipeline();
+                dup.forEach((cid) => p.unlink(this.chunkHashKey(cid)));
+                p.zrem(this.roomZsetKey(roomId), ...dup);
+                await p.exec();
+            }
+        }
+        const chunkId = this.generateChunkId(roomId, chunkNumber);
+        const audioChunk = { start, end, duration, isFirst, isLast, theme, processingStart: Date.now() };
+        const stt = {};
+        sttProviders.forEach((p) => (stt[p.service] = { transcription: '', model: p.model, status: 'INIT' }));
+        const translation = {};
+        const tts = {};
+        shortCodeTargetLanguages.forEach((l) => {
+            translation[l] = { translation: '', status: 'INIT' };
+            tts[l] = { ttsAudioPath: '', status: 'INIT', isEmitted: false, totalCheck: 0 };
+        });
+        const hash = {
+            chunkId,
+            roomId,
+            chunkNumber: String(chunkNumber),
+            language,
+            sttProviders: this.serialize(sttProviders),
+            targetLanguages: this.serialize(targetLanguages),
+            shortCodeTargetLanguages: this.serialize(shortCodeTargetLanguages),
+            finalTranscription: '',
+            sttStatus: 'INIT',
+            createdAt: String(Date.now()),
+            audioChunk: this.serialize(audioChunk),
+            stt: this.serialize(stt),
+            translation: this.serialize(translation),
+            tts: this.serialize(tts)
+        };
+        const pipe = this.redisClient.pipeline();
+        pipe.hset(this.chunkHashKey(chunkId), hash);
+        pipe.expire(this.chunkHashKey(chunkId), EXPIRATION);
+        pipe.zadd(this.roomZsetKey(roomId), chunkNumber, chunkId);
+        pipe.expire(this.roomZsetKey(roomId), EXPIRATION);
+        pipe.zrange(this.roomZsetKey(roomId), 0, -ROOM_ARRAY_LENGTH - 1, 'WITHSCORES');
+        const execResults = await pipe.exec();
+        const oldPairs = ((_b = (_a = execResults === null || execResults === void 0 ? void 0 : execResults[4]) === null || _a === void 0 ? void 0 : _a[1]) !== null && _b !== void 0 ? _b : []);
+        if (Array.isArray(oldPairs) && oldPairs.length) {
+            const oldIds = [];
+            for (let i = 0; i < oldPairs.length; i += 2)
+                oldIds.push(oldPairs[i]);
+            const trim = this.redisClient.pipeline();
+            trim.zrem(this.roomZsetKey(roomId), ...oldIds);
+            oldIds.forEach((cid) => trim.unlink(this.chunkHashKey(cid)));
+            await trim.exec();
+        }
+    }
+    /* --------------------------- helper lookup ---------------------------- */
+    async getChunkId(roomId, n) {
+        const ids = await this.redisClient.zrangebyscore(this.roomZsetKey(roomId), n, n);
+        return ids.length ? ids[0] : null;
+    }
+    async getMulingstreamChunkById(roomId, n) {
+        const cid = await this.getChunkId(roomId, n);
+        if (!cid)
+            return null;
+        const raw = await this.redisClient.hgetall(this.chunkHashKey(cid));
+        return raw.chunkId ? this.hashToChunk(raw) : null;
+    }
+    /* ------------------------------ Updaters ------------------------------ */
+    /* helper to fetch-mutate-save one chunk */
+    async withChunk(roomId, n, fn) {
+        const cid = await this.getChunkId(roomId, n);
+        if (!cid)
+            return null;
+        const key = this.chunkHashKey(cid);
+        const raw = await this.redisClient.hgetall(key);
+        if (!raw.chunkId)
+            return null;
+        const chunk = this.hashToChunk(raw);
+        const out = await fn(chunk);
+        const p = this.redisClient.pipeline();
+        p.hset(key, {
+            finalTranscription: chunk.finalTranscription,
+            sttStatus: chunk.sttStatus,
+            stt: this.serialize(chunk.stt),
+            translation: this.serialize(chunk.translation),
+            tts: this.serialize(chunk.tts)
+        });
+        p.expire(key, EXPIRATION);
+        await p.exec();
+        return out;
+    }
+    async updateStt(roomId, n, service, opt) {
+        return ((await this.withChunk(roomId, n, (c) => {
+            if (!c.stt[service])
+                return false;
+            if (opt.transcription !== undefined)
+                c.stt[service].transcription = opt.transcription;
+            if (opt.sttStatus !== undefined)
+                c.stt[service].status = opt.sttStatus;
+            return true;
+        })) === true);
+    }
+    async updateSttObject(roomId, n, newStt) {
+        return ((await this.withChunk(roomId, n, (c) => {
+            c.stt = newStt;
+            return true;
+        })) === true);
+    }
+    async discardStt(roomId, n) {
+        return ((await this.withChunk(roomId, n, (c) => {
+            Object.keys(c.stt).forEach((p) => {
+                c.stt[p].transcription = '';
+                c.stt[p].status = 'DISCARDED';
+            });
+            c.finalTranscription = '';
+            c.sttStatus = 'DISCARDED';
+            return true;
+        })) === true);
+    }
+    async updateFinalTranscription(roomId, n, opt) {
+        return this.withChunk(roomId, n, (c) => {
+            if (opt.transcription !== undefined)
+                c.finalTranscription = opt.transcription;
+            if (opt.sttStatus !== undefined)
+                c.sttStatus = opt.sttStatus;
+            return c;
+        });
+    }
+    async discardPostStt(roomId, n) {
+        return ((await this.withChunk(roomId, n, (c) => {
+            Object.values(c.translation).forEach((t) => (t.status = 'DISCARDED'));
+            Object.values(c.tts).forEach((t) => (t.status = 'DISCARDED'));
+            return true;
+        })) === true);
+    }
+    async discardLanguage(roomId, n, lang) {
+        return ((await this.withChunk(roomId, n, (c) => {
+            if (c.translation[lang])
+                c.translation[lang].status = 'DISCARDED';
+            if (c.tts[lang])
+                c.tts[lang].status = 'DISCARDED';
+            return true;
+        })) === true);
+    }
+    async discardLanguages(roomId, n, opt) {
+        return this.withChunk(roomId, n, (c) => {
+            var _a, _b;
+            (_a = opt.translation) === null || _a === void 0 ? void 0 : _a.forEach((l) => {
+                const e = c.translation[l];
+                if (e && e.status === 'INIT')
+                    e.status = 'DISCARDED';
+            });
+            (_b = opt.tts) === null || _b === void 0 ? void 0 : _b.forEach((l) => {
+                const e = c.tts[l];
+                if (e && e.status === 'INIT')
+                    e.status = 'DISCARDED';
+            });
+            return c;
+        });
+    }
+    async updateTranslation(roomId, n, lang, opt) {
+        return this.withChunk(roomId, n, (c) => {
+            const e = c.translation[lang];
+            if (!e)
+                return null;
+            if (opt.translation !== undefined)
+                e.translation = opt.translation;
+            if (opt.status !== undefined)
+                e.status = opt.status;
+            return c;
+        });
+    }
+    async updateTranslationInBulk(roomId, n, dict, status = 'READY') {
+        return this.withChunk(roomId, n, (c) => {
+            Object.entries(dict).forEach(([l, txt]) => {
+                if (!c.translation[l])
+                    return;
+                c.translation[l].translation = txt;
+                c.translation[l].status = status;
+            });
+            return c;
+        });
+    }
+    async updateTts(roomId, n, lang, opt) {
+        return this.withChunk(roomId, n, (c) => {
+            const e = c.tts[lang];
+            if (!e)
+                return null;
+            if (opt.ttsAudioPath !== undefined)
+                e.ttsAudioPath = opt.ttsAudioPath;
+            if (opt.status !== undefined)
+                e.status = opt.status;
+            if (opt.isEmitted !== undefined)
+                e.isEmitted = opt.isEmitted;
+            if (opt.totalCheck !== undefined)
+                e.totalCheck = opt.totalCheck;
+            return c;
+        });
+    }
+    async increaseTotalCheck(roomId, n, lang) {
+        return this.withChunk(roomId, n, (c) => {
+            if (!c.tts[lang])
+                return null;
+            c.tts[lang].totalCheck += 1;
+            return c;
+        });
+    }
+    async areTranslationsProcessed(roomId, n) {
+        const c = await this.getMulingstreamChunkById(roomId, n);
+        return !!c && Object.values(c.translation).every((t) => t.status !== 'INIT');
+    }
+    /* -------------------------- READY-TTS sequence ------------------------- */
+    async getAllReadyTts(roomId, lang) {
+        var _a;
+        const chunks = (_a = (await this.getMulingstreamChunksByRoom(roomId))) !== null && _a !== void 0 ? _a : [];
+        if (!chunks.length)
+            return [];
+        chunks.sort((a, b) => a.chunkNumber - b.chunkNumber);
+        let lastIdx = -1;
+        for (let i = chunks.length - 1; i >= 0; i--)
+            if (chunks[i].tts[lang]) {
+                lastIdx = i;
+                break;
+            }
+        if (lastIdx === -1)
+            return [];
+        let firstIdx = lastIdx;
+        for (let i = lastIdx - 1; i >= 0; i--) {
+            if (!chunks[i].tts[lang])
+                break;
+            firstIdx = i;
+        }
+        const window = chunks.slice(firstIdx, lastIdx + 1);
+        let lastDone = -1;
+        for (let i = window.length - 1; i >= 0; i--) {
+            const s = window[i].tts[lang].status;
+            if (s === 'USED' || s === '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[lang];
+            const audio = window[i].audioChunk;
+            if (entry.status === 'INIT') {
+                if (now - window[i].createdAt > this.getTimeout(audio.start, audio.end))
+                    entry.status = 'DISCARDED';
+                else
+                    blocked = true;
+                continue;
+            }
+            if (entry.status === 'READY') {
+                if (blocked)
+                    break;
+                ready.push(window[i]);
+                continue;
+            }
+            break;
+        }
+        if (!ready.length || blocked) {
+            const p = this.redisClient.pipeline();
+            window.forEach((c) => p.hset(this.chunkHashKey(c.chunkId), { tts: this.serialize(c.tts) }));
+            await p.exec();
+        }
+        return ready;
+    }
+}
+exports.MulingstreamChunkManager = MulingstreamChunkManager;