@mulingai-npm/redis 3.40.44 → 3.40.46

package/dist/managers/aggregated-content-manager.d.ts

@@ -1,4 +1,5 @@
 import { RedisClient } from '../redis-client';
+import type { CacheVersionResolver } from './page-content-manager';
 export interface CachedAggregatedContent {
     id: string;
     locale: string;
@@ -10,8 +11,11 @@ export interface CachedAggregatedContent {
 }
 export declare class AggregatedContentManager {
     private redis;
+    private resolveVersion?;
     private static DEFAULT_TTL;
-    constructor(redis: RedisClient);
+    constructor(redis: RedisClient, resolveVersion?: CacheVersionResolver);
+    /** `v<version>--`, or empty when no resolver was supplied. See PageContentManager. */
+    private versionSegment;
     private key;
     private build;
     private scan;

package/dist/managers/aggregated-content-manager.js

@@ -2,11 +2,18 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AggregatedContentManager = void 0;
 class AggregatedContentManager {
-    constructor(redis) {
+    constructor(redis, resolveVersion) {
         this.redis = redis;
+        this.resolveVersion = resolveVersion;
+    }
+    /** `v<version>--`, or empty when no resolver was supplied. See PageContentManager. */
+    versionSegment() {
+        var _a;
+        const version = (_a = this.resolveVersion) === null || _a === void 0 ? void 0 : _a.call(this);
+        return version ? `v${version}--` : '';
     }
     key(locale, domain) {
-        return `aggregated-content--[${locale.toLowerCase()}]-[${domain.toLowerCase()}]`;
+        return `aggregated-content--${this.versionSegment()}[${locale.toLowerCase()}]-[${domain.toLowerCase()}]`;
     }
     build(locale, domain, payload) {
         const id = this.key(locale, domain);
@@ -41,7 +48,7 @@ class AggregatedContentManager {
         return raw ? JSON.parse(raw) : null;
     }
     async getAllAggregatedContents() {
-        const keys = await this.scan('aggregated-content--[*');
+        const keys = await this.scan('aggregated-content--*[');
         if (!keys.length)
             return [];
         const p = this.redis.pipeline();
@@ -53,7 +60,7 @@ class AggregatedContentManager {
         await this.redis.unlink(this.key(locale, domain));
     }
     async clearAllAggregatedContents() {
-        const keys = await this.scan('aggregated-content--[*');
+        const keys = await this.scan('aggregated-content--*[');
         if (keys.length)
             await this.redis.unlink(...keys);
     }

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

@@ -36,6 +36,21 @@ export declare class MulingstreamListenerManager {
         totalListeners: number;
         languageBreakdown: Record<string, number>;
     }>;
+    /**
+     * How many people in this room are ACTUALLY RECEIVING translation right now.
+     *
+     * 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.
+     */
+    getReceivingCount(roomId: string): Promise<number>;
     private capKey;
     /**
      * Cache the room's listener cap. Called by the speaker service at go-live and

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

@@ -239,6 +239,24 @@ class MulingstreamListenerManager {
             languageBreakdown
         };
     }
+    /**
+     * How many people in this room are ACTUALLY RECEIVING translation right now.
+     *
+     * 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.
+     */
+    async getReceivingCount(roomId) {
+        const listeners = await this.getListenersByRoom(roomId);
+        return listeners.filter((l) => l.isListening !== false).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
     // speaker service when it goes live (it already fetches the plan entitlements)

package/dist/managers/page-content-manager.d.ts

@@ -10,10 +10,28 @@ export interface CachedPageContent {
     lastUsedAt: number | null;
     totalUsage: number;
 }
+/**
+ * Returns the namespace the cache should currently write under. Called per
+ * operation rather than captured once, so a caller can change it at runtime
+ * (local development, where content is edited under a running process).
+ */
+export type CacheVersionResolver = () => string;
 export declare class PageContentManager {
     private redis;
+    private resolveVersion?;
     private static DEFAULT_TTL;
-    constructor(redis: RedisClient);
+    /**
+     * `resolveVersion` namespaces every key by the content it was built from.
+     * Content ships inside the service image, so nothing else invalidates this
+     * cache on deploy: without the namespace a new build keeps serving the
+     * previous build's content until the 30-day TTL expires.
+     *
+     * Omit it and keys keep their original un-namespaced shape, so an existing
+     * deployment behaves exactly as before.
+     */
+    constructor(redis: RedisClient, resolveVersion?: CacheVersionResolver);
+    /** `v<version>--`, or empty when no resolver was supplied. */
+    private versionSegment;
     private key;
     private build;
     private scan;

package/dist/managers/page-content-manager.js

@@ -2,11 +2,27 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PageContentManager = void 0;
 class PageContentManager {
-    constructor(redis) {
+    /**
+     * `resolveVersion` namespaces every key by the content it was built from.
+     * Content ships inside the service image, so nothing else invalidates this
+     * cache on deploy: without the namespace a new build keeps serving the
+     * previous build's content until the 30-day TTL expires.
+     *
+     * Omit it and keys keep their original un-namespaced shape, so an existing
+     * deployment behaves exactly as before.
+     */
+    constructor(redis, resolveVersion) {
         this.redis = redis;
+        this.resolveVersion = resolveVersion;
+    }
+    /** `v<version>--`, or empty when no resolver was supplied. */
+    versionSegment() {
+        var _a;
+        const version = (_a = this.resolveVersion) === null || _a === void 0 ? void 0 : _a.call(this);
+        return version ? `v${version}--` : '';
     }
     key(locale, route, domain) {
-        return `page-content--[${locale.toLowerCase()}]-[${route.toLowerCase()}]-[${domain.toLowerCase()}]`;
+        return `page-content--${this.versionSegment()}[${locale.toLowerCase()}]-[${route.toLowerCase()}]-[${domain.toLowerCase()}]`;
     }
     build(locale, route, domain, payload) {
         const id = this.key(locale, route, domain);
@@ -43,7 +59,7 @@ class PageContentManager {
         return raw ? JSON.parse(raw) : null;
     }
     async getAllPageContents() {
-        const keys = await this.scan('page-content--[*');
+        const keys = await this.scan('page-content--*[');
         if (!keys.length)
             return [];
         const p = this.redis.pipeline();
@@ -52,7 +68,7 @@ class PageContentManager {
         return res.flatMap(([_, v]) => (v ? [JSON.parse(v)] : []));
     }
     async getAllPageContentsByLocale(locale) {
-        const keys = await this.scan(`page-content--[${locale.toLowerCase()}]-[*`);
+        const keys = await this.scan(`page-content--*[${locale.toLowerCase()}]-[*`);
         if (!keys.length)
             return [];
         const p = this.redis.pipeline();
@@ -64,12 +80,12 @@ class PageContentManager {
         await this.redis.unlink(this.key(locale, route, domain));
     }
     async clearAllPageContents() {
-        const keys = await this.scan('page-content--[*');
+        const keys = await this.scan('page-content--*[');
         if (keys.length)
             await this.redis.unlink(...keys);
     }
     async clearAllPageContentsByLocale(locale) {
-        const keys = await this.scan(`page-content--[${locale.toLowerCase()}]-[*`);
+        const keys = await this.scan(`page-content--*[${locale.toLowerCase()}]-[*`);
         if (keys.length)
             await this.redis.unlink(...keys);
     }

package/package.json

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