@mulingai-npm/redis 3.40.40 → 3.40.43

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

@@ -181,8 +181,21 @@ export declare class MulingstreamChunkManager {
      */
     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.
+     * Atomic per-language merge into the serialized `tts` hash field.
+     *
+     * The `tts` field is ONE JSON blob holding every target language's TTS state. A naive
+     * hget -> modify -> hset (the previous implementation) races with concurrent updateTts calls
+     * for OTHER languages on the SAME chunk: with fast TTS (ElevenLabs Flash ~150ms) all target
+     * languages of a chunk finish within a few ms of each other, so two handlers read the same
+     * snapshot and the second hset clobbers the first language's freshly-written READY back to its
+     * old value (INIT). The sequencer then reads INIT and drops the audio
+     * ('[audio-drop] reason=not-ready'), leaving the listener with text but no audio even though
+     * TTS succeeded — the faster the provider, the tighter the window and the more clips are lost.
+     *
+     * Running the read-modify-write inside a Lua script makes it atomic (Redis executes a script to
+     * completion single-threaded), so sibling-language writes can no longer interleave. WATCH/MULTI
+     * is NOT usable here: RedisClient shares a single ioredis connection across all callers, and
+     * concurrent commands on that connection would break optimistic-lock semantics.
      */
     updateTts(roomId: string, n: number, lang: string, opt: {
         ttsAudioPath?: string;

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

@@ -4,6 +4,27 @@ exports.MulingstreamChunkManager = void 0;
 const uuid_1 = require("uuid");
 const EXPIRATION = 12 * 60 * 60;
 const ROOM_ARRAY_LENGTH = 50;
+/**
+ * Atomic merge of a partial update into one language's entry inside the serialized `tts` JSON
+ * hash field. Runs entirely inside Redis so concurrent per-language writes to the same chunk can
+ * never clobber each other (see MulingstreamChunkManager.updateTts for the race this prevents).
+ *   KEYS[1] = chunk hash key
+ *   ARGV[1] = language code           ARGV[2] = JSON of the partial patch     ARGV[3] = expiry seconds
+ * Returns 1 on merge, -1 if the language entry is absent (no-op), 0 if there is no tts field yet.
+ */
+const TTS_MERGE_LUA = `
+local raw = redis.call('HGET', KEYS[1], 'tts')
+if not raw or raw == '' then return 0 end
+local ok, tts = pcall(cjson.decode, raw)
+if not ok or type(tts) ~= 'table' then return 0 end
+local entry = tts[ARGV[1]]
+if entry == nil then return -1 end
+local patch = cjson.decode(ARGV[2])
+for k, v in pairs(patch) do entry[k] = v end
+redis.call('HSET', KEYS[1], 'tts', cjson.encode(tts))
+redis.call('EXPIRE', KEYS[1], tonumber(ARGV[3]))
+return 1
+`;
 class MulingstreamChunkManager {
     constructor(redisClient) {
         this.redisClient = redisClient;
@@ -413,32 +434,38 @@ class MulingstreamChunkManager {
         return this.getMulingstreamChunkById(roomId, n);
     }
     /**
-     * Partial HSET — only `tts` is read and rewritten. Same race-rationale as
-     * updateTranslationInBulk: avoids clobbering concurrent translation writes.
+     * Atomic per-language merge into the serialized `tts` hash field.
+     *
+     * The `tts` field is ONE JSON blob holding every target language's TTS state. A naive
+     * hget -> modify -> hset (the previous implementation) races with concurrent updateTts calls
+     * for OTHER languages on the SAME chunk: with fast TTS (ElevenLabs Flash ~150ms) all target
+     * languages of a chunk finish within a few ms of each other, so two handlers read the same
+     * snapshot and the second hset clobbers the first language's freshly-written READY back to its
+     * old value (INIT). The sequencer then reads INIT and drops the audio
+     * ('[audio-drop] reason=not-ready'), leaving the listener with text but no audio even though
+     * TTS succeeded — the faster the provider, the tighter the window and the more clips are lost.
+     *
+     * Running the read-modify-write inside a Lua script makes it atomic (Redis executes a script to
+     * completion single-threaded), so sibling-language writes can no longer interleave. WATCH/MULTI
+     * is NOT usable here: RedisClient shares a single ioredis connection across all callers, and
+     * concurrent commands on that connection would break optimistic-lock semantics.
      */
     async updateTts(roomId, n, lang, opt) {
-        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);
+        // Only the explicitly-provided fields are merged; absent fields are left untouched.
+        const patch = {};
         if (opt.ttsAudioPath !== undefined)
-            e.ttsAudioPath = opt.ttsAudioPath;
+            patch.ttsAudioPath = opt.ttsAudioPath;
         if (opt.status !== undefined)
-            e.status = opt.status;
+            patch.status = opt.status;
         if (opt.isEmitted !== undefined)
-            e.isEmitted = opt.isEmitted;
+            patch.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();
+            patch.duration = opt.duration;
+        await this.redisClient.eval(TTS_MERGE_LUA, [key], [lang, JSON.stringify(patch), EXPIRATION]);
         return this.getMulingstreamChunkById(roomId, n);
     }
     /**

package/dist/redis-client.d.ts

@@ -44,6 +44,13 @@ export declare class RedisClient {
     lrange(key: string, start: number, stop: number): Promise<string[]>;
     ltrim(key: string, start: number, stop: number): Promise<string>;
     pipeline(): ReturnType<IORedis['pipeline']>;
+    /**
+     * Run a Lua script atomically (Redis executes each script to completion single-threaded, so a
+     * read-modify-write inside one script cannot be interleaved by another writer). Used for
+     * lost-update-safe merges into serialized JSON hash fields — see MulingstreamChunkManager.updateTts.
+     * Args are stringified because every Redis command argument is a bulk string; use tonumber() in Lua.
+     */
+    eval(script: string, keys: string[], args: (string | number)[]): Promise<unknown>;
     unlink(...keys: string[]): Promise<number>;
     jsonSet<T>(key: string, path: string, value: T): Promise<string>;
     jsonGet<T>(key: string, path: string): Promise<T | null>;

package/dist/redis-client.js

@@ -126,6 +126,15 @@ class RedisClient {
     pipeline() {
         return this.client.pipeline();
     }
+    /**
+     * Run a Lua script atomically (Redis executes each script to completion single-threaded, so a
+     * read-modify-write inside one script cannot be interleaved by another writer). Used for
+     * lost-update-safe merges into serialized JSON hash fields — see MulingstreamChunkManager.updateTts.
+     * Args are stringified because every Redis command argument is a bulk string; use tonumber() in Lua.
+     */
+    async eval(script, keys, args) {
+        return this.client.call('EVAL', script, String(keys.length), ...keys, ...args.map(String));
+    }
     async unlink(...keys) {
         // unlink exists on Redis ≥4 and is supported by ioredis but not typed in
         // older versions – we cast to any.

package/package.json

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