@mulingai-npm/redis 3.40.54 → 3.40.55

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

@@ -89,13 +89,6 @@ export declare class MulingstreamListenerManager {
      * for why that single threshold could not be lowered and had to be split.
      */
     getUniqueLanguagesByRoom(roomId: string): Promise<string[]>;
-    private guestLanguagesKey;
-    /** Record that a guest, not the host, put this language in the room. */
-    markGuestLanguage(roomId: string, language: string): Promise<void>;
-    /** Forget a guest language, once it has been released from the room. */
-    unmarkGuestLanguage(roomId: string, language: string): Promise<void>;
-    /** Every language in this room that a guest added. */
-    getGuestLanguages(roomId: string): Promise<string[]>;
     /**
      * How many PRESENT listeners in this room are on a language.
      *
@@ -140,14 +133,35 @@ export declare class MulingstreamListenerManager {
      *
      * Church passes turn on this number rather than on how many people joined. A
      * pass is spent only when translation reached a human being, so somebody
-     * sitting on the join screen, or with the tab open and audio stopped, must
-     * not burn a church's pass.
-     *
-     * `isListening` is already maintained by setListeningState, so this is the
-     * honest count rather than a proxy for it. Falls back to counting a listener
-     * whose flag has never been written, because the flag arrived after some
-     * clients shipped and an older client that is genuinely playing audio should
-     * still count.
+     * sitting on the join screen must not burn a church's pass.
+     *
+     * ─── RECEIVING MEANS AUDIO **OR** TEXT ──────────────────────────────────
+     *
+     * Corrected 2026-08-19. This used to require `isListening`, the audio
+     * playback flag, so a guest who joined, chose their language and sat reading
+     * the translated text counted for nothing: the pass clock stayed at zero
+     * until they pressed Listening. David found it on a phone, and the counting
+     * spec had said otherwise all along, in as many words: "the listener session
+     * is open AND we are delivering translated output to it, audio or text".
+     *
+     * The reading is the product. A deaf guest, a guest in a quiet room, a guest
+     * with no headphones and a guest who simply prefers to read are all being
+     * served, all costing us translation on every chunk, and none of them are
+     * pressing an audio button. Charging only for audio would have meant a
+     * church whose congregation reads never spends a pass, which sounds generous
+     * until you notice we are paying for every word of it.
+     *
+     * So the test is PRESENCE, and nothing else. Presence already means joined,
+     * in a language, and with a heartbeat inside the last ninety seconds, which
+     * is exactly the population `consumersFor` is translating for. Whether they
+     * also chose to hear it is not our business, and the spec is explicit that we
+     * do not police attention: a phone in a pocket with audio playing is
+     * listening, and a phone in a hand with text on it is reading.
+     *
+     * `isListening` keeps its real job, which is a different question: whether to
+     * SYNTHESISE SPEECH. See getLanguagesWithActiveListeners. Speech is the most
+     * expensive thing we produce and nobody should pay to generate audio no one
+     * is playing. Text is already produced for the room either way.
      */
     getReceivingCount(roomId: string): Promise<number>;
     private capKey;

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

@@ -263,48 +263,6 @@ class MulingstreamListenerManager {
         // 4) Map back to just the language strings in order
         return sortedEntries.map(([language]) => language);
     }
-    /*
-     * GUEST ADDED LANGUAGES
-     *
-     * Which of a room's target languages a guest put there, as opposed to the
-     * host. The distinction is the whole reason this exists: a guest-added
-     * language is released the moment nobody is on it, and the host's own
-     * language never is, however empty the room gets. Without the distinction a
-     * church that pinned Danish and had every guest wander off would find its room
-     * translating nothing.
-     *
-     * It also stops a single guest eating the room. Changing language seven times
-     * would otherwise leave seven languages standing, every one of them translated
-     * and synthesised for the rest of the service on a counted pass, and no slot
-     * left for the person who actually needed one.
-     *
-     * A set rather than a column: it is per-session bookkeeping, not a property of
-     * the room, and it should disappear on its own if a process dies mid-service.
-     * The TTL is the listener expiry for exactly that reason.
-     */
-    guestLanguagesKey(roomId) {
-        return `room:${roomId}:guest-languages`;
-    }
-    /** Record that a guest, not the host, put this language in the room. */
-    async markGuestLanguage(roomId, language) {
-        if (!roomId || !language)
-            return;
-        const key = this.guestLanguagesKey(roomId);
-        await this.redisClient.sadd(key, language);
-        await this.redisClient.expire(key, EXPIRATION);
-    }
-    /** Forget a guest language, once it has been released from the room. */
-    async unmarkGuestLanguage(roomId, language) {
-        if (!roomId || !language)
-            return;
-        await this.redisClient.srem(this.guestLanguagesKey(roomId), language);
-    }
-    /** Every language in this room that a guest added. */
-    async getGuestLanguages(roomId) {
-        if (!roomId)
-            return [];
-        return (await this.redisClient.smembers(this.guestLanguagesKey(roomId))) || [];
-    }
     /**
      * How many PRESENT listeners in this room are on a language.
      *
@@ -396,25 +354,40 @@ class MulingstreamListenerManager {
      *
      * Church passes turn on this number rather than on how many people joined. A
      * pass is spent only when translation reached a human being, so somebody
-     * sitting on the join screen, or with the tab open and audio stopped, must
-     * not burn a church's pass.
+     * sitting on the join screen must not burn a church's pass.
+     *
+     * ─── RECEIVING MEANS AUDIO **OR** TEXT ──────────────────────────────────
+     *
+     * Corrected 2026-08-19. This used to require `isListening`, the audio
+     * playback flag, so a guest who joined, chose their language and sat reading
+     * the translated text counted for nothing: the pass clock stayed at zero
+     * until they pressed Listening. David found it on a phone, and the counting
+     * spec had said otherwise all along, in as many words: "the listener session
+     * is open AND we are delivering translated output to it, audio or text".
+     *
+     * The reading is the product. A deaf guest, a guest in a quiet room, a guest
+     * with no headphones and a guest who simply prefers to read are all being
+     * served, all costing us translation on every chunk, and none of them are
+     * pressing an audio button. Charging only for audio would have meant a
+     * church whose congregation reads never spends a pass, which sounds generous
+     * until you notice we are paying for every word of it.
+     *
+     * So the test is PRESENCE, and nothing else. Presence already means joined,
+     * in a language, and with a heartbeat inside the last ninety seconds, which
+     * is exactly the population `consumersFor` is translating for. Whether they
+     * also chose to hear it is not our business, and the spec is explicit that we
+     * do not police attention: a phone in a pocket with audio playing is
+     * listening, and a phone in a hand with text on it is reading.
      *
-     * `isListening` is already maintained by setListeningState, so this is the
-     * honest count rather than a proxy for it. Falls back to counting a listener
-     * whose flag has never been written, because the flag arrived after some
-     * clients shipped and an older client that is genuinely playing audio should
-     * still count.
+     * `isListening` keeps its real job, which is a different question: whether to
+     * SYNTHESISE SPEECH. See getLanguagesWithActiveListeners. Speech is the most
+     * expensive thing we produce and nobody should pay to generate audio no one
+     * is playing. Text is already produced for the room either way.
      */
     async getReceivingCount(roomId) {
         const now = Date.now();
         const listeners = await this.getListenersByRoom(roomId);
-        return listeners.filter(
-        // Present AND playing audio. Presence is the half that was missing:
-        // a listener who closed their phone kept the isListening flag they had
-        // when they left, so they went on being counted as receiving until the
-        // sweep removed them, and went on pushing a church's pass toward being
-        // spent. Nobody ever pauses audio on the way out of a building.
-        (l) => (0, listener_presence_1.isListenerPresent)(l.lastHeartbeat, l.isAway === true, now) && l.isListening !== false).length;
+        return listeners.filter((l) => (0, listener_presence_1.isListenerPresent)(l.lastHeartbeat, l.isAway === true, now)).length;
     }
     // ─── Per-room listener capacity (design B, 2026-07-09) ────────────────────
     // The cap value is the room owner's plan `max_audience`, resolved ONCE by the

package/package.json

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