@mulingai-npm/redis 3.40.27 → 3.40.29

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

@@ -122,13 +122,27 @@ export declare class MulingstreamChunkManager {
     }): Promise<MulingstreamChunkData>;
     private getChunkId;
     getMulingstreamChunkById(roomId: string, n: number): Promise<MulingstreamChunkData>;
-    private withChunk;
+    /**
+     * Partial HSET — touches only `finalTranscription`. See setBufferStatus for the
+     * race rationale (whole-chunk read-modify-write would clobber concurrent updates).
+     */
     updateFinalTranscription(roomId: string, n: number, transcription: string): Promise<MulingstreamChunkData | null>;
     /**
      * Update chunk with LLM-sanitized transcription from SmartTranslate.
      * If the sanitized text differs from the original, sets transcriptionSource to 'llm'
      * and updates finalTranscription to the sanitized version.
      * Returns the chunk (caller can compare original vs sanitized to decide on TRANSCRIPTION_CORRECTED).
+     *
+     * IMPORTANT — partial HSET, NOT withChunk(). Reasoning identical to setBufferStatus:
+     * handleTtsService runs in parallel and writes `tts.<lang>.status = READY`. The
+     * read-modify-write of withChunk would clobber that READY back to INIT (we read
+     * tts before TTS callback fires, then write the entire chunk back later). Result:
+     * emitChunk's `if (status !== READY) return;` drops the audio publish, listeners
+     * see text but never get the audio URL.
+     *
+     * This bug surfaced 2026-05-01: same root cause as the earlier setBufferStatus
+     * race; updateLlmTranscription wasn't fixed at the same time so it kept producing
+     * silent audio for any chunk where wasSanitized=true (i.e. every LLM-routed chunk).
      */
     updateLlmTranscription(roomId: string, n: number, opts: {
         llmTranscription: string;
@@ -139,16 +153,37 @@ export declare class MulingstreamChunkManager {
         chunk: MulingstreamChunkData | null;
         wasChanged: boolean;
     }>;
+    /**
+     * Partial HSET — reads only `translation` and `tts` fields, modifies in place,
+     * writes back only those two. See setBufferStatus for the race rationale.
+     */
     discardLanguage(roomId: string, n: number, lang: string): Promise<MulingstreamChunkData | null>;
+    /**
+     * Partial HSET — same race-safe pattern as discardLanguage. Only writes the
+     * fields actually mutated by the caller (translation and/or tts).
+     */
     discardLanguages(roomId: string, n: number, opt: {
         translation?: string[];
         tts?: string[];
     }): Promise<MulingstreamChunkData | null>;
+    /**
+     * Partial HSET — only `translation` is read and rewritten. Concurrent updateTts
+     * calls won't be clobbered.
+     */
     updateTranslation(roomId: string, n: number, lang: string, opt: {
         translation?: string;
         status?: StepStatus;
     }): Promise<MulingstreamChunkData | null>;
+    /**
+     * Partial HSET — only `translation` is read and rewritten. This is the hot path
+     * that races with handleTtsService's updateTts and was the root cause of the
+     * "audio LISTENER_FEED never arrives" bug fixed 2026-05-01.
+     */
     updateTranslationInBulk(roomId: string, n: number, dict: Record<string, string>, status?: StepStatus, hintsPerLanguage?: Record<string, TranslationHint[]>): Promise<MulingstreamChunkData | null>;
+    /**
+     * Partial HSET — only `tts` is read and rewritten. Same race-rationale as
+     * updateTranslationInBulk: avoids clobbering concurrent translation writes.
+     */
     updateTts(roomId: string, n: number, lang: string, opt: {
         ttsAudioPath?: string;
         status?: StepStatus;
@@ -159,6 +194,13 @@ export declare class MulingstreamChunkManager {
      * Update SmartTranslate buffering metadata on a chunk (Section 22).
      * Writes `bufferStatus`, `pendingText`, and `consumedChunkNumbers` so the chunk row
      * persisted at the end of the pipeline reflects whether it was DEFERRED / USED / EMITTED.
+     *
+     * IMPORTANT — this is a partial HSET that touches ONLY the buffering fields.
+     * It deliberately does NOT use `withChunk()` (which rewrites the whole chunk hash)
+     * because handleTtsService can update `tts` concurrently with this call. Using the
+     * read-modify-write pattern of withChunk would race with TTS status updates and
+     * clobber `tts.<lang>.status = READY` back to INIT — preventing the audio sequencer
+     * from emitting the listener feed (audio came through as text-only with audio:"").
      */
     setBufferStatus(roomId: string, n: number, opt: {
         bufferStatus?: 'EMITTED' | 'DEFERRED' | 'USED';
@@ -171,11 +213,13 @@ export declare class MulingstreamChunkManager {
      */
     isChunkComplete(roomId: string, n: number): Promise<boolean>;
     /**
-     * Mark a chunk as complete (all TTS finished for all target languages)
+     * Mark a chunk as complete (all TTS finished for all target languages).
+     * Partial HSET — touches only `isComplete`.
      */
     markChunkComplete(roomId: string, n: number): Promise<MulingstreamChunkData | null>;
     /**
-     * Mark a chunk as saved to database
+     * Mark a chunk as saved to database.
+     * Partial HSET — touches only `isSaved`.
      */
     markChunkSaved(roomId: string, n: number): Promise<MulingstreamChunkData | null>;
     /**

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

@@ -45,7 +45,11 @@ class MulingstreamChunkManager {
             llmWords: h.llmWords ? this.deserialize(h.llmWords) : undefined,
             transcriptionSource: h.transcriptionSource || 'stt',
             routeUsed: h.routeUsed || undefined,
-            sttHistory: h.sttHistory ? this.deserialize(h.sttHistory) : undefined
+            sttHistory: h.sttHistory ? this.deserialize(h.sttHistory) : undefined,
+            // SmartTranslate buffering (Section 22)
+            bufferStatus: h.bufferStatus || undefined,
+            pendingText: h.pendingText || undefined,
+            consumedChunkNumbers: h.consumedChunkNumbers ? this.deserialize(h.consumedChunkNumbers) : undefined
         };
     }
     getTimeout() {
@@ -211,151 +215,266 @@ class MulingstreamChunkManager {
         const raw = await this.redisClient.hgetall(this.chunkHashKey(cid));
         return raw.chunkId ? this.hashToChunk(raw) : null;
     }
-    async withChunk(roomId, n, fn) {
+    // NOTE — `withChunk` was removed 2026-05-01. Its read-modify-write pattern
+    // raced with concurrent updates to other fields and clobbered them on writeback.
+    // All mutators now use partial HSETs that read and write only the fields they own.
+    // If you need a new mutator, follow the pattern of `updateTts` / `updateTranslationInBulk`.
+    /**
+     * Partial HSET — touches only `finalTranscription`. See setBufferStatus for the
+     * race rationale (whole-chunk read-modify-write would clobber concurrent updates).
+     */
+    async updateFinalTranscription(roomId, n, transcription) {
         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);
-        await fn(chunk);
-        const p = this.redisClient.pipeline();
-        const updateHash = {
-            finalTranscription: chunk.finalTranscription,
-            translation: this.serialize(chunk.translation),
-            tts: this.serialize(chunk.tts),
-            streamingChunk: this.serialize(chunk.streamingChunk),
-            isComplete: String(chunk.isComplete),
-            isSaved: String(chunk.isSaved),
-            transcriptionSource: chunk.transcriptionSource || 'stt'
-        };
-        // SmartTranslate fields (only set if populated)
-        if (chunk.llmTranscription !== undefined)
-            updateHash.llmTranscription = chunk.llmTranscription;
-        if (chunk.llmWords !== undefined)
-            updateHash.llmWords = this.serialize(chunk.llmWords);
-        if (chunk.routeUsed !== undefined)
-            updateHash.routeUsed = chunk.routeUsed;
-        if (chunk.sttHistory !== undefined)
-            updateHash.sttHistory = this.serialize(chunk.sttHistory);
-        p.hset(key, updateHash);
-        p.expire(key, EXPIRATION);
-        await p.exec();
-        return chunk;
-    }
-    async updateFinalTranscription(roomId, n, transcription) {
-        return this.withChunk(roomId, n, (c) => {
-            c.finalTranscription = transcription;
-        });
+        const pipe = this.redisClient.pipeline();
+        pipe.hset(key, { finalTranscription: transcription });
+        pipe.expire(key, EXPIRATION);
+        await pipe.exec();
+        return this.getMulingstreamChunkById(roomId, n);
     }
     /**
      * Update chunk with LLM-sanitized transcription from SmartTranslate.
      * If the sanitized text differs from the original, sets transcriptionSource to 'llm'
      * and updates finalTranscription to the sanitized version.
      * Returns the chunk (caller can compare original vs sanitized to decide on TRANSCRIPTION_CORRECTED).
+     *
+     * IMPORTANT — partial HSET, NOT withChunk(). Reasoning identical to setBufferStatus:
+     * handleTtsService runs in parallel and writes `tts.<lang>.status = READY`. The
+     * read-modify-write of withChunk would clobber that READY back to INIT (we read
+     * tts before TTS callback fires, then write the entire chunk back later). Result:
+     * emitChunk's `if (status !== READY) return;` drops the audio publish, listeners
+     * see text but never get the audio URL.
+     *
+     * This bug surfaced 2026-05-01: same root cause as the earlier setBufferStatus
+     * race; updateLlmTranscription wasn't fixed at the same time so it kept producing
+     * silent audio for any chunk where wasSanitized=true (i.e. every LLM-routed chunk).
      */
     async updateLlmTranscription(roomId, n, opts) {
+        const cid = await this.getChunkId(roomId, n);
+        if (!cid)
+            return { chunk: null, wasChanged: false };
+        const key = this.chunkHashKey(cid);
+        // Read just the fields we need to compute the diff/append, NOT the whole chunk.
+        // We don't need tts/translation/streamingChunk here — they're untouched by this op.
+        const [originalTextRaw, sttHistoryRaw] = await Promise.all([
+            this.redisClient.hget(key, 'finalTranscription'),
+            this.redisClient.hget(key, 'sttHistory')
+        ]);
+        const originalText = originalTextRaw !== null && originalTextRaw !== void 0 ? originalTextRaw : '';
+        const existingSttHistory = sttHistoryRaw ? this.deserialize(sttHistoryRaw) : [];
+        const update = {
+            llmTranscription: opts.llmTranscription,
+            routeUsed: opts.routeUsed
+        };
+        if (opts.llmWords !== undefined)
+            update.llmWords = this.serialize(opts.llmWords);
         let wasChanged = false;
-        const chunk = await this.withChunk(roomId, n, (c) => {
-            const originalText = c.finalTranscription;
-            c.llmTranscription = opts.llmTranscription;
-            c.llmWords = opts.llmWords;
-            c.routeUsed = opts.routeUsed;
-            // If LLM produced a different transcription, update the active text
-            if (opts.routeUsed === 'LLM' && opts.llmTranscription !== originalText) {
-                c.finalTranscription = opts.llmTranscription;
-                c.transcriptionSource = 'llm';
-                wasChanged = true;
-            }
-            // Append to STT history (keep last 3)
-            if (opts.sttHistoryEntry) {
-                if (!c.sttHistory)
-                    c.sttHistory = [];
-                c.sttHistory.push(opts.sttHistoryEntry);
-                if (c.sttHistory.length > 3)
-                    c.sttHistory = c.sttHistory.slice(-3);
-            }
-        });
+        if (opts.routeUsed === 'LLM' && opts.llmTranscription !== originalText) {
+            update.finalTranscription = opts.llmTranscription;
+            update.transcriptionSource = 'llm';
+            wasChanged = true;
+        }
+        if (opts.sttHistoryEntry) {
+            const next = [...existingSttHistory, opts.sttHistoryEntry];
+            if (next.length > 3)
+                next.splice(0, next.length - 3);
+            update.sttHistory = this.serialize(next);
+        }
+        const pipe = this.redisClient.pipeline();
+        pipe.hset(key, update);
+        pipe.expire(key, EXPIRATION);
+        await pipe.exec();
+        // Re-read the full chunk so callers can use the up-to-date object.
+        const chunk = await this.getMulingstreamChunkById(roomId, n);
         return { chunk, wasChanged };
     }
+    /**
+     * Partial HSET — reads only `translation` and `tts` fields, modifies in place,
+     * writes back only those two. See setBufferStatus for the race rationale.
+     */
     async discardLanguage(roomId, n, lang) {
-        return this.withChunk(roomId, n, (c) => {
-            if (c.translation[lang])
-                c.translation[lang].status = 'DISCARDED';
-            if (c.tts[lang])
-                c.tts[lang].status = 'DISCARDED';
-        });
+        var _a, _b;
+        const cid = await this.getChunkId(roomId, n);
+        if (!cid)
+            return null;
+        const key = this.chunkHashKey(cid);
+        const [translationRaw, ttsRaw] = await Promise.all([
+            this.redisClient.hget(key, 'translation'),
+            this.redisClient.hget(key, 'tts')
+        ]);
+        const translation = (_a = this.deserialize(translationRaw !== null && translationRaw !== void 0 ? translationRaw : '')) !== null && _a !== void 0 ? _a : {};
+        const tts = (_b = this.deserialize(ttsRaw !== null && ttsRaw !== void 0 ? ttsRaw : '')) !== null && _b !== void 0 ? _b : {};
+        if (translation[lang])
+            translation[lang].status = 'DISCARDED';
+        if (tts[lang])
+            tts[lang].status = 'DISCARDED';
+        const pipe = this.redisClient.pipeline();
+        pipe.hset(key, { translation: this.serialize(translation), tts: this.serialize(tts) });
+        pipe.expire(key, EXPIRATION);
+        await pipe.exec();
+        return this.getMulingstreamChunkById(roomId, n);
     }
+    /**
+     * Partial HSET — same race-safe pattern as discardLanguage. Only writes the
+     * fields actually mutated by the caller (translation and/or tts).
+     */
     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];
+        var _a, _b, _c, _d;
+        const cid = await this.getChunkId(roomId, n);
+        if (!cid)
+            return null;
+        const key = this.chunkHashKey(cid);
+        const wantTranslation = !!((_a = opt.translation) === null || _a === void 0 ? void 0 : _a.length);
+        const wantTts = !!((_b = opt.tts) === null || _b === void 0 ? void 0 : _b.length);
+        if (!wantTranslation && !wantTts)
+            return this.getMulingstreamChunkById(roomId, n);
+        const [translationRaw, ttsRaw] = await Promise.all([
+            wantTranslation ? this.redisClient.hget(key, 'translation') : Promise.resolve(null),
+            wantTts ? this.redisClient.hget(key, 'tts') : Promise.resolve(null)
+        ]);
+        const update = {};
+        if (wantTranslation) {
+            const translation = (_c = this.deserialize(translationRaw !== null && translationRaw !== void 0 ? translationRaw : '')) !== null && _c !== void 0 ? _c : {};
+            opt.translation.forEach((l) => {
+                const e = 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];
+            update.translation = this.serialize(translation);
+        }
+        if (wantTts) {
+            const tts = (_d = this.deserialize(ttsRaw !== null && ttsRaw !== void 0 ? ttsRaw : '')) !== null && _d !== void 0 ? _d : {};
+            opt.tts.forEach((l) => {
+                const e = tts[l];
                 if (e && e.status === 'INIT')
                     e.status = 'DISCARDED';
             });
-        });
+            update.tts = this.serialize(tts);
+        }
+        const pipe = this.redisClient.pipeline();
+        pipe.hset(key, update);
+        pipe.expire(key, EXPIRATION);
+        await pipe.exec();
+        return this.getMulingstreamChunkById(roomId, n);
     }
+    /**
+     * Partial HSET — only `translation` is read and rewritten. Concurrent updateTts
+     * calls won't be clobbered.
+     */
     async updateTranslation(roomId, n, lang, opt) {
-        return this.withChunk(roomId, n, (c) => {
-            const e = c.translation[lang];
-            if (!e)
-                return;
-            if (opt.translation !== undefined)
-                e.translation = opt.translation;
-            if (opt.status !== undefined)
-                e.status = opt.status;
-        });
+        var _a;
+        const cid = await this.getChunkId(roomId, n);
+        if (!cid)
+            return null;
+        const key = this.chunkHashKey(cid);
+        const translationRaw = await this.redisClient.hget(key, 'translation');
+        const translation = (_a = this.deserialize(translationRaw !== null && translationRaw !== void 0 ? translationRaw : '')) !== null && _a !== void 0 ? _a : {};
+        const e = translation[lang];
+        if (!e)
+            return this.getMulingstreamChunkById(roomId, n);
+        if (opt.translation !== undefined)
+            e.translation = opt.translation;
+        if (opt.status !== undefined)
+            e.status = opt.status;
+        const pipe = this.redisClient.pipeline();
+        pipe.hset(key, { translation: this.serialize(translation) });
+        pipe.expire(key, EXPIRATION);
+        await pipe.exec();
+        return this.getMulingstreamChunkById(roomId, n);
     }
+    /**
+     * Partial HSET — only `translation` is read and rewritten. This is the hot path
+     * that races with handleTtsService's updateTts and was the root cause of the
+     * "audio LISTENER_FEED never arrives" bug fixed 2026-05-01.
+     */
     async updateTranslationInBulk(roomId, n, dict, status = 'READY', hintsPerLanguage) {
-        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;
-                if (hintsPerLanguage && hintsPerLanguage[l]) {
-                    c.translation[l].hints = hintsPerLanguage[l];
-                }
-            });
+        var _a;
+        const cid = await this.getChunkId(roomId, n);
+        if (!cid)
+            return null;
+        const key = this.chunkHashKey(cid);
+        const translationRaw = await this.redisClient.hget(key, 'translation');
+        const translation = (_a = this.deserialize(translationRaw !== null && translationRaw !== void 0 ? translationRaw : '')) !== null && _a !== void 0 ? _a : {};
+        Object.entries(dict).forEach(([l, txt]) => {
+            if (!translation[l])
+                return;
+            translation[l].translation = txt;
+            translation[l].status = status;
+            if (hintsPerLanguage && hintsPerLanguage[l]) {
+                translation[l].hints = hintsPerLanguage[l];
+            }
         });
+        const pipe = this.redisClient.pipeline();
+        pipe.hset(key, { translation: this.serialize(translation) });
+        pipe.expire(key, EXPIRATION);
+        await pipe.exec();
+        return this.getMulingstreamChunkById(roomId, n);
     }
+    /**
+     * Partial HSET — only `tts` is read and rewritten. Same race-rationale as
+     * updateTranslationInBulk: avoids clobbering concurrent translation writes.
+     */
     async updateTts(roomId, n, lang, opt) {
-        return this.withChunk(roomId, n, (c) => {
-            const e = c.tts[lang];
-            if (!e)
-                return;
-            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.duration !== undefined)
-                e.duration = opt.duration;
-        });
+        var _a;
+        const cid = await this.getChunkId(roomId, n);
+        if (!cid)
+            return null;
+        const key = this.chunkHashKey(cid);
+        const ttsRaw = await this.redisClient.hget(key, 'tts');
+        const tts = (_a = this.deserialize(ttsRaw !== null && ttsRaw !== void 0 ? ttsRaw : '')) !== null && _a !== void 0 ? _a : {};
+        const e = tts[lang];
+        if (!e)
+            return this.getMulingstreamChunkById(roomId, n);
+        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.duration !== undefined)
+            e.duration = opt.duration;
+        const pipe = this.redisClient.pipeline();
+        pipe.hset(key, { tts: this.serialize(tts) });
+        pipe.expire(key, EXPIRATION);
+        await pipe.exec();
+        return this.getMulingstreamChunkById(roomId, n);
     }
     /**
      * Update SmartTranslate buffering metadata on a chunk (Section 22).
      * Writes `bufferStatus`, `pendingText`, and `consumedChunkNumbers` so the chunk row
      * persisted at the end of the pipeline reflects whether it was DEFERRED / USED / EMITTED.
+     *
+     * IMPORTANT — this is a partial HSET that touches ONLY the buffering fields.
+     * It deliberately does NOT use `withChunk()` (which rewrites the whole chunk hash)
+     * because handleTtsService can update `tts` concurrently with this call. Using the
+     * read-modify-write pattern of withChunk would race with TTS status updates and
+     * clobber `tts.<lang>.status = READY` back to INIT — preventing the audio sequencer
+     * from emitting the listener feed (audio came through as text-only with audio:"").
      */
     async setBufferStatus(roomId, n, opt) {
-        return this.withChunk(roomId, n, (c) => {
-            if (opt.bufferStatus !== undefined)
-                c.bufferStatus = opt.bufferStatus;
-            if (opt.pendingText !== undefined)
-                c.pendingText = opt.pendingText;
-            if (opt.consumedChunkNumbers !== undefined)
-                c.consumedChunkNumbers = opt.consumedChunkNumbers;
-        });
+        const cid = await this.getChunkId(roomId, n);
+        if (!cid)
+            return null;
+        const key = this.chunkHashKey(cid);
+        const update = {};
+        if (opt.bufferStatus !== undefined)
+            update.bufferStatus = opt.bufferStatus;
+        if (opt.pendingText !== undefined)
+            update.pendingText = opt.pendingText;
+        if (opt.consumedChunkNumbers !== undefined)
+            update.consumedChunkNumbers = this.serialize(opt.consumedChunkNumbers);
+        if (Object.keys(update).length === 0) {
+            // Nothing to write — read-only fetch for callers that still want the chunk back.
+            return this.getMulingstreamChunkById(roomId, n);
+        }
+        const pipe = this.redisClient.pipeline();
+        pipe.hset(key, update);
+        pipe.expire(key, EXPIRATION);
+        await pipe.exec();
+        // Return the freshly-read chunk so callers can persist it (e.g. insertChunk to PG).
+        return this.getMulingstreamChunkById(roomId, n);
     }
     async areTranslationsProcessed(roomId, n) {
         const c = await this.getMulingstreamChunkById(roomId, n);
@@ -371,20 +490,34 @@ class MulingstreamChunkManager {
         return Object.values(c.tts).every((t) => t.status !== 'INIT');
     }
     /**
-     * Mark a chunk as complete (all TTS finished for all target languages)
+     * Mark a chunk as complete (all TTS finished for all target languages).
+     * Partial HSET — touches only `isComplete`.
      */
     async markChunkComplete(roomId, n) {
-        return this.withChunk(roomId, n, (c) => {
-            c.isComplete = true;
-        });
+        const cid = await this.getChunkId(roomId, n);
+        if (!cid)
+            return null;
+        const key = this.chunkHashKey(cid);
+        const pipe = this.redisClient.pipeline();
+        pipe.hset(key, { isComplete: 'true' });
+        pipe.expire(key, EXPIRATION);
+        await pipe.exec();
+        return this.getMulingstreamChunkById(roomId, n);
     }
     /**
-     * Mark a chunk as saved to database
+     * Mark a chunk as saved to database.
+     * Partial HSET — touches only `isSaved`.
      */
     async markChunkSaved(roomId, n) {
-        return this.withChunk(roomId, n, (c) => {
-            c.isSaved = true;
-        });
+        const cid = await this.getChunkId(roomId, n);
+        if (!cid)
+            return null;
+        const key = this.chunkHashKey(cid);
+        const pipe = this.redisClient.pipeline();
+        pipe.hset(key, { isSaved: 'true' });
+        pipe.expire(key, EXPIRATION);
+        await pipe.exec();
+        return this.getMulingstreamChunkById(roomId, n);
     }
     /**
      * Get all complete but unsaved chunks for a room

package/package.json

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