@resolveio/server-lib 22.2.34 → 22.2.36

package/managers/subscription.manager.js

@@ -0,0 +1,3422 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SubscriptionManager = void 0;
+var NodeCache = require("node-cache");
+var msgpackr_1 = require("msgpackr");
+var WebSocket = require("ws");
+var flag_collection_1 = require("../collections/flag.collection");
+var logged_in_users_collection_1 = require("../collections/logged-in-users.collection");
+var app_status_1 = require("../publications/app-status");
+var app_settings_1 = require("../publications/app-settings");
+var ai_terminal_1 = require("../publications/ai-terminal");
+var cron_jobs_1 = require("../publications/cron-jobs");
+var customer_notifications_1 = require("../publications/customer-notifications");
+var files_1 = require("../publications/files");
+var flags_1 = require("../publications/flags");
+var flags_update_1 = require("../publications/flags-update");
+var logs_1 = require("../publications/logs");
+var notifications_1 = require("../publications/notifications");
+var report_builder_dashboard_builders_1 = require("../publications/report-builder-dashboard-builders");
+var report_builder_libraries_1 = require("../publications/report-builder-libraries");
+var report_builder_reports_1 = require("../publications/report-builder-reports");
+var super_admin_1 = require("../publications/super-admin");
+var user_groups_1 = require("../publications/user-groups");
+var user_guides_1 = require("../publications/user-guides");
+var resolveio_server_app_1 = require("../resolveio-server-app");
+var common_1 = require("../util/common");
+var error_reporter_1 = require("../util/error-reporter");
+var error_tracking_1 = require("../util/error-tracking");
+var subscription_dependency_context_1 = require("../util/subscription-dependency-context");
+var v8 = require('v8');
+var sift = require('sift');
+function resolveHeapLimitBytes() {
+    var stats = v8.getHeapStatistics();
+    if (stats && typeof stats.heap_size_limit === 'number') {
+        return stats.heap_size_limit;
+    }
+    if (stats && typeof stats.total_available_size === 'number') {
+        return stats.total_available_size;
+    }
+    return 0;
+}
+// interface CurrentPerformanceMonitor {
+// 	_id: number;
+// 	function: string;
+// 	publication: string;
+// 	subscriptionData: any[];
+// 	date_start: Date;
+// 	date_end: Date;
+// 	duration: number;
+// 	result: string;
+// }
+var SubscriptionManager = /** @class */ (function () {
+    function SubscriptionManager() {
+        this._publications = {};
+        this._subscriptions = [];
+        this._loggedInUsers = [];
+        this._lastRouteBySocket = new Map();
+        this._mongoQueue = [];
+        this._mongoQueueId = 0;
+        this._oplogMode = 'auto';
+        this._useLocalOplog = false;
+        this._localOplogResyncIntervalMs = 0;
+        this._localOplogResyncTimer = null;
+        this._cacheId = 1;
+        this._heapSize = resolveHeapLimitBytes();
+        this._enableDebug = false;
+        this._enableDependencyDebug = false;
+        this._connectDebug = false;
+        this._debugOplogCollections = [];
+        this._debugOplogHits = 0;
+        this._debugSubCollections = [];
+        this._debugSubHits = 0;
+        this._debugUnSubHits = 0;
+        this._debugUnSubAllHits = 0;
+        this._debugMongoQueueHits = 0;
+        this._debugMongoQueueCollections = [];
+        this._debugSendQueueHits = 0;
+        this._debugRemoveCacheHits = 0;
+        this._subSendDebug = false;
+        this._subSendLogEnabled = false;
+        this._subSendLogThresholdMs = 0;
+        this._subSendLogBytes = 0;
+        this._subSendLogSampleRate = 1;
+        this._aiWorkerDebug = false;
+        this._aiSubscriptionDebug = false;
+        this._aiSubLastAt = new Map();
+        this._oplogRetryCount = 0;
+        this._lastResumeToken = null;
+        this._lastResumeTokenSaveMs = 0;
+        this._resumeTokenSavePromise = null;
+        this._resumeTokenSaveForcePending = false;
+        this._fullResyncPromise = null;
+        this.RESUME_TOKEN_COLLECTION = 'subscription-manager-resume-tokens';
+        this.RESUME_TOKEN_SAVE_INTERVAL_MS = 5000;
+        this.RESUME_TOKEN_AUTO_HEAL_RETRY_THRESHOLD = 2;
+        // Buffer to store throttled latency updates with timestamps
+        this.latencyBuffer = new Map();
+        this._latencyFlushInProgress = false;
+        this._latencyFlushPending = false;
+        // Interval to flush latency updates in MongoDB
+        this.LATENCY_UPDATE_INTERVAL = 60000;
+        // Minimum time difference between two latency updates for the same user
+        this.LATENCY_UPDATE_THRESHOLD_MS = 30000;
+        this.LATENCY_DEBUG_THRESHOLD_MS = 1000;
+        this.PUBLICATION_DEBUG_THRESHOLD_MS = 300;
+        // private currentPerfomanceMonitor: CurrentPerformanceMonitor[] = [];
+        // private idPerformance: number = 0;
+        // private performanceThread;
+        this._invalidationDebounceTimers = new Map();
+        this._invalidationPendingTimestamps = new Map();
+        this._pendingInvalidations = new Map();
+        this.DEBOUNCE_DELAY = 100; // 100ms debounce window
+        this.MAX_WAIT_TIME = 500; // 500ms maximum delay
+        this._publicationWorkerQueueLimit = 0;
+    }
+    SubscriptionManager.createPublicationRegistry = function (serverConfig) {
+        var subscriptionManager = new SubscriptionManager();
+        subscriptionManager.initializePublicationRegistry(serverConfig);
+        return subscriptionManager;
+    };
+    SubscriptionManager.create = function (wss, serverConfig, monitorManagerFunction) {
+        var _this = this;
+        var subscriptionManager = new SubscriptionManager();
+        setImmediate(function () { return __awaiter(_this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, subscriptionManager.initialize(wss, serverConfig, monitorManagerFunction)];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        return subscriptionManager;
+    };
+    SubscriptionManager.prototype.initializePublicationRegistry = function (serverConfig) {
+        this.serverConfig = serverConfig || resolveio_server_app_1.ResolveIOServer.getServerConfig();
+        this.registerCorePublications();
+    };
+    SubscriptionManager.prototype.initialize = function (wss, serverConfig, monitorManagerFunction) {
+        return __awaiter(this, void 0, void 0, function () {
+            var resumeToken, flag, dependencyFlag;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        this._websocketManager = resolveio_server_app_1.ResolveIOServer.getMainServer().getWebSocketManager();
+                        this._monitorManagerFunction = monitorManagerFunction;
+                        this._nodeCache = new NodeCache({ stdTTL: 0, checkperiod: 0 });
+                        setInterval(function () { return _this.flushThrottledLatencyUpdates(); }, this.LATENCY_UPDATE_INTERVAL);
+                        // setTimeout(() => {
+                        // 	console.log('Setting up performance thread');
+                        // 	this.performanceThread = new Worker(path.join(__dirname, './subscription.performance.js'));
+                        // 	this.performanceThread.on('exit', code => {
+                        // 		console.error(new Date(), 'THREAD EXITED!!!!!!!!!!!!!!!!!!', code);
+                        // 	});
+                        // 	this.performanceThread.on('error', code => {
+                        // 		console.error(new Date(), 'THREAD RECV ERROR !!!!!!!!!!!!!!!!!!', code);
+                        // 	});
+                        // }, 5000);
+                        // setInterval(() => {
+                        // 	console.log('Post thread msg');
+                        // 	this.performanceThread.postMessage(this.currentPerfomanceMonitor);
+                        // 	this.currentPerfomanceMonitor = [];
+                        // }, 10000);
+                        this.serverConfig = serverConfig;
+                        this._wss = wss;
+                        this._connectDebug = this.resolveConnectDebug();
+                        this._subSendDebug = this.resolveSubSendDebug();
+                        this._subSendLogEnabled = this.resolveSubSendLogEnabled();
+                        this._subSendLogThresholdMs = this.resolveSubSendLogThresholdMs();
+                        this._subSendLogBytes = this.resolveSubSendLogBytes();
+                        this._subSendLogSampleRate = this.resolveSubSendLogSampleRate();
+                        this._aiWorkerDebug = this.parseDebugFlag(process.env.AI_ASSISTANT_WORKER_DEBUG);
+                        this._aiSubscriptionDebug = this.resolveAiSubscriptionDebug();
+                        this._oplogMode = this.resolveOplogMode();
+                        this._localOplogResyncIntervalMs = this.resolveLocalOplogResyncIntervalMs();
+                        this.registerCorePublications();
+                        if (!(this._oplogMode === 'local')) return [3 /*break*/, 2];
+                        return [4 /*yield*/, this.enableLocalOplogFallback('config')];
+                    case 1:
+                        _a.sent();
+                        return [3 /*break*/, 5];
+                    case 2: return [4 /*yield*/, this.loadResumeToken()];
+                    case 3:
+                        resumeToken = _a.sent();
+                        return [4 /*yield*/, this.tailOpLog(resumeToken || undefined)];
+                    case 4:
+                        _a.sent();
+                        _a.label = 5;
+                    case 5:
+                        setInterval(function () {
+                            _this._oplogRetryCount = 0;
+                        }, 15000);
+                        setInterval(function () {
+                            if (_this.getEnableDebug()) {
+                                console.log(new Date(), 'Sub Manager', 'Subs', _this._subscriptions.length);
+                                console.log(new Date(), 'Sub Manager', 'Logged In Users', _this._loggedInUsers.length);
+                                console.log(new Date(), 'Sub Manager', 'Mongo Queue', _this._mongoQueue.length);
+                                console.log(new Date(), 'Sub Manager', 'Mongo Queue Hits', _this._debugMongoQueueHits);
+                                console.log(new Date(), 'Sub Manager', 'Mongo Queue Collections', JSON.stringify(_this._debugMongoQueueCollections.sort(function (a, b) { return a.collection.localeCompare(b.collection) || a.publication.localeCompare(b.publication); }), null, 2));
+                                console.log(new Date(), 'Sub Manager', 'Oplog Hits', _this._debugOplogHits);
+                                console.log(new Date(), 'Sub Manager', 'Oplog Collections', JSON.stringify(_this._debugOplogCollections.sort(function (a, b) { return a.collection.localeCompare(b.collection) || a.type.localeCompare(b.type); }), null, 2));
+                                console.log(new Date(), 'Sub Manager', 'Send Queue Hits', _this._debugSendQueueHits);
+                                console.log(new Date(), 'Sub Manager', 'Sub Hits', _this._debugSubHits);
+                                console.log(new Date(), 'Sub Manager', 'Sub Collections', JSON.stringify(_this._debugSubCollections.sort(function (a, b) { return a.publication.localeCompare(b.publication); }), null, 2));
+                                console.log(new Date(), 'Sub Manager', 'Unsub Hits', _this._debugUnSubHits);
+                                console.log(new Date(), 'Sub Manager', 'Unsub All Hits', _this._debugUnSubAllHits);
+                                console.log(new Date(), 'Sub Manager', 'Cache Cleanup Hits', _this._debugRemoveCacheHits);
+                            }
+                            _this._debugOplogHits = 0;
+                            _this._debugOplogCollections = [];
+                            _this._debugSubCollections = [];
+                            _this._debugMongoQueueHits = 0;
+                            _this._debugMongoQueueCollections = [];
+                            _this._debugSendQueueHits = 0;
+                            _this._debugSubHits = 0;
+                            _this._debugUnSubHits = 0;
+                            _this._debugUnSubAllHits = 0;
+                            _this._debugRemoveCacheHits = 0;
+                        }, 60000);
+                        setInterval(function () { return __awaiter(_this, void 0, void 0, function () {
+                            var _a, userCopy, _loop_1, this_1, i, i, sub, _loop_2, this_2, j;
+                            return __generator(this, function (_b) {
+                                switch (_b.label) {
+                                    case 0:
+                                        _a = this;
+                                        return [4 /*yield*/, logged_in_users_collection_1.LoggedInUsers.find()];
+                                    case 1:
+                                        _a._loggedInUsers = _b.sent();
+                                        userCopy = (0, common_1.deepCopy)(this._loggedInUsers);
+                                        _loop_1 = function (i) {
+                                            var loggedInUser;
+                                            return __generator(this, function (_c) {
+                                                switch (_c.label) {
+                                                    case 0:
+                                                        loggedInUser = userCopy[i];
+                                                        if (!(!loggedInUser.date || Date.now() - loggedInUser.date.getTime() > 120000)) return [3 /*break*/, 4];
+                                                        if (!this_1._websocketManager.getWebSocket(loggedInUser.id_ws)) return [3 /*break*/, 2];
+                                                        if (this_1.getEnableDebug()) {
+                                                            console.log(new Date(), 'Sub Manager', 'Unsub WS', this_1._websocketManager.getWebSocket(loggedInUser.id_ws)['user'], this_1._websocketManager.getWebSocket(loggedInUser.id_ws)['id_socket'], 2);
+                                                        }
+                                                        return [4 /*yield*/, this_1.unsubscribeAll(this_1._websocketManager.getWebSocket(loggedInUser.id_ws))];
+                                                    case 1:
+                                                        _c.sent();
+                                                        return [3 /*break*/, 4];
+                                                    case 2:
+                                                        this_1._subscriptions.forEach(function (sub) {
+                                                            for (var j = sub.clients.length - 1; j >= 0; j--) {
+                                                                var client = sub.clients[j];
+                                                                if (client.id_socket === loggedInUser.id_ws) {
+                                                                    sub.clients.splice(j, 1);
+                                                                }
+                                                            }
+                                                        });
+                                                        return [4 /*yield*/, logged_in_users_collection_1.LoggedInUsers.deleteOne({ _id: loggedInUser._id })];
+                                                    case 3:
+                                                        _c.sent();
+                                                        if (this_1._loggedInUsers.findIndex(function (a) { return a._id === loggedInUser._id; }) >= 0) {
+                                                            this_1._loggedInUsers.splice(this_1._loggedInUsers.findIndex(function (a) { return a._id === loggedInUser._id; }), 1);
+                                                        }
+                                                        _c.label = 4;
+                                                    case 4: return [2 /*return*/];
+                                                }
+                                            });
+                                        };
+                                        this_1 = this;
+                                        i = this._loggedInUsers.length - 1;
+                                        _b.label = 2;
+                                    case 2:
+                                        if (!(i >= 0)) return [3 /*break*/, 5];
+                                        return [5 /*yield**/, _loop_1(i)];
+                                    case 3:
+                                        _b.sent();
+                                        _b.label = 4;
+                                    case 4:
+                                        i--;
+                                        return [3 /*break*/, 2];
+                                    case 5:
+                                        for (i = 0; i < this._subscriptions.length; i++) {
+                                            sub = this._subscriptions[i];
+                                            _loop_2 = function (j) {
+                                                var client = sub.clients[j];
+                                                if (!this_2._loggedInUsers.some(function (a) { return a.id_ws === client.id_socket; })) {
+                                                    sub.clients.splice(j, 1);
+                                                }
+                                            };
+                                            this_2 = this;
+                                            for (j = sub.clients.length - 1; j >= 0; j--) {
+                                                _loop_2(j);
+                                            }
+                                        }
+                                        return [2 /*return*/];
+                                }
+                            });
+                        }); }, 30000);
+                        return [4 /*yield*/, flag_collection_1.Flags.findOne({ type: 'Enable Debug' })];
+                    case 6:
+                        flag = _a.sent();
+                        return [4 /*yield*/, flag_collection_1.Flags.findOne({ type: 'Enable Dependency Debug' })];
+                    case 7:
+                        dependencyFlag = _a.sent();
+                        if (flag && flag.value) {
+                            this._enableDebug = true;
+                        }
+                        else {
+                            this._enableDebug = false;
+                        }
+                        if (dependencyFlag && dependencyFlag.value) {
+                            this._enableDependencyDebug = true;
+                        }
+                        else {
+                            this._enableDependencyDebug = process.env.ENABLE_DEPENDENCY_DEBUG === 'true';
+                        }
+                        this.setCacheLimit();
+                        this.configurePublicationWorkers();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    SubscriptionManager.prototype.registerCorePublications = function () {
+        (0, super_admin_1.loadSuperAdminPublications)(this);
+        (0, ai_terminal_1.loadAiTerminalPublications)(this);
+        (0, app_status_1.loadAppStatusPublications)(this);
+        (0, app_settings_1.loadAppSettingsPublications)(this);
+        (0, logs_1.loadLogPublications)(this);
+        (0, files_1.loadFilePublications)(this);
+        (0, cron_jobs_1.loadCronJobPublications)(this);
+        (0, flags_update_1.loadFlagsUpdatePublications)(this);
+        (0, flags_1.loadFlagsPublications)(this);
+        (0, notifications_1.loadNotificationPublications)(this);
+        (0, customer_notifications_1.loadCustomerNotificationPublications)(this);
+        (0, report_builder_reports_1.loadReportBuilderReportPublications)(this);
+        (0, report_builder_libraries_1.loadReportBuilderLibraryPublications)(this);
+        (0, user_groups_1.loadUserGroupPublications)(this);
+        (0, user_guides_1.loadUserGuidePublications)(this);
+        (0, report_builder_dashboard_builders_1.loadReportBuilderDashboardBuilderPublications)(this);
+    };
+    SubscriptionManager.prototype.setCacheLimit = function () {
+        if (process.env.IS_WORKERS_ENABLED === 'true') {
+            this._heapLimit = this._heapSize * 0.4;
+        }
+        else {
+            this._heapLimit = this._heapSize * 0.3; // Use 50% of total heap size
+        }
+    };
+    SubscriptionManager.prototype.configurePublicationWorkers = function () {
+        var _a;
+        var config = this.serverConfig || resolveio_server_app_1.ResolveIOServer.getServerConfig() || {};
+        this._publicationWorkerQueueLimit = this.parsePositiveNumber((_a = process.env.SUBSCRIPTION_WORKER_QUEUE_MAX) !== null && _a !== void 0 ? _a : config['SUBSCRIPTION_WORKER_QUEUE_MAX']);
+    };
+    SubscriptionManager.prototype.parseBoolean = function (value) {
+        if (value === true) {
+            return true;
+        }
+        if (value === false || value === null || value === undefined) {
+            return false;
+        }
+        if (typeof value === 'number') {
+            return value === 1;
+        }
+        if (typeof value === 'string') {
+            var normalized = value.trim().toLowerCase();
+            return ['1', 'true', 'yes', 'y', 'on'].includes(normalized);
+        }
+        return false;
+    };
+    SubscriptionManager.prototype.clampNumber = function (value, min, max) {
+        if (value < min) {
+            return min;
+        }
+        if (value > max) {
+            return max;
+        }
+        return value;
+    };
+    SubscriptionManager.prototype.invalidatePubsCache = function (collection, type, documentId, document) {
+        return __awaiter(this, void 0, void 0, function () {
+            var queue, debounceKey, now, firstInvalidationTime, waitedTooLong;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        queue = this._pendingInvalidations.get(collection);
+                        if (!queue) {
+                            queue = { events: [] };
+                            this._pendingInvalidations.set(collection, queue);
+                        }
+                        queue.events.push({ type: type, documentId: documentId, document: document });
+                        debounceKey = collection;
+                        now = Date.now();
+                        firstInvalidationTime = this._invalidationPendingTimestamps.get(debounceKey) || now;
+                        this._invalidationPendingTimestamps.set(debounceKey, firstInvalidationTime);
+                        // Clear any existing timer
+                        if (this._invalidationDebounceTimers.has(debounceKey)) {
+                            clearTimeout(this._invalidationDebounceTimers.get(debounceKey));
+                        }
+                        waitedTooLong = (now - firstInvalidationTime) >= this.MAX_WAIT_TIME;
+                        if (!waitedTooLong) return [3 /*break*/, 2];
+                        // Immediate execution path
+                        this._invalidationPendingTimestamps.delete(debounceKey);
+                        return [4 /*yield*/, this._executeInvalidation(collection)];
+                    case 1:
+                        _a.sent();
+                        return [3 /*break*/, 3];
+                    case 2:
+                        // Normal debounce path
+                        this._invalidationDebounceTimers.set(debounceKey, setTimeout(function () { return __awaiter(_this, void 0, void 0, function () {
+                            return __generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0:
+                                        this._invalidationPendingTimestamps.delete(debounceKey);
+                                        return [4 /*yield*/, this._executeInvalidation(collection)];
+                                    case 1:
+                                        _a.sent();
+                                        return [2 /*return*/];
+                                }
+                            });
+                        }); }, this.DEBOUNCE_DELAY));
+                        _a.label = 3;
+                    case 3: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    SubscriptionManager.prototype._executeInvalidation = function (collection) {
+        return __awaiter(this, void 0, void 0, function () {
+            var queued, events, collSubs, collSubs_1, collSubs_1_1, sub, batchType, _a, _b, client, ws, _c, e_1_1, e_2_1;
+            var e_2, _d, e_1, _e;
+            var _this = this;
+            return __generator(this, function (_f) {
+                switch (_f.label) {
+                    case 0:
+                        // Clean up any existing timer (defensive)
+                        if (this._invalidationDebounceTimers.has(collection)) {
+                            clearTimeout(this._invalidationDebounceTimers.get(collection));
+                            this._invalidationDebounceTimers.delete(collection);
+                        }
+                        queued = this._pendingInvalidations.get(collection);
+                        this._pendingInvalidations.delete(collection);
+                        if (!queued || !queued.events.length) {
+                            return [2 /*return*/];
+                        }
+                        events = queued.events;
+                        // Original invalidation logic
+                        resolveio_server_app_1.ResolveIOServer.getMongoManager().invalidateQueryCache(collection, true);
+                        collSubs = this._subscriptions.filter(function (sub) { return _this.subscriptionReferencesCollection(sub, collection); });
+                        _f.label = 1;
+                    case 1:
+                        _f.trys.push([1, 18, 19, 20]);
+                        collSubs_1 = __values(collSubs), collSubs_1_1 = collSubs_1.next();
+                        _f.label = 2;
+                    case 2:
+                        if (!!collSubs_1_1.done) return [3 /*break*/, 17];
+                        sub = collSubs_1_1.value;
+                        if (this._enableDebug) {
+                            console.log(new Date(), 'Invalidate Sub', sub.publication, sub.running, sub.runAgain);
+                        }
+                        return [4 /*yield*/, this.shouldInvalidateSubscriptionForEvents(sub, collection, events)];
+                    case 3:
+                        if (!(_f.sent())) {
+                            return [3 /*break*/, 16];
+                        }
+                        if (sub.running) {
+                            sub.runAgain = true;
+                            this.dependencyDebug('Subscription busy, scheduling rerun', { publication: sub.publication, collection: collection, events: this.summarizeEvents(events) });
+                            return [3 /*break*/, 16];
+                        }
+                        batchType = events.length === 1 ? events[0].type : events.map(function (event) { return event.type; }).join(',');
+                        if (!this._publications[sub.publication].user_specific) return [3 /*break*/, 14];
+                        this.dependencyDebug('Triggering user-specific invalidation', { publication: sub.publication, collection: collection, events: this.summarizeEvents(events), clientCount: sub.clients.length });
+                        _f.label = 4;
+                    case 4:
+                        _f.trys.push([4, 11, 12, 13]);
+                        _a = (e_1 = void 0, __values(sub.clients)), _b = _a.next();
+                        _f.label = 5;
+                    case 5:
+                        if (!!_b.done) return [3 /*break*/, 10];
+                        client = _b.value;
+                        ws = this._websocketManager.getWebSocket(client.id_socket);
+                        if (!((ws === null || ws === void 0 ? void 0 : ws.readyState) === WebSocket.OPEN)) return [3 /*break*/, 9];
+                        _f.label = 6;
+                    case 6:
+                        _f.trys.push([6, 8, , 9]);
+                        return [4 /*yield*/, this.sendDataToOneWithRetry(ws, client.messageId, sub, collection, batchType)];
+                    case 7:
+                        _f.sent();
+                        return [3 /*break*/, 9];
+                    case 8:
+                        _c = _f.sent();
+                        return [3 /*break*/, 9];
+                    case 9:
+                        _b = _a.next();
+                        return [3 /*break*/, 5];
+                    case 10: return [3 /*break*/, 13];
+                    case 11:
+                        e_1_1 = _f.sent();
+                        e_1 = { error: e_1_1 };
+                        return [3 /*break*/, 13];
+                    case 12:
+                        try {
+                            if (_b && !_b.done && (_e = _a.return)) _e.call(_a);
+                        }
+                        finally { if (e_1) throw e_1.error; }
+                        return [7 /*endfinally*/];
+                    case 13: return [3 /*break*/, 16];
+                    case 14:
+                        this.dependencyDebug('Triggering broadcast invalidation', { publication: sub.publication, collection: collection, events: this.summarizeEvents(events), clientCount: sub.clients.length });
+                        return [4 /*yield*/, this.sendDataToAllWithRetry(sub, collection, batchType)];
+                    case 15:
+                        _f.sent();
+                        _f.label = 16;
+                    case 16:
+                        collSubs_1_1 = collSubs_1.next();
+                        return [3 /*break*/, 2];
+                    case 17: return [3 /*break*/, 20];
+                    case 18:
+                        e_2_1 = _f.sent();
+                        e_2 = { error: e_2_1 };
+                        return [3 /*break*/, 20];
+                    case 19:
+                        try {
+                            if (collSubs_1_1 && !collSubs_1_1.done && (_d = collSubs_1.return)) _d.call(collSubs_1);
+                        }
+                        finally { if (e_2) throw e_2.error; }
+                        return [7 /*endfinally*/];
+                    case 20: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    SubscriptionManager.prototype.subscriptionReferencesCollection = function (sub, collection) {
+        var _a, _b, _c, _d;
+        if ((_a = sub.collections) === null || _a === void 0 ? void 0 : _a.includes(collection)) {
+            return true;
+        }
+        this.ensureDependencyContainers(sub);
+        var dependencyIds = (_b = sub.collectionDependencies) === null || _b === void 0 ? void 0 : _b.get(collection);
+        if (dependencyIds && dependencyIds.size > 0) {
+            return true;
+        }
+        var filters = (_c = sub.collectionFilters) === null || _c === void 0 ? void 0 : _c.get(collection);
+        if (filters && filters.length > 0) {
+            return true;
+        }
+        if ((_d = sub.watchAllCollections) === null || _d === void 0 ? void 0 : _d.has(collection)) {
+            return true;
+        }
+        return false;
+    };
+    SubscriptionManager.prototype.delay = function (ms) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                // eslint-disable-next-line no-restricted-syntax
+                return [2 /*return*/, new Promise(function (resolve) { return setTimeout(resolve, ms); })];
+            });
+        });
+    };
+    SubscriptionManager.prototype.getMessageDateMs = function (messageDate) {
+        if (messageDate instanceof Date && !isNaN(messageDate.getTime())) {
+            return messageDate.getTime();
+        }
+        if (typeof messageDate === 'string' || typeof messageDate === 'number') {
+            var parsed = new Date(messageDate);
+            if (!isNaN(parsed.getTime())) {
+                return parsed.getTime();
+            }
+        }
+        return Date.now();
+    };
+    SubscriptionManager.prototype.isStaleRouteMessage = function (ws, messageRoute, messageDate) {
+        var socketId = ws ? ws['id_socket'] : '';
+        if (!socketId) {
+            return false;
+        }
+        if (!messageRoute || messageRoute === 'Bypass') {
+            return false;
+        }
+        var messageDateMs = this.getMessageDateMs(messageDate);
+        var lastRoute = this._lastRouteBySocket.get(socketId);
+        if (lastRoute && messageDateMs < lastRoute.dateMs) {
+            this.dependencyDebug('Skip route cleanup due to stale route message', {
+                socketId: socketId,
+                messageRoute: messageRoute,
+                messageDateMs: messageDateMs,
+                lastRoute: lastRoute.route,
+                lastRouteDateMs: lastRoute.dateMs
+            });
+            return true;
+        }
+        this._lastRouteBySocket.set(socketId, { route: messageRoute, dateMs: messageDateMs });
+        return false;
+    };
+    SubscriptionManager.prototype.getPublicationWorkerDispatcher = function () {
+        var mainServer = resolveio_server_app_1.ResolveIOServer.getMainServer();
+        return mainServer && typeof mainServer.getWorkerDispatcherManager === 'function'
+            ? mainServer.getWorkerDispatcherManager()
+            : null;
+    };
+    SubscriptionManager.prototype.shouldUsePublicationWorkers = function () {
+        var dispatcher = this.getPublicationWorkerDispatcher();
+        if (!dispatcher || !dispatcher.hasWorkers()) {
+            return false;
+        }
+        if (typeof dispatcher.hasWorkersForMethod === 'function' && !dispatcher.hasWorkersForMethod('runPublication')) {
+            return false;
+        }
+        if (this._publicationWorkerQueueLimit > 0) {
+            var snapshot = dispatcher.getQueueSnapshot();
+            if (snapshot.queueDepth >= this._publicationWorkerQueueLimit) {
+                return false;
+            }
+        }
+        return true;
+    };
+    SubscriptionManager.prototype.runPublicationViaWorker = function (sub, userId) {
+        return __awaiter(this, void 0, void 0, function () {
+            var dispatcher, response, meta, snapshot, error_1;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!this.shouldUsePublicationWorkers()) {
+                            return [2 /*return*/, null];
+                        }
+                        dispatcher = this.getPublicationWorkerDispatcher();
+                        if (!dispatcher) {
+                            return [2 /*return*/, null];
+                        }
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, 3, , 4]);
+                        return [4 /*yield*/, dispatcher.sendInternalPromiseRaw('runPublication', [
+                                sub.publication,
+                                sub.subscriptionData,
+                                userId
+                            ])];
+                    case 2:
+                        response = _a.sent();
+                        if (!response || response.error) {
+                            throw (response === null || response === void 0 ? void 0 : response.result) || new Error('Publication worker error');
+                        }
+                        if (!response.packedResult) {
+                            throw new Error('Publication worker missing packedResult');
+                        }
+                        meta = response.meta || {};
+                        snapshot = meta.snapshot ? (0, subscription_dependency_context_1.deserializeDependencySnapshot)(meta.snapshot) : undefined;
+                        return [2 /*return*/, {
+                                packedResult: response.packedResult,
+                                snapshot: snapshot,
+                                encoding: response.encoding || meta.encoding || 'msgpack',
+                                workerUsed: true
+                            }];
+                    case 3:
+                        error_1 = _a.sent();
+                        if (this._enableDebug) {
+                            console.log(new Date(), 'Sub Manager', 'Worker publication failed, falling back', sub.publication, (error_1 === null || error_1 === void 0 ? void 0 : error_1.message) || error_1);
+                        }
+                        return [2 /*return*/, null];
+                    case 4: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    SubscriptionManager.prototype.runPublicationLocally = function (sub, userId) {
+        return __awaiter(this, void 0, void 0, function () {
+            var pub, context, metadata, execution, _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        pub = this._publications[sub.publication];
+                        if (!pub) {
+                            throw new Error("Publication not found: ".concat(sub.publication));
+                        }
+                        context = Object.assign({}, this, SubscriptionManager.prototype);
+                        metadata = {
+                            publication: sub.publication,
+                            subscriptionData: sub.subscriptionData
+                        };
+                        if (!pub.user_specific) return [3 /*break*/, 2];
+                        return [4 /*yield*/, (0, subscription_dependency_context_1.withDependencyTracking)(function () {
+                                var _a;
+                                return (_a = pub.function).call.apply(_a, __spreadArray([context, userId || ''], __read(sub.subscriptionData), false));
+                            }, Object.assign({}, metadata, { userId: userId }))];
+                    case 1:
+                        _a = _b.sent();
+                        return [3 /*break*/, 4];
+                    case 2: return [4 /*yield*/, (0, subscription_dependency_context_1.withDependencyTracking)(function () {
+                            var _a;
+                            return (_a = pub.function).call.apply(_a, __spreadArray([context], __read(sub.subscriptionData), false));
+                        }, metadata)];
+                    case 3:
+                        _a = _b.sent();
+                        _b.label = 4;
+                    case 4:
+                        execution = _a;
+                        return [2 /*return*/, {
+                                result: execution.result,
+                                packedResult: this.packCachePayload(execution.result),
+                                snapshot: execution.snapshot,
+                                encoding: 'msgpack',
+                                workerUsed: false
+                            }];
+                }
+            });
+        });
+    };
+    SubscriptionManager.prototype.runPublicationExecution = function (sub, userId) {
+        return __awaiter(this, void 0, void 0, function () {
+            var pub, effectiveUserId, workerExecution;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        pub = this._publications[sub.publication];
+                        if (!pub) {
+                            throw new Error("Publication not found: ".concat(sub.publication));
+                        }
+                        effectiveUserId = pub.user_specific ? userId : undefined;
+                        return [4 /*yield*/, this.runPublicationViaWorker(sub, effectiveUserId)];
+                    case 1:
+                        workerExecution = _a.sent();
+                        if (workerExecution) {
+                            return [2 /*return*/, workerExecution];
+                        }
+                        return [2 /*return*/, this.runPublicationLocally(sub, effectiveUserId)];
+                }
+            });
+        });
+    };
+    SubscriptionManager.prototype.sendDataToAllWithRetry = function (sub, collection, type) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        sub.running = true;
+                        _a.label = 1;
+                    case 1:
+                        if (this._enableDebug) {
+                            console.log(new Date(), 'Running sendDataToAll Sub', sub.publication);
+                        }
+                        sub.runAgain = false;
+                        return [4 /*yield*/, this.sendDataToAll(sub, collection, type)];
+                    case 2:
+                        _a.sent();
+                        if (this._enableDebug) {
+                            console.log(new Date(), 'Done sendDataToAll Sub', sub.publication, sub.runAgain);
+                        }
+                        if (!sub.runAgain) return [3 /*break*/, 4];
+                        return [4 /*yield*/, this.delay(500)];
+                    case 3:
+                        _a.sent(); // delay, adjust as needed
+                        _a.label = 4;
+                    case 4:
+                        if (sub.runAgain) return [3 /*break*/, 1];
+                        _a.label = 5;
+                    case 5:
+                        sub.running = false;
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    SubscriptionManager.prototype.sendDataToOneWithRetry = function (ws, messageId, sub, collection, type) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        sub.running = true;
+                        _a.label = 1;
+                    case 1:
+                        if (this._enableDebug) {
+                            console.log(new Date(), 'Running sendDataToOne Sub', sub.publication);
+                        }
+                        sub.runAgain = false;
+                        return [4 /*yield*/, this.sendDataToOne(ws, messageId, sub, collection, type)];
+                    case 2:
+                        _a.sent();
+                        if (this._enableDebug) {
+                            console.log(new Date(), 'Done sendDataToOne Sub', sub.publication, sub.runAgain);
+                        }
+                        if (!sub.runAgain) return [3 /*break*/, 4];
+                        return [4 /*yield*/, this.delay(500)];
+                    case 3:
+                        _a.sent(); // delay, adjust as needed
+                        _a.label = 4;
+                    case 4:
+                        if (sub.runAgain) return [3 /*break*/, 1];
+                        _a.label = 5;
+                    case 5:
+                        sub.running = false;
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    // Add all files to publications private object
+    SubscriptionManager.prototype.publications = function (method) {
+        this._publications = Object.assign(this._publications, method);
+    };
+    SubscriptionManager.prototype.getPublication = function (publication) {
+        return this._publications[publication];
+    };
+    SubscriptionManager.prototype.getPublications = function () {
+        return this._publications;
+    };
+    // Throttled `loggedInLatency` method
+    SubscriptionManager.prototype.loggedInLatency = function (ws) {
+        var now = new Date();
+        var newLatency = ws['latency'];
+        var socketId = ws['id_socket'];
+        var loggedInUser = this._loggedInUsers.find(function (a) { return a.id_ws === socketId; });
+        if (!loggedInUser) {
+            return;
+        }
+        var existingEntry = this.latencyBuffer.get(socketId);
+        // Throttle updates: only update if time threshold has passed or latency has significantly changed
+        if (!existingEntry ||
+            (now.getTime() - existingEntry.lastUpdate.getTime() >= this.LATENCY_UPDATE_THRESHOLD_MS) ||
+            (Math.abs(newLatency - existingEntry.latency) > 100) // Optional: log only significant changes
+        ) {
+            // Update in-memory and buffer
+            loggedInUser.date = now;
+            this.latencyBuffer.set(socketId, { latency: newLatency, lastUpdate: now });
+        }
+    };
+    // Method to flush buffered latency updates in bulk
+    SubscriptionManager.prototype.flushThrottledLatencyUpdates = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var pendingEntries, updates, error_2, pendingEntries_1, pendingEntries_1_1, _a, id_ws, payload, current;
+            var e_3, _b;
+            var _this = this;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        if (this.latencyBuffer.size === 0)
+                            return [2 /*return*/]; // No updates to flush
+                        if (this._latencyFlushInProgress) {
+                            this._latencyFlushPending = true;
+                            return [2 /*return*/];
+                        }
+                        this._latencyFlushInProgress = true;
+                        pendingEntries = Array.from(this.latencyBuffer.entries());
+                        this.latencyBuffer.clear();
+                        updates = pendingEntries.map(function (_a) {
+                            var _b = __read(_a, 2), id_ws = _b[0], _c = _b[1], latency = _c.latency, lastUpdate = _c.lastUpdate;
+                            return ({
+                                updateOne: {
+                                    filter: { id_ws: id_ws },
+                                    update: { $set: { latency: latency, date: lastUpdate } }
+                                }
+                            });
+                        });
+                        _c.label = 1;
+                    case 1:
+                        _c.trys.push([1, 3, 4, 5]);
+                        return [4 /*yield*/, logged_in_users_collection_1.LoggedInUsers.bulkWrite(updates, { ordered: false })];
+                    case 2:
+                        _c.sent();
+                        if (this.getEnableDebug()) {
+                            console.log(new Date(), 'Sub Manager', 'Throttled latency batch update successful', updates.length);
+                        }
+                        return [3 /*break*/, 5];
+                    case 3:
+                        error_2 = _c.sent();
+                        try {
+                            for (pendingEntries_1 = __values(pendingEntries), pendingEntries_1_1 = pendingEntries_1.next(); !pendingEntries_1_1.done; pendingEntries_1_1 = pendingEntries_1.next()) {
+                                _a = __read(pendingEntries_1_1.value, 2), id_ws = _a[0], payload = _a[1];
+                                current = this.latencyBuffer.get(id_ws);
+                                if (!current || current.lastUpdate < payload.lastUpdate) {
+                                    this.latencyBuffer.set(id_ws, payload);
+                                }
+                            }
+                        }
+                        catch (e_3_1) { e_3 = { error: e_3_1 }; }
+                        finally {
+                            try {
+                                if (pendingEntries_1_1 && !pendingEntries_1_1.done && (_b = pendingEntries_1.return)) _b.call(pendingEntries_1);
+                            }
+                            finally { if (e_3) throw e_3.error; }
+                        }
+                        console.error(new Date(), 'Sub Manager', 'Throttled latency batch update failed', error_2);
+                        return [3 /*break*/, 5];
+                    case 4:
+                        this._latencyFlushInProgress = false;
+                        if (this._latencyFlushPending) {
+                            this._latencyFlushPending = false;
+                            setImmediate(function () { return _this.flushThrottledLatencyUpdates(); });
+                        }
+                        return [7 /*endfinally*/];
+                    case 5: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    // Subscribe to publication
+    SubscriptionManager.prototype.subscribe = function (messageRoute, messageDate, ws, messageId, publication, subscriptionData) {
+        return __awaiter(this, void 0, void 0, function () {
+            var pub, valObj, valKeys, rootKeys, i, staleRouteMessage, urlData, urlModule_1, urlNext, otherRouteSubs, normalizedSubscriptionData, subscriptionKey_1, sub, isAiPublication, wsId_1, wsUserId, existingIndex, existingClient, i;
+            var _this = this;
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        this._debugSubHits += 1;
+                        this.connectDebug('Subscribe request', {
+                            publication: publication,
+                            messageRoute: messageRoute,
+                            messageId: messageId,
+                            id_socket: ws ? ws['id_socket'] : null,
+                            user: ws ? ws['user'] : null,
+                            args: Array.isArray(subscriptionData) ? subscriptionData.length : 0
+                        });
+                        if (!this._debugSubCollections.some(function (a) { return a.publication === publication; })) {
+                            this._debugSubCollections.push({
+                                publication: publication,
+                                hits: 1
+                            });
+                        }
+                        else {
+                            this._debugSubCollections.find(function (a) { return a.publication === publication; }).hits += 1;
+                        }
+                        pub = this._publications[publication];
+                        if (!!pub) return [3 /*break*/, 1];
+                        console.error(new Date(), 'No Publication: ' + publication);
+                        this.connectDebug('Missing publication', { publication: publication, messageRoute: messageRoute, messageId: messageId });
+                        return [2 /*return*/];
+                    case 1:
+                        if (subscriptionData.length > 1 || subscriptionData[0]) {
+                            if (!pub.check) {
+                                console.error(new Date(), 'No Check Function For Pub ' + publication);
+                                this.connectDebug('Missing check for publication', { publication: publication, messageRoute: messageRoute, messageId: messageId });
+                                return [2 /*return*/];
+                            }
+                            else if (!pub.check._schema) {
+                                console.error(new Date(), 'No Check Schema For Pub ' + publication);
+                                this.connectDebug('Missing check schema for publication', { publication: publication, messageRoute: messageRoute, messageId: messageId });
+                                return [2 /*return*/];
+                            }
+                            else {
+                                valObj = {};
+                                valKeys = Object.keys(pub.check._schema);
+                                rootKeys = valKeys.filter(function (a) { return !a.includes('.'); });
+                                for (i = 0; i < subscriptionData.length; i++) {
+                                    valObj[rootKeys[i]] = subscriptionData[i];
+                                }
+                                try {
+                                    pub.check.validate(valObj);
+                                }
+                                catch (errors) {
+                                    if (errors) {
+                                        console.error(new Date(), 'Error in Pub Check (' + publication + ')', errors);
+                                        this.connectDebug('Publication check failed', {
+                                            publication: publication,
+                                            messageRoute: messageRoute,
+                                            messageId: messageId,
+                                            args: subscriptionData.length,
+                                            valObj: valObj,
+                                            error: (errors === null || errors === void 0 ? void 0 : errors.message) || errors
+                                        });
+                                        return [2 /*return*/];
+                                    }
+                                }
+                            }
+                        }
+                        staleRouteMessage = this.isStaleRouteMessage(ws, messageRoute, messageDate);
+                        if (messageRoute !== 'Bypass' && messageRoute !== '/' && !staleRouteMessage) {
+                            urlData = messageRoute.split('/');
+                            urlModule_1 = '';
+                            urlNext = urlData[0];
+                            if (urlData[0] === '') {
+                                urlModule_1 = '/';
+                                urlNext = urlData[1];
+                            }
+                            urlModule_1 += urlNext;
+                            if (urlData.length > 1) {
+                                urlModule_1 += '/';
+                            }
+                            otherRouteSubs = this._subscriptions.filter(function (a) { return a.clients.some(function (b) { return b.id_socket === ws['id_socket'] && b.messageRoute !== 'Bypass' && b.messageRoute !== '/' && b.messageRoute !== messageRoute && !b.messageRoute.startsWith(urlModule_1); }); });
+                            if (otherRouteSubs.length) {
+                                // ResolveIOServer.getMainServer().getMethodManager().sendEmail('dev@resolveio.com', 'SERVER - Detected Undestroyed Subscription - ' + this.serverConfig['CLIENT_NAME'], 'USER: ' + ws['user'] + ' (Socket: ' + ws['id_socket'] + ') ' + ' is on route: ' + messageRoute + ' but has the following subscriptions on other routes:' + JSON.stringify(otherRouteSubs, null, 2));
+                                otherRouteSubs.forEach(function (otherSub) {
+                                    otherSub.clients.filter(function (a) { return a.id_socket === ws['id_socket']; }).forEach(function (client) {
+                                        _this.unsubscribe(client.messageRoute, new Date(), ws, client.messageId, otherSub.publication, otherSub.subscriptionData);
+                                    });
+                                });
+                            }
+                        }
+                        normalizedSubscriptionData = Array.isArray(subscriptionData) ? subscriptionData : [];
+                        subscriptionKey_1 = JSON.stringify(normalizedSubscriptionData);
+                        sub = this._subscriptions.find(function (a) { return a.publication === publication && a.subscriptionKey === subscriptionKey_1; });
+                        isAiPublication = this.isAiPublication(publication);
+                        wsId_1 = ws ? ws['id_socket'] : null;
+                        wsUserId = ws ? ws['id_user'] : null;
+                        // If sub found (another user watching same data), add client to same sub
+                        if (sub) {
+                            if (isAiPublication && wsId_1) {
+                                existingIndex = sub.clients.findIndex(function (a) { return a.id_socket === wsId_1; });
+                                if (existingIndex >= 0) {
+                                    existingClient = sub.clients[existingIndex];
+                                    for (i = sub.clients.length - 1; i >= 0; i--) {
+                                        if (i !== existingIndex && sub.clients[i].id_socket === wsId_1) {
+                                            sub.clients.splice(i, 1);
+                                        }
+                                    }
+                                    existingClient.id_user = wsUserId;
+                                    existingClient.messageId = messageId;
+                                    existingClient.messageRoute = messageRoute;
+                                }
+                                else {
+                                    sub.clients.push({
+                                        id_user: wsUserId,
+                                        messageId: messageId,
+                                        id_socket: wsId_1,
+                                        messageRoute: messageRoute
+                                    });
+                                }
+                            }
+                            else if (!sub.clients.some(function (a) { return a.id_socket === ws['id_socket'] && a.messageId === messageId; })) {
+                                sub.clients.push({
+                                    id_user: ws['id_user'],
+                                    messageId: messageId,
+                                    id_socket: ws['id_socket'],
+                                    messageRoute: messageRoute
+                                });
+                            }
+                        }
+                        // If sub not found, create new sub
+                        else {
+                            this._subscriptions.push({
+                                publication: publication,
+                                subscriptionKey: subscriptionKey_1,
+                                subscriptionData: normalizedSubscriptionData,
+                                collections: this.getPublicationCollections(publication),
+                                clients: [{
+                                        id_user: ws['id_user'],
+                                        messageId: messageId,
+                                        id_socket: ws['id_socket'],
+                                        messageRoute: messageRoute,
+                                    }],
+                                cacheId: 0,
+                                running: false,
+                                runAgain: false,
+                                collectionDependencies: new Map(),
+                                collectionFilters: new Map(),
+                                watchAllCollections: new Set(),
+                                collectionQueryMeta: new Map()
+                            });
+                        }
+                        if (!sub) {
+                            sub = this._subscriptions.find(function (a) { return a.publication === publication && a.subscriptionKey === subscriptionKey_1; });
+                        }
+                        this.ensureDependencyContainers(sub);
+                        this.logAiSubscriptionEvent('sub', {
+                            publication: publication,
+                            subscriptionKey: subscriptionKey_1,
+                            messageId: messageId,
+                            id_socket: ws ? ws['id_socket'] : null,
+                            messageRoute: messageRoute,
+                            clients: ((_a = sub === null || sub === void 0 ? void 0 : sub.clients) === null || _a === void 0 ? void 0 : _a.length) || 0,
+                            subscriptionData: normalizedSubscriptionData
+                        });
+                        if (this._enableDebug) {
+                            console.log(new Date(), 'New Sub', sub.publication, sub.running, sub.runAgain, sub.clients.length);
+                        }
+                        // Immediately send data to the new client
+                        return [4 /*yield*/, this.processSubscription(sub, ws, messageId)];
+                    case 2:
+                        // Immediately send data to the new client
+                        _b.sent();
+                        _b.label = 3;
+                    case 3: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    SubscriptionManager.prototype.createLoggedInUser = function (id_ws) {
+        return __awaiter(this, void 0, void 0, function () {
+            var ws, user;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        ws = this._websocketManager.getWebSocket(id_ws);
+                        if (!ws) return [3 /*break*/, 2];
+                        user = {
+                            _id: (0, common_1.objectIdHexString)(),
+                            __v: 0,
+                            date: new Date(),
+                            id_user: ws['id_user'],
+                            user: ws['user'],
+                            id_ws: ws['id_socket']
+                        };
+                        this._loggedInUsers.push(user);
+                        return [4 /*yield*/, logged_in_users_collection_1.LoggedInUsers.insertOne(user)];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/, user];
+                    case 2: throw new Error('Error in Create Logged In User: No WS');
+                }
+            });
+        });
+    };
+    // Unsubscribe from publication 
+    SubscriptionManager.prototype.unsubscribe = function (messageRoute, messageDate, ws, messageId, publication, subscriptionData) {
+        this._debugUnSubHits += 1;
+        if (!this._publications[publication]) {
+            console.log('No Publication: ' + publication);
+            return;
+        }
+        else {
+            var normalizedSubscriptionData = Array.isArray(subscriptionData) ? subscriptionData : [];
+            var subscriptionKey_2 = JSON.stringify(normalizedSubscriptionData);
+            var sub = this._subscriptions.find(function (a) { return a.publication === publication && a.subscriptionKey === subscriptionKey_2; });
+            if (sub) {
+                var isAiPublication = this.isAiPublication(publication);
+                for (var i = sub.clients.length - 1; i >= 0; i--) {
+                    if (isAiPublication && sub.clients[i].id_socket === ws['id_socket']) {
+                        sub.clients.splice(i, 1);
+                    }
+                    else if (sub.clients[i].id_user === ws['id_user'] && sub.clients[i].messageId === messageId && sub.clients[i].id_socket === ws['id_socket']) {
+                        sub.clients.splice(i, 1);
+                    }
+                }
+                this.logAiSubscriptionEvent('unsub', {
+                    publication: publication,
+                    subscriptionKey: subscriptionKey_2,
+                    messageId: messageId,
+                    id_socket: ws ? ws['id_socket'] : null,
+                    messageRoute: messageRoute,
+                    clients: sub.clients.length,
+                    subscriptionData: normalizedSubscriptionData
+                });
+                if (this._enableDebug) {
+                    console.log(new Date(), 'Unsub', sub.publication, sub.running, sub.runAgain, sub.clients.length);
+                }
+            }
+        }
+    };
+    // Unsubscribe from publication
+    SubscriptionManager.prototype.unsubscribeAll = function (ws) {
+        return __awaiter(this, void 0, void 0, function () {
+            var userSubs, i, sub, j;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        this._debugUnSubAllHits += 1;
+                        if (!ws) return [3 /*break*/, 2];
+                        if (ws['id_socket']) {
+                            this._lastRouteBySocket.delete(ws['id_socket']);
+                        }
+                        // Check if WebSocket has already been unsubscribed
+                        if (ws['isUnsubscribed']) {
+                            return [2 /*return*/]; // Skip if already unsubscribed
+                        }
+                        // Mark the WebSocket as unsubscribed to prevent further calls
+                        ws['isUnsubscribed'] = true;
+                        if (this._loggedInUsers.map(function (a) { return a.id_ws; }).indexOf(ws['id_socket']) >= 0) {
+                            this._loggedInUsers.splice(this._loggedInUsers.map(function (a) { return a.id_ws; }).indexOf(ws['id_socket']), 1);
+                        }
+                        return [4 /*yield*/, logged_in_users_collection_1.LoggedInUsers.deleteOne({ id_ws: ws['id_socket'] })];
+                    case 1:
+                        _a.sent();
+                        userSubs = this._subscriptions.filter(function (a) { return a.clients.some(function (b) { return b.id_user === ws['id_user'] && b.id_socket === ws['id_socket']; }); });
+                        for (i = userSubs.length - 1; i >= 0; i--) {
+                            sub = userSubs[i];
+                            for (j = sub.clients.length - 1; j >= 0; j--) {
+                                if (sub.clients[j].id_socket === ws['id_socket']) {
+                                    sub.clients.splice(j, 1);
+                                }
+                            }
+                        }
+                        this._websocketManager.removeWebSocket(ws);
+                        _a.label = 2;
+                    case 2: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    SubscriptionManager.prototype.getActiveSubscriptions = function () {
+        return this._subscriptions;
+    };
+    // Get publication collection
+    SubscriptionManager.prototype.getPublicationCollections = function (publication) {
+        return this._publications[publication].collections;
+    };
+    SubscriptionManager.prototype.getWatchedDatabases = function () {
+        var mongoManager = resolveio_server_app_1.ResolveIOServer.getMongoManager();
+        var managerDatabases = (mongoManager === null || mongoManager === void 0 ? void 0 : mongoManager.getWatchedDatabases()) || [];
+        if (managerDatabases.length) {
+            return managerDatabases;
+        }
+        var config = this.serverConfig || resolveio_server_app_1.ResolveIOServer.getServerConfig();
+        var mainDb = config && typeof config['DATABASE'] === 'string' ? config['DATABASE'] : '';
+        return mainDb ? [mainDb] : [];
+    };
+    SubscriptionManager.prototype.resolveOplogMode = function () {
+        var config = this.serverConfig || resolveio_server_app_1.ResolveIOServer.getServerConfig() || {};
+        var raw = process.env.SUBSCRIPTION_OPLOG_MODE || process.env.OPLOG_MODE || config['SUBSCRIPTION_OPLOG_MODE'] || config['OPLOG_MODE'];
+        if (typeof raw !== 'string' || !raw.trim()) {
+            return 'auto';
+        }
+        var normalized = raw.trim().toLowerCase();
+        if (['local', 'single', 'standalone', 'fallback', 'poll'].includes(normalized)) {
+            return 'local';
+        }
+        if (['change-stream', 'changestream', 'oplog', 'replica', 'replicaset', 'rs'].includes(normalized)) {
+            return 'change-stream';
+        }
+        return 'auto';
+    };
+    SubscriptionManager.prototype.resolveLocalOplogResyncIntervalMs = function () {
+        var config = this.serverConfig || resolveio_server_app_1.ResolveIOServer.getServerConfig() || {};
+        var raw = process.env.OPLOG_FALLBACK_RESYNC_MS
+            || process.env.SUBSCRIPTION_OPLOG_RESYNC_MS
+            || config['OPLOG_FALLBACK_RESYNC_MS']
+            || config['SUBSCRIPTION_OPLOG_RESYNC_MS'];
+        return this.parsePositiveNumber(raw);
+    };
+    SubscriptionManager.prototype.resolveResumeTokenMaxAgeMs = function () {
+        var config = this.serverConfig || resolveio_server_app_1.ResolveIOServer.getServerConfig() || {};
+        var raw = process.env.OPLOG_RESUME_TOKEN_MAX_AGE_MS
+            || process.env.SUBSCRIPTION_OPLOG_RESUME_TOKEN_MAX_AGE_MS
+            || config['OPLOG_RESUME_TOKEN_MAX_AGE_MS']
+            || config['SUBSCRIPTION_OPLOG_RESUME_TOKEN_MAX_AGE_MS'];
+        return this.parsePositiveNumber(raw);
+    };
+    SubscriptionManager.prototype.resolveConnectDebug = function () {
+        var config = this.serverConfig || resolveio_server_app_1.ResolveIOServer.getServerConfig() || {};
+        var raw = process.env.WS_CONNECT_DEBUG
+            || process.env.CONNECT_DEBUG
+            || config['WS_CONNECT_DEBUG']
+            || config['CONNECT_DEBUG'];
+        return this.parseDebugFlag(raw);
+    };
+    SubscriptionManager.prototype.resolveSubSendDebug = function () {
+        var config = this.serverConfig || resolveio_server_app_1.ResolveIOServer.getServerConfig() || {};
+        var raw = process.env.SUB_SEND_DEBUG
+            || process.env.SUBSCRIPTION_SEND_DEBUG
+            || config['SUB_SEND_DEBUG']
+            || config['SUBSCRIPTION_SEND_DEBUG'];
+        return this.parseDebugFlag(raw);
+    };
+    SubscriptionManager.prototype.resolveSubSendLogEnabled = function () {
+        var config = this.serverConfig || resolveio_server_app_1.ResolveIOServer.getServerConfig() || {};
+        var raw = process.env.SUB_SEND_LOG_ENABLED
+            || process.env.SUBSCRIPTION_SEND_LOG_ENABLED
+            || config['SUB_SEND_LOG_ENABLED']
+            || config['SUBSCRIPTION_SEND_LOG_ENABLED'];
+        if (raw === undefined || raw === null || raw === '') {
+            return this._subSendDebug;
+        }
+        return this.parseDebugFlag(raw);
+    };
+    SubscriptionManager.prototype.resolveSubSendLogThresholdMs = function () {
+        var config = this.serverConfig || resolveio_server_app_1.ResolveIOServer.getServerConfig() || {};
+        var raw = process.env.SUB_SEND_LOG_THRESHOLD_MS
+            || process.env.SUBSCRIPTION_SEND_LOG_THRESHOLD_MS
+            || config['SUB_SEND_LOG_THRESHOLD_MS']
+            || config['SUBSCRIPTION_SEND_LOG_THRESHOLD_MS'];
+        return this.parsePositiveNumber(raw);
+    };
+    SubscriptionManager.prototype.resolveSubSendLogBytes = function () {
+        var config = this.serverConfig || resolveio_server_app_1.ResolveIOServer.getServerConfig() || {};
+        var raw = process.env.SUB_SEND_LOG_BYTES
+            || process.env.SUBSCRIPTION_SEND_LOG_BYTES
+            || config['SUB_SEND_LOG_BYTES']
+            || config['SUBSCRIPTION_SEND_LOG_BYTES'];
+        return this.parsePositiveNumber(raw);
+    };
+    SubscriptionManager.prototype.resolveSubSendLogSampleRate = function () {
+        var config = this.serverConfig || resolveio_server_app_1.ResolveIOServer.getServerConfig() || {};
+        var raw = process.env.SUB_SEND_LOG_SAMPLE_RATE
+            || process.env.SUBSCRIPTION_SEND_LOG_SAMPLE_RATE
+            || config['SUB_SEND_LOG_SAMPLE_RATE']
+            || config['SUBSCRIPTION_SEND_LOG_SAMPLE_RATE'];
+        return this.parseSampleRate(raw, this._subSendLogSampleRate);
+    };
+    SubscriptionManager.prototype.resolveAiSubscriptionDebug = function () {
+        var config = this.serverConfig || resolveio_server_app_1.ResolveIOServer.getServerConfig() || {};
+        var raw = process.env.AI_ASSISTANT_SUB_DEBUG
+            || process.env.AI_TERMINAL_SUB_DEBUG
+            || config['AI_ASSISTANT_SUB_DEBUG']
+            || config['AI_TERMINAL_SUB_DEBUG'];
+        return this.parseDebugFlag(raw);
+    };
+    SubscriptionManager.prototype.parseDebugFlag = function (value) {
+        if (value === true) {
+            return true;
+        }
+        if (value === false || value === null || value === undefined) {
+            return false;
+        }
+        if (typeof value === 'number') {
+            return value === 1;
+        }
+        if (typeof value === 'string') {
+            var normalized = value.trim().toLowerCase();
+            return ['1', 'true', 'yes', 'y', 'on'].includes(normalized);
+        }
+        return false;
+    };
+    SubscriptionManager.prototype.parsePositiveNumber = function (value) {
+        if (typeof value === 'number' && Number.isFinite(value) && value > 0) {
+            return value;
+        }
+        if (typeof value === 'string' && value.trim().length) {
+            var parsed = parseInt(value, 10);
+            if (Number.isFinite(parsed) && parsed > 0) {
+                return parsed;
+            }
+        }
+        return 0;
+    };
+    SubscriptionManager.prototype.parseSampleRate = function (value, fallback) {
+        var parsed = parseFloat(value !== null && value !== void 0 ? value : '');
+        if (Number.isFinite(parsed) && parsed > 0 && parsed <= 1) {
+            return parsed;
+        }
+        return fallback;
+    };
+    SubscriptionManager.prototype.shouldLogSubSend = function (durationMs, payloadBytes) {
+        if (!this._subSendLogEnabled) {
+            return false;
+        }
+        if (this._subSendLogSampleRate < 1 && Math.random() > this._subSendLogSampleRate) {
+            return false;
+        }
+        if (this._subSendDebug) {
+            return true;
+        }
+        if (this._subSendLogThresholdMs > 0 && durationMs >= this._subSendLogThresholdMs) {
+            return true;
+        }
+        if (payloadBytes !== null && this._subSendLogBytes > 0 && payloadBytes >= this._subSendLogBytes) {
+            return true;
+        }
+        return false;
+    };
+    SubscriptionManager.prototype.logSubSend = function (sub, details) {
+        if (!details.clients) {
+            return;
+        }
+        if (!this.shouldLogSubSend(details.durationMs, details.payloadBytes)) {
+            return;
+        }
+        console.log(new Date(), '[Sub Send]', JSON.stringify({
+            publication: sub.publication,
+            subscriptionKey: sub.subscriptionKey,
+            clients: details.clients,
+            durationMs: details.durationMs,
+            payloadBytes: details.payloadBytes,
+            collection: details.collection,
+            type: details.type
+        }));
+    };
+    SubscriptionManager.prototype.isAiPublication = function (publication) {
+        return publication === 'aiTerminalMessages' || publication === 'aiTerminalConversations';
+    };
+    SubscriptionManager.prototype.logAiSubSend = function (details) {
+        var _a;
+        if (!this._aiWorkerDebug) {
+            return;
+        }
+        if (!this.isAiPublication(details.publication)) {
+            return;
+        }
+        console.log(new Date(), '[AI Worker Debug] subSend', JSON.stringify({
+            publication: details.publication,
+            subscriptionKey: details.subscriptionKey,
+            messageId: details.messageId,
+            id_socket: details.id_socket,
+            clients: details.clients,
+            payloadBytes: details.payloadBytes,
+            packed: details.packed,
+            cacheHit: (_a = details.cacheHit) !== null && _a !== void 0 ? _a : false,
+            collection: details.collection,
+            type: details.type,
+            subscriptionData: details.subscriptionData
+        }));
+    };
+    SubscriptionManager.prototype.logAiSubscriptionEvent = function (event, details) {
+        if (!this._aiSubscriptionDebug) {
+            return;
+        }
+        if (!this.isAiPublication(details.publication)) {
+            return;
+        }
+        var wsId = details.id_socket || 'unknown';
+        var key = "".concat(event, ":").concat(wsId, ":").concat(details.publication, ":").concat(details.subscriptionKey);
+        var now = Date.now();
+        var lastAt = this._aiSubLastAt.get(key);
+        var deltaMs = lastAt ? now - lastAt : null;
+        this._aiSubLastAt.set(key, now);
+        console.log(new Date(), "[AI Sub Debug] ".concat(event), JSON.stringify({
+            publication: details.publication,
+            subscriptionKey: details.subscriptionKey,
+            messageId: details.messageId,
+            messageRoute: details.messageRoute,
+            id_socket: wsId,
+            clients: details.clients,
+            deltaMs: deltaMs,
+            subscriptionData: details.subscriptionData
+        }));
+    };
+    SubscriptionManager.prototype.connectDebug = function (message, details) {
+        if (!this._connectDebug) {
+            return;
+        }
+        if (details) {
+            console.log(new Date(), '[Connect Debug]', message, JSON.stringify(details));
+        }
+        else {
+            console.log(new Date(), '[Connect Debug]', message);
+        }
+    };
+    SubscriptionManager.prototype.parsePositiveFloat = function (value) {
+        if (typeof value === 'number' && Number.isFinite(value) && value > 0) {
+            return value;
+        }
+        if (typeof value === 'string' && value.trim().length) {
+            var parsed = parseFloat(value);
+            if (Number.isFinite(parsed) && parsed > 0) {
+                return parsed;
+            }
+        }
+        return 0;
+    };
+    SubscriptionManager.prototype.isChangeStreamUnsupported = function (error) {
+        var code = typeof (error === null || error === void 0 ? void 0 : error.code) === 'number' ? error.code : null;
+        var codeName = typeof (error === null || error === void 0 ? void 0 : error.codeName) === 'string' ? error.codeName.toLowerCase() : '';
+        var message = typeof (error === null || error === void 0 ? void 0 : error.message) === 'string' ? error.message.toLowerCase() : '';
+        if (code === 40573) {
+            return true;
+        }
+        if (codeName && codeName.includes('changestream')) {
+            return true;
+        }
+        if (message.includes('change stream') && message.includes('replica')) {
+            return true;
+        }
+        if (message.includes('change stream') && message.includes('not supported')) {
+            return true;
+        }
+        return false;
+    };
+    SubscriptionManager.prototype.isResumeTokenInvalid = function (error) {
+        var code = typeof (error === null || error === void 0 ? void 0 : error.code) === 'number' ? error.code : null;
+        var codeName = typeof (error === null || error === void 0 ? void 0 : error.codeName) === 'string' ? error.codeName.toLowerCase() : '';
+        var message = typeof (error === null || error === void 0 ? void 0 : error.message) === 'string' ? error.message.toLowerCase() : '';
+        if (code === 286) {
+            // ChangeStreamHistoryLost
+            return true;
+        }
+        if (codeName.includes('changestreamhistorylost')) {
+            return true;
+        }
+        if (message.includes('resume token') && (message.includes('not found') ||
+            message.includes('not possible') ||
+            message.includes('no longer') ||
+            message.includes('not in the oplog') ||
+            message.includes('too old'))) {
+            return true;
+        }
+        if (message.includes('resume of change stream') && message.includes('not possible')) {
+            return true;
+        }
+        return false;
+    };
+    SubscriptionManager.prototype.isChangeStreamDocumentTooLarge = function (error) {
+        var code = typeof (error === null || error === void 0 ? void 0 : error.code) === 'number' ? error.code : null;
+        var codeName = typeof (error === null || error === void 0 ? void 0 : error.codeName) === 'string' ? error.codeName.toLowerCase() : '';
+        var message = typeof (error === null || error === void 0 ? void 0 : error.message) === 'string' ? error.message.toLowerCase() : '';
+        if (code === 10334) {
+            return true;
+        }
+        if (codeName.includes('bsonobjecttoolarge')) {
+            return true;
+        }
+        if (message.includes('bsonobj size') && message.includes('16mb')) {
+            return true;
+        }
+        return false;
+    };
+    SubscriptionManager.prototype.enableLocalOplogFallback = function (reason, error) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, message;
+            var _this = this;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (this._useLocalOplog) {
+                            return [2 /*return*/];
+                        }
+                        this._useLocalOplog = true;
+                        this._oplogMode = 'local';
+                        this._oplogRetryCount = 0;
+                        if (!(this._oplog$ && !this._oplog$.closed)) return [3 /*break*/, 5];
+                        _b.label = 1;
+                    case 1:
+                        _b.trys.push([1, 3, , 4]);
+                        this._oplog$.removeAllListeners();
+                        return [4 /*yield*/, this._oplog$.close()];
+                    case 2:
+                        _b.sent();
+                        return [3 /*break*/, 4];
+                    case 3:
+                        _a = _b.sent();
+                        return [3 /*break*/, 4];
+                    case 4:
+                        this._oplog$ = null;
+                        _b.label = 5;
+                    case 5:
+                        message = typeof (error === null || error === void 0 ? void 0 : error.message) === 'string' ? error.message : '';
+                        console.log(new Date(), 'oplog fallback enabled', reason, message ? "(".concat(message, ")") : '');
+                        this.queueFullResync('oplog-fallback-enabled');
+                        if (this._localOplogResyncIntervalMs > 0 && !this._localOplogResyncTimer) {
+                            this._localOplogResyncTimer = setInterval(function () {
+                                _this.queueFullResync('oplog-fallback-poll');
+                            }, this._localOplogResyncIntervalMs);
+                        }
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    SubscriptionManager.prototype.getUseLocalOplog = function () {
+        return this._useLocalOplog;
+    };
+    SubscriptionManager.prototype.handleMongoReconnect = function (reason) {
+        return __awaiter(this, void 0, void 0, function () {
+            var resumeToken, _a, error_3;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (this._useLocalOplog) {
+                            this.queueFullResync("mongo-reconnect:".concat(reason));
+                            return [2 /*return*/];
+                        }
+                        _b.label = 1;
+                    case 1:
+                        _b.trys.push([1, 5, , 6]);
+                        _a = this._lastResumeToken;
+                        if (_a) return [3 /*break*/, 3];
+                        return [4 /*yield*/, this.loadResumeToken()];
+                    case 2:
+                        _a = (_b.sent());
+                        _b.label = 3;
+                    case 3:
+                        resumeToken = _a;
+                        return [4 /*yield*/, this.tailOpLog(resumeToken || undefined)];
+                    case 4:
+                        _b.sent();
+                        return [3 /*break*/, 6];
+                    case 5:
+                        error_3 = _b.sent();
+                        console.log(new Date(), 'Sub Manager', 'Mongo reconnect: tailOpLog restart failed', reason, error_3);
+                        return [3 /*break*/, 6];
+                    case 6:
+                        this.queueFullResync("mongo-reconnect:".concat(reason));
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    SubscriptionManager.prototype.notifyLocalOplog = function (collection, type) {
+        var _this = this;
+        if (type === void 0) { type = 'update'; }
+        if (!this._useLocalOplog) {
+            return;
+        }
+        setImmediate(function () { return __awaiter(_this, void 0, void 0, function () {
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        _b.trys.push([0, 2, , 3]);
+                        return [4 /*yield*/, this.invalidatePubsCache(collection, type)];
+                    case 1:
+                        _b.sent();
+                        return [3 /*break*/, 3];
+                    case 2:
+                        _a = _b.sent();
+                        return [3 /*break*/, 3];
+                    case 3: return [2 /*return*/];
+                }
+            });
+        }); });
+    };
+    SubscriptionManager.prototype.getResumeTokenDocId = function () {
+        if (process.env.NODE_APP_INSTANCE) {
+            return "oplog:".concat(process.env.NODE_APP_INSTANCE);
+        }
+        // Fallback: avoid cross-process contention when NODE_APP_INSTANCE is not set.
+        return "oplog:".concat(process.pid);
+    };
+    SubscriptionManager.prototype.loadResumeToken = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var db_1, loadToken, mongoManager, _a, error_4;
+            var _this = this;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        _b.trys.push([0, 5, , 6]);
+                        db_1 = resolveio_server_app_1.ResolveIOServer.getMainDB();
+                        if (!db_1) {
+                            return [2 /*return*/, null];
+                        }
+                        loadToken = function () { return __awaiter(_this, void 0, void 0, function () {
+                            var collection, doc, token, maxAgeMs, ageMs;
+                            return __generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0:
+                                        collection = db_1.collection(this.RESUME_TOKEN_COLLECTION);
+                                        return [4 /*yield*/, collection.findOne({ _id: this.getResumeTokenDocId() })];
+                                    case 1:
+                                        doc = _a.sent();
+                                        token = (doc === null || doc === void 0 ? void 0 : doc.token) || null;
+                                        if (!token) {
+                                            return [2 /*return*/, null];
+                                        }
+                                        maxAgeMs = this.resolveResumeTokenMaxAgeMs();
+                                        if (!(maxAgeMs > 0 && (doc === null || doc === void 0 ? void 0 : doc.updatedAt) instanceof Date)) return [3 /*break*/, 3];
+                                        ageMs = Date.now() - doc.updatedAt.getTime();
+                                        if (!(ageMs > maxAgeMs)) return [3 /*break*/, 3];
+                                        return [4 /*yield*/, collection.deleteOne({ _id: this.getResumeTokenDocId() })];
+                                    case 2:
+                                        _a.sent();
+                                        console.log(new Date(), 'Sub Manager', 'Resume token expired, clearing', (0, common_1.round)(ageMs / 1000), 's');
+                                        return [2 /*return*/, null];
+                                    case 3: return [2 /*return*/, token];
+                                }
+                            });
+                        }); };
+                        mongoManager = resolveio_server_app_1.ResolveIOServer.getMongoManager();
+                        if (!mongoManager) return [3 /*break*/, 2];
+                        return [4 /*yield*/, mongoManager.runWithoutSession(loadToken)];
+                    case 1:
+                        _a = _b.sent();
+                        return [3 /*break*/, 4];
+                    case 2: return [4 /*yield*/, loadToken()];
+                    case 3:
+                        _a = _b.sent();
+                        _b.label = 4;
+                    case 4: return [2 /*return*/, _a];
+                    case 5:
+                        error_4 = _b.sent();
+                        console.log(new Date(), 'Sub Manager', 'Failed to load oplog resume token', error_4);
+                        return [2 /*return*/, null];
+                    case 6: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    SubscriptionManager.prototype.saveResumeToken = function (token) {
+        return __awaiter(this, void 0, void 0, function () {
+            var db_2, saveToken, mongoManager, error_5;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!token) {
+                            return [2 /*return*/];
+                        }
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, 6, , 7]);
+                        db_2 = resolveio_server_app_1.ResolveIOServer.getMainDB();
+                        if (!db_2) {
+                            return [2 /*return*/];
+                        }
+                        saveToken = function () { return __awaiter(_this, void 0, void 0, function () {
+                            return __generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0: return [4 /*yield*/, db_2.collection(this.RESUME_TOKEN_COLLECTION).updateOne({ _id: this.getResumeTokenDocId() }, { $set: { token: token, updatedAt: new Date() } }, { upsert: true })];
+                                    case 1:
+                                        _a.sent();
+                                        return [2 /*return*/];
+                                }
+                            });
+                        }); };
+                        mongoManager = resolveio_server_app_1.ResolveIOServer.getMongoManager();
+                        if (!mongoManager) return [3 /*break*/, 3];
+                        return [4 /*yield*/, mongoManager.runWithoutSession(saveToken)];
+                    case 2:
+                        _a.sent();
+                        return [3 /*break*/, 5];
+                    case 3: return [4 /*yield*/, saveToken()];
+                    case 4:
+                        _a.sent();
+                        _a.label = 5;
+                    case 5: return [3 /*break*/, 7];
+                    case 6:
+                        error_5 = _a.sent();
+                        console.log(new Date(), 'Sub Manager', 'Failed to persist oplog resume token', error_5);
+                        return [3 /*break*/, 7];
+                    case 7: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    SubscriptionManager.prototype.clearResumeToken = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var db_3, clearToken, mongoManager, error_6;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 5, , 6]);
+                        db_3 = resolveio_server_app_1.ResolveIOServer.getMainDB();
+                        if (!db_3) {
+                            return [2 /*return*/];
+                        }
+                        clearToken = function () { return __awaiter(_this, void 0, void 0, function () {
+                            return __generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0: return [4 /*yield*/, db_3.collection(this.RESUME_TOKEN_COLLECTION)
+                                            .deleteOne({ _id: this.getResumeTokenDocId() })];
+                                    case 1:
+                                        _a.sent();
+                                        return [2 /*return*/];
+                                }
+                            });
+                        }); };
+                        mongoManager = resolveio_server_app_1.ResolveIOServer.getMongoManager();
+                        if (!mongoManager) return [3 /*break*/, 2];
+                        return [4 /*yield*/, mongoManager.runWithoutSession(clearToken)];
+                    case 1:
+                        _a.sent();
+                        return [3 /*break*/, 4];
+                    case 2: return [4 /*yield*/, clearToken()];
+                    case 3:
+                        _a.sent();
+                        _a.label = 4;
+                    case 4: return [3 /*break*/, 6];
+                    case 5:
+                        error_6 = _a.sent();
+                        console.log(new Date(), 'Sub Manager', 'Failed to clear oplog resume token', error_6);
+                        return [3 /*break*/, 6];
+                    case 6: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    SubscriptionManager.prototype.queueResumeTokenSave = function (token, options) {
+        var _this = this;
+        if (!token) {
+            return;
+        }
+        this._lastResumeToken = token;
+        var now = Date.now();
+        var shouldSave = !!(options === null || options === void 0 ? void 0 : options.force) || (now - this._lastResumeTokenSaveMs) >= this.RESUME_TOKEN_SAVE_INTERVAL_MS;
+        if (!shouldSave) {
+            return;
+        }
+        if (this._resumeTokenSavePromise !== null) {
+            if (options === null || options === void 0 ? void 0 : options.force) {
+                this._resumeTokenSaveForcePending = true;
+            }
+            return;
+        }
+        this._lastResumeTokenSaveMs = now;
+        var tokenToSave = this._lastResumeToken;
+        this._resumeTokenSavePromise = (function () { return __awaiter(_this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, , 2, 3]);
+                        return [4 /*yield*/, this.saveResumeToken(tokenToSave)];
+                    case 1:
+                        _a.sent();
+                        return [3 /*break*/, 3];
+                    case 2:
+                        this._resumeTokenSavePromise = null;
+                        if (this._resumeTokenSaveForcePending) {
+                            this._resumeTokenSaveForcePending = false;
+                            this.queueResumeTokenSave(this._lastResumeToken, { force: true });
+                        }
+                        return [7 /*endfinally*/];
+                    case 3: return [2 /*return*/];
+                }
+            });
+        }); })();
+    };
+    SubscriptionManager.prototype.queueFullResync = function (reason) {
+        var _this = this;
+        if (this._fullResyncPromise !== null) {
+            return;
+        }
+        this._fullResyncPromise = (function () { return __awaiter(_this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, , 2, 3]);
+                        return [4 /*yield*/, this.fullResyncSubscriptions(reason)];
+                    case 1:
+                        _a.sent();
+                        return [3 /*break*/, 3];
+                    case 2:
+                        this._fullResyncPromise = null;
+                        return [7 /*endfinally*/];
+                    case 3: return [2 /*return*/];
+                }
+            });
+        }); })();
+    };
+    SubscriptionManager.prototype.fullResyncSubscriptions = function (reason) {
+        return __awaiter(this, void 0, void 0, function () {
+            var subs, subs_1, subs_1_1, sub, pub, _a, _b, client, ws, _c, e_4_1, e_5_1, error_7;
+            var e_5, _d, e_4, _e;
+            var _f, _g, _h, _j, _k;
+            return __generator(this, function (_l) {
+                switch (_l.label) {
+                    case 0:
+                        _l.trys.push([0, 20, , 21]);
+                        if (this._enableDebug) {
+                            console.log(new Date(), 'Sub Manager', 'Full subscription resync', reason, this._subscriptions.length);
+                        }
+                        try {
+                            (_g = (_f = resolveio_server_app_1.ResolveIOServer.getMongoManager()) === null || _f === void 0 ? void 0 : _f.clearQueryCache) === null || _g === void 0 ? void 0 : _g.call(_f, reason);
+                        }
+                        catch (_m) {
+                            // ignore cache-clear errors
+                        }
+                        try {
+                            (_j = (_h = this._nodeCache) === null || _h === void 0 ? void 0 : _h.flushAll) === null || _j === void 0 ? void 0 : _j.call(_h);
+                        }
+                        catch (_o) {
+                            // ignore cache-clear errors
+                        }
+                        subs = this._subscriptions.slice();
+                        _l.label = 1;
+                    case 1:
+                        _l.trys.push([1, 17, 18, 19]);
+                        subs_1 = __values(subs), subs_1_1 = subs_1.next();
+                        _l.label = 2;
+                    case 2:
+                        if (!!subs_1_1.done) return [3 /*break*/, 16];
+                        sub = subs_1_1.value;
+                        if (!((_k = sub === null || sub === void 0 ? void 0 : sub.clients) === null || _k === void 0 ? void 0 : _k.length)) {
+                            return [3 /*break*/, 15];
+                        }
+                        pub = this._publications[sub.publication];
+                        if (!pub) {
+                            return [3 /*break*/, 15];
+                        }
+                        if (sub.running) {
+                            sub.runAgain = true;
+                            return [3 /*break*/, 15];
+                        }
+                        if (!pub.user_specific) return [3 /*break*/, 13];
+                        _l.label = 3;
+                    case 3:
+                        _l.trys.push([3, 10, 11, 12]);
+                        _a = (e_4 = void 0, __values(sub.clients)), _b = _a.next();
+                        _l.label = 4;
+                    case 4:
+                        if (!!_b.done) return [3 /*break*/, 9];
+                        client = _b.value;
+                        ws = this._websocketManager.getWebSocket(client.id_socket);
+                        if (!((ws === null || ws === void 0 ? void 0 : ws.readyState) === WebSocket.OPEN)) return [3 /*break*/, 8];
+                        _l.label = 5;
+                    case 5:
+                        _l.trys.push([5, 7, , 8]);
+                        return [4 /*yield*/, this.sendDataToOneWithRetry(ws, client.messageId, sub, '', reason)];
+                    case 6:
+                        _l.sent();
+                        return [3 /*break*/, 8];
+                    case 7:
+                        _c = _l.sent();
+                        return [3 /*break*/, 8];
+                    case 8:
+                        _b = _a.next();
+                        return [3 /*break*/, 4];
+                    case 9: return [3 /*break*/, 12];
+                    case 10:
+                        e_4_1 = _l.sent();
+                        e_4 = { error: e_4_1 };
+                        return [3 /*break*/, 12];
+                    case 11:
+                        try {
+                            if (_b && !_b.done && (_e = _a.return)) _e.call(_a);
+                        }
+                        finally { if (e_4) throw e_4.error; }
+                        return [7 /*endfinally*/];
+                    case 12: return [3 /*break*/, 15];
+                    case 13: return [4 /*yield*/, this.sendDataToAllWithRetry(sub, '', reason)];
+                    case 14:
+                        _l.sent();
+                        _l.label = 15;
+                    case 15:
+                        subs_1_1 = subs_1.next();
+                        return [3 /*break*/, 2];
+                    case 16: return [3 /*break*/, 19];
+                    case 17:
+                        e_5_1 = _l.sent();
+                        e_5 = { error: e_5_1 };
+                        return [3 /*break*/, 19];
+                    case 18:
+                        try {
+                            if (subs_1_1 && !subs_1_1.done && (_d = subs_1.return)) _d.call(subs_1);
+                        }
+                        finally { if (e_5) throw e_5.error; }
+                        return [7 /*endfinally*/];
+                    case 19: return [3 /*break*/, 21];
+                    case 20:
+                        error_7 = _l.sent();
+                        console.log(new Date(), 'Sub Manager', 'Full resync failed', reason, error_7);
+                        return [3 /*break*/, 21];
+                    case 21: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    // Watch (tail) Mongo's operation log on the entire database (all insert/modify/delete will trigger this function)
+    SubscriptionManager.prototype.tailOpLog = function (resumeToken) {
+        return __awaiter(this, void 0, void 0, function () {
+            var watchDatabases, pipeline, lastResumeToken_1, startedWithResumeToken_1, sawChangeEvent_1, resumeTokenInvalidated_1, streamStartedAtMs_1, error_8, innerError_1, error_9;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (this._useLocalOplog) {
+                            return [2 /*return*/];
+                        }
+                        if (!(this._oplog$ && !this._oplog$.closed)) return [3 /*break*/, 2];
+                        this._oplog$.removeAllListeners();
+                        return [4 /*yield*/, this._oplog$.close()];
+                    case 1:
+                        _a.sent();
+                        this._oplog$ = null;
+                        _a.label = 2;
+                    case 2: 
+                    // eslint-disable-next-line no-restricted-syntax
+                    return [4 /*yield*/, new Promise(function (resolve) { return setTimeout(resolve, 1000); })];
+                    case 3:
+                        // eslint-disable-next-line no-restricted-syntax
+                        _a.sent();
+                        if (!(!this._oplog$ || this._oplog$.closed)) return [3 /*break*/, 27];
+                        this._oplogRetryCount += 1;
+                        if (this._oplogRetryCount > 5) {
+                            console.error('****************** TAIL OPLOG ERROR, RETRYING A BUNCH OF TIMES, KILLING PROCESS **************************');
+                            process.exit(1);
+                        }
+                        watchDatabases = this.getWatchedDatabases();
+                        pipeline = [
+                            {
+                                $match: {
+                                    $and: __spreadArray(__spreadArray([], __read((watchDatabases.length ? [{ 'ns.db': { $in: watchDatabases } }] : [])), false), [
+                                        { 'ns.coll': { $nin: [
+                                                    'log-method-latencies',
+                                                    'log-subscriptions',
+                                                    'logs',
+                                                    'counters',
+                                                    'cron-job-histories',
+                                                    'email-histories',
+                                                    'qb-soap-request-histories',
+                                                    'qb-soap-request-responses',
+                                                    'qb-soap-requests',
+                                                    'qb-soap-retries',
+                                                    this.RESUME_TOKEN_COLLECTION
+                                                ] } },
+                                        { 'ns.coll': { $not: /.*\.versions$/ } },
+                                        { 'ns.coll': { $not: /^monitor-/ } },
+                                    ], false)
+                                },
+                            },
+                        ];
+                        startedWithResumeToken_1 = false;
+                        sawChangeEvent_1 = false;
+                        resumeTokenInvalidated_1 = false;
+                        streamStartedAtMs_1 = Date.now();
+                        if (!resumeToken) return [3 /*break*/, 20];
+                        lastResumeToken_1 = resumeToken;
+                        _a.label = 4;
+                    case 4:
+                        _a.trys.push([4, 5, , 19]);
+                        this._oplog$ = resolveio_server_app_1.ResolveIOServer.getMongoConnection().watch(pipeline, { resumeAfter: resumeToken, fullDocument: 'updateLookup' });
+                        startedWithResumeToken_1 = true;
+                        return [3 /*break*/, 19];
+                    case 5:
+                        error_8 = _a.sent();
+                        if (!this.isChangeStreamUnsupported(error_8)) return [3 /*break*/, 7];
+                        return [4 /*yield*/, this.enableLocalOplogFallback('change-stream-unsupported', error_8)];
+                    case 6:
+                        _a.sent();
+                        return [2 /*return*/];
+                    case 7:
+                        if (!this.isChangeStreamDocumentTooLarge(error_8)) return [3 /*break*/, 10];
+                        return [4 /*yield*/, this.clearResumeToken()];
+                    case 8:
+                        _a.sent();
+                        lastResumeToken_1 = null;
+                        this.queueFullResync('oplog-change-stream-document-too-large');
+                        return [4 /*yield*/, this.enableLocalOplogFallback('change-stream-document-too-large', error_8)];
+                    case 9:
+                        _a.sent();
+                        return [2 /*return*/];
+                    case 10:
+                        if (!this._oplog$) return [3 /*break*/, 12];
+                        this._oplog$.removeAllListeners();
+                        return [4 /*yield*/, this._oplog$.close()];
+                    case 11:
+                        _a.sent();
+                        this._oplog$ = null;
+                        _a.label = 12;
+                    case 12: return [4 /*yield*/, this.clearResumeToken()];
+                    case 13:
+                        _a.sent();
+                        lastResumeToken_1 = null;
+                        console.log(new Date(), 'oplog resumeAfter failed, starting fresh', error_8);
+                        _a.label = 14;
+                    case 14:
+                        _a.trys.push([14, 15, , 18]);
+                        this._oplog$ = resolveio_server_app_1.ResolveIOServer.getMongoConnection().watch(pipeline, { fullDocument: 'updateLookup' });
+                        startedWithResumeToken_1 = false;
+                        return [3 /*break*/, 18];
+                    case 15:
+                        innerError_1 = _a.sent();
+                        if (!this.isChangeStreamUnsupported(innerError_1)) return [3 /*break*/, 17];
+                        return [4 /*yield*/, this.enableLocalOplogFallback('change-stream-unsupported', innerError_1)];
+                    case 16:
+                        _a.sent();
+                        return [2 /*return*/];
+                    case 17: throw innerError_1;
+                    case 18:
+                        this.queueFullResync('oplog-resumeAfter-failed');
+                        return [3 /*break*/, 19];
+                    case 19: return [3 /*break*/, 26];
+                    case 20:
+                        _a.trys.push([20, 21, , 26]);
+                        this._oplog$ = resolveio_server_app_1.ResolveIOServer.getMongoConnection().watch(pipeline, { fullDocument: 'updateLookup' });
+                        return [3 /*break*/, 26];
+                    case 21:
+                        error_9 = _a.sent();
+                        if (!this.isChangeStreamUnsupported(error_9)) return [3 /*break*/, 23];
+                        return [4 /*yield*/, this.enableLocalOplogFallback('change-stream-unsupported', error_9)];
+                    case 22:
+                        _a.sent();
+                        return [2 /*return*/];
+                    case 23:
+                        if (!this.isChangeStreamDocumentTooLarge(error_9)) return [3 /*break*/, 25];
+                        return [4 /*yield*/, this.enableLocalOplogFallback('change-stream-document-too-large', error_9)];
+                    case 24:
+                        _a.sent();
+                        return [2 /*return*/];
+                    case 25: throw error_9;
+                    case 26:
+                        console.log(new Date(), 'oplog started', startedWithResumeToken_1 ? '(resumeAfter)' : '');
+                        this._oplog$.on('change', function (doc) { return __awaiter(_this, void 0, void 0, function () {
+                            var collection, fullDocument, docId, flag, dependencyFlag;
+                            return __generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0:
+                                        sawChangeEvent_1 = true;
+                                        this._oplogRetryCount = 0;
+                                        if (!doc.ns) return [3 /*break*/, 14];
+                                        if (this._enableDebug) {
+                                            console.log(new Date(), 'Oplog Hit', doc.ns);
+                                        }
+                                        collection = doc.ns.coll;
+                                        if (!this._debugOplogCollections.some(function (a) { return a.collection === doc.ns.coll && a.type === doc.operationType; })) {
+                                            this._debugOplogCollections.push({
+                                                collection: doc.ns.coll,
+                                                type: doc.operationType,
+                                                hits: 1
+                                            });
+                                        }
+                                        else {
+                                            this._debugOplogCollections.find(function (a) { return a.collection === doc.ns.coll && a.type === doc.operationType; }).hits += 1;
+                                        }
+                                        if (!collection) return [3 /*break*/, 10];
+                                        this._debugOplogHits += 1;
+                                        fullDocument = doc['fullDocument'];
+                                        docId = doc.documentKey && doc.documentKey['_id'] !== undefined ? doc.documentKey['_id'] : (fullDocument && fullDocument['_id'] !== undefined ? fullDocument['_id'] : null);
+                                        if (!(doc.operationType === 'insert')) return [3 /*break*/, 5];
+                                        if (!(collection === 'support-tickets')) return [3 /*break*/, 2];
+                                        if (!(this.serverConfig['ROOT_URL'] === 'https://resolveio.com')) return [3 /*break*/, 2];
+                                        resolveio_server_app_1.ResolveIOServer.getMainServer().getMethodManager().callMethod.call(resolveio_server_app_1.ResolveIOServer.getMainServer().getMethodManager(), 'sendSupportTicketEmail', doc.documentKey['_id']);
+                                        return [4 /*yield*/, this.invalidatePubsCache(collection, 'insert', docId, fullDocument)];
+                                    case 1:
+                                        _a.sent();
+                                        _a.label = 2;
+                                    case 2:
+                                        if (!(collection !== 'method-responses')) return [3 /*break*/, 4];
+                                        return [4 /*yield*/, this.invalidatePubsCache(collection, 'insert', docId, fullDocument)];
+                                    case 3:
+                                        _a.sent();
+                                        _a.label = 4;
+                                    case 4: return [3 /*break*/, 10];
+                                    case 5:
+                                        if (!(doc.operationType === 'update' || doc.operationType === 'replace')) return [3 /*break*/, 8];
+                                        if (!(collection !== 'method-responses')) return [3 /*break*/, 7];
+                                        return [4 /*yield*/, this.invalidatePubsCache(collection, 'update', docId, fullDocument)];
+                                    case 6:
+                                        _a.sent();
+                                        _a.label = 7;
+                                    case 7: return [3 /*break*/, 10];
+                                    case 8:
+                                        if (!(doc.operationType === 'delete')) return [3 /*break*/, 10];
+                                        if (!(collection !== 'method-responses')) return [3 /*break*/, 10];
+                                        return [4 /*yield*/, this.invalidatePubsCache(collection, 'delete', docId)];
+                                    case 9:
+                                        _a.sent();
+                                        _a.label = 10;
+                                    case 10:
+                                        if (!(collection === 'flags')) return [3 /*break*/, 13];
+                                        return [4 /*yield*/, flag_collection_1.Flags.findOne({ type: 'Enable Debug' })];
+                                    case 11:
+                                        flag = _a.sent();
+                                        return [4 /*yield*/, flag_collection_1.Flags.findOne({ type: 'Enable Dependency Debug' })];
+                                    case 12:
+                                        dependencyFlag = _a.sent();
+                                        if (flag && flag.value) {
+                                            this._enableDebug = true;
+                                        }
+                                        else {
+                                            this._enableDebug = false;
+                                        }
+                                        if (dependencyFlag && dependencyFlag.value) {
+                                            this._enableDependencyDebug = true;
+                                        }
+                                        else {
+                                            this._enableDependencyDebug = process.env.ENABLE_DEPENDENCY_DEBUG === 'true';
+                                        }
+                                        _a.label = 13;
+                                    case 13:
+                                        lastResumeToken_1 = doc._id;
+                                        this.queueResumeTokenSave(lastResumeToken_1);
+                                        if ((!process.env.NODE_APP_INSTANCE || process.env.NODE_APP_INSTANCE === '0') && (process.env.IS_WORKERS_ENABLED === 'false' || (process.env.IS_WORKER_INSTANCE === 'true' && process.env.WORKER_INDEX === '0'))) {
+                                        }
+                                        _a.label = 14;
+                                    case 14: return [2 /*return*/];
+                                }
+                            });
+                        }); });
+                        this._oplog$.on('error', function (error) { return __awaiter(_this, void 0, void 0, function () {
+                            return __generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0:
+                                        console.log(new Date(), 'oplog error', error);
+                                        if (!this.isChangeStreamUnsupported(error)) return [3 /*break*/, 2];
+                                        return [4 /*yield*/, this.enableLocalOplogFallback('change-stream-unsupported', error)];
+                                    case 1:
+                                        _a.sent();
+                                        return [2 /*return*/];
+                                    case 2:
+                                        if (!this.isChangeStreamDocumentTooLarge(error)) return [3 /*break*/, 5];
+                                        return [4 /*yield*/, this.clearResumeToken()];
+                                    case 3:
+                                        _a.sent();
+                                        lastResumeToken_1 = null;
+                                        this.queueFullResync('oplog-change-stream-document-too-large');
+                                        return [4 /*yield*/, this.enableLocalOplogFallback('change-stream-document-too-large', error)];
+                                    case 4:
+                                        _a.sent();
+                                        return [2 /*return*/];
+                                    case 5:
+                                        if (!this.isResumeTokenInvalid(error)) return [3 /*break*/, 7];
+                                        resumeTokenInvalidated_1 = true;
+                                        return [4 /*yield*/, this.clearResumeToken()];
+                                    case 6:
+                                        _a.sent();
+                                        lastResumeToken_1 = null;
+                                        this.queueFullResync('oplog-resume-token-invalid');
+                                        _a.label = 7;
+                                    case 7: return [4 /*yield*/, this._oplog$.close()];
+                                    case 8:
+                                        _a.sent();
+                                        return [2 /*return*/];
+                                }
+                            });
+                        }); });
+                        this._oplog$.on('end', function () { return __awaiter(_this, void 0, void 0, function () {
+                            return __generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0:
+                                        console.log(new Date(), 'oplog end');
+                                        return [4 /*yield*/, this._oplog$.close()];
+                                    case 1:
+                                        _a.sent();
+                                        return [2 /*return*/];
+                                }
+                            });
+                        }); });
+                        this._oplog$.on('close', function () { return __awaiter(_this, void 0, void 0, function () {
+                            var retryThresholdReached, shouldAutoHealResumeToken;
+                            return __generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0:
+                                        console.log(new Date(), 'oplog close');
+                                        retryThresholdReached = this._oplogRetryCount >= this.RESUME_TOKEN_AUTO_HEAL_RETRY_THRESHOLD;
+                                        shouldAutoHealResumeToken = startedWithResumeToken_1
+                                            && !!lastResumeToken_1
+                                            && !sawChangeEvent_1
+                                            && (resumeTokenInvalidated_1 || retryThresholdReached);
+                                        if (!shouldAutoHealResumeToken) return [3 /*break*/, 2];
+                                        return [4 /*yield*/, this.clearResumeToken()];
+                                    case 1:
+                                        _a.sent();
+                                        lastResumeToken_1 = null;
+                                        if (!resumeTokenInvalidated_1) {
+                                            this.queueFullResync('oplog-resume-token-auto-heal');
+                                        }
+                                        console.log(new Date(), 'Sub Manager', 'Auto-healed stale oplog resume token', { retryCount: this._oplogRetryCount, streamLifetimeMs: Date.now() - streamStartedAtMs_1 });
+                                        _a.label = 2;
+                                    case 2:
+                                        if (lastResumeToken_1) {
+                                            this.queueResumeTokenSave(lastResumeToken_1, { force: true });
+                                        }
+                                        this._oplog$.removeAllListeners();
+                                        this._oplog$ = null;
+                                        return [4 /*yield*/, this.tailOpLog(lastResumeToken_1)];
+                                    case 3:
+                                        _a.sent();
+                                        return [2 /*return*/];
+                                }
+                            });
+                        }); });
+                        _a.label = 27;
+                    case 27: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    SubscriptionManager.prototype.packCachePayload = function (data) {
+        if (data === undefined) {
+            return null;
+        }
+        try {
+            var packed = (0, msgpackr_1.pack)(data);
+            return Buffer.isBuffer(packed) ? packed : Buffer.from(packed);
+        }
+        catch (err) {
+            if (this._enableDebug) {
+                console.log(new Date(), 'Sub Cache', 'Pack Failed', (err === null || err === void 0 ? void 0 : err.message) || err);
+            }
+            return null;
+        }
+    };
+    SubscriptionManager.prototype.decodeCachePayload = function (raw) {
+        if (!raw) {
+            return null;
+        }
+        if (Buffer.isBuffer(raw)) {
+            try {
+                return (0, msgpackr_1.unpack)(raw);
+            }
+            catch (err) {
+                if (this._enableDebug) {
+                    console.log(new Date(), 'Sub Cache', 'Unpack Failed', (err === null || err === void 0 ? void 0 : err.message) || err);
+                }
+                return null;
+            }
+        }
+        if (raw instanceof Uint8Array) {
+            try {
+                return (0, msgpackr_1.unpack)(raw);
+            }
+            catch (err) {
+                if (this._enableDebug) {
+                    console.log(new Date(), 'Sub Cache', 'Unpack Failed', (err === null || err === void 0 ? void 0 : err.message) || err);
+                }
+                return null;
+            }
+        }
+        if (raw instanceof ArrayBuffer) {
+            try {
+                return (0, msgpackr_1.unpack)(new Uint8Array(raw));
+            }
+            catch (err) {
+                if (this._enableDebug) {
+                    console.log(new Date(), 'Sub Cache', 'Unpack Failed', (err === null || err === void 0 ? void 0 : err.message) || err);
+                }
+                return null;
+            }
+        }
+        // Treat legacy string caches as invalid to avoid JSON parsing in the hot path.
+        if (typeof raw === 'string') {
+            return null;
+        }
+        return raw;
+    };
+    SubscriptionManager.prototype.getCacheBuffer = function (raw) {
+        if (!raw) {
+            return null;
+        }
+        if (Buffer.isBuffer(raw)) {
+            return raw;
+        }
+        if (raw instanceof Uint8Array) {
+            return Buffer.from(raw);
+        }
+        if (raw instanceof ArrayBuffer) {
+            return Buffer.from(new Uint8Array(raw));
+        }
+        return null;
+    };
+    SubscriptionManager.prototype.shouldCachePayload = function (sub, payload) {
+        if (!payload || payload.byteLength >= 1000000) {
+            return false;
+        }
+        if (sub.collections.includes('logs')) {
+            return false;
+        }
+        if (sub.collections.find(function (a) { return a.endsWith('.versions'); })) {
+            return false;
+        }
+        if (sub.collections.find(function (a) { return a.startsWith('monitor-'); })) {
+            return false;
+        }
+        return true;
+    };
+    SubscriptionManager.prototype.buffersEqual = function (a, b) {
+        if (!a || !b) {
+            return false;
+        }
+        if (a.byteLength !== b.byteLength) {
+            return false;
+        }
+        var toBuffer = function (value) {
+            if (Buffer.isBuffer(value)) {
+                return value;
+            }
+            var buffer = value.buffer;
+            return Buffer.from(buffer, value.byteOffset, value.byteLength);
+        };
+        var aBuf = toBuffer(a);
+        var bBuf = toBuffer(b);
+        return aBuf.equals(bBuf);
+    };
+    SubscriptionManager.prototype.processSubscription = function (sub, ws, messageId) {
+        return __awaiter(this, void 0, void 0, function () {
+            var cachedRaw, cachedBuffer, cacheData, serverRes, _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (!!this._publications[sub.publication].user_specific) return [3 /*break*/, 8];
+                        if (!sub.cacheId) return [3 /*break*/, 5];
+                        _b.label = 1;
+                    case 1:
+                        _b.trys.push([1, 2, , 4]);
+                        cachedRaw = this._nodeCache.get(sub.cacheId);
+                        cachedBuffer = this.getCacheBuffer(cachedRaw);
+                        if (cachedBuffer && cachedBuffer.byteLength) {
+                            if (this._enableDebug) {
+                                console.log(new Date(), 'Process Sub, Cache (packed)', sub.publication);
+                            }
+                            this._websocketManager.sendPackedBuffer(ws, messageId, false, cachedBuffer, 'msgpack');
+                            this.logAiSubSend({
+                                publication: sub.publication,
+                                subscriptionKey: sub.subscriptionKey,
+                                messageId: messageId,
+                                id_socket: ws['id_socket'],
+                                clients: 1,
+                                payloadBytes: cachedBuffer.byteLength,
+                                packed: true,
+                                cacheHit: true,
+                                collection: '',
+                                type: 'cache',
+                                subscriptionData: sub.subscriptionData
+                            });
+                        }
+                        else {
+                            cacheData = this.decodeCachePayload(cachedRaw);
+                            if (cacheData === null || cacheData === undefined) {
+                                throw new Error('cache-miss');
+                            }
+                            serverRes = {
+                                messageId: messageId,
+                                hasError: false,
+                                data: cacheData
+                            };
+                            if (this._enableDebug) {
+                                console.log(new Date(), 'Process Sub, Cache', sub.publication);
+                            }
+                            this.sendWS(ws, serverRes);
+                            this.logAiSubSend({
+                                publication: sub.publication,
+                                subscriptionKey: sub.subscriptionKey,
+                                messageId: messageId,
+                                id_socket: ws['id_socket'],
+                                clients: 1,
+                                payloadBytes: cacheData ? Buffer.byteLength(JSON.stringify(cacheData)) : null,
+                                packed: false,
+                                cacheHit: true,
+                                collection: '',
+                                type: 'cache',
+                                subscriptionData: sub.subscriptionData
+                            });
+                        }
+                        return [3 /*break*/, 4];
+                    case 2:
+                        _a = _b.sent();
+                        this._nodeCache.del(sub.cacheId);
+                        sub.cacheId = 0;
+                        return [4 /*yield*/, this.sendDataToAllWithRetry(sub, '', 'newSub')];
+                    case 3:
+                        _b.sent();
+                        return [3 /*break*/, 4];
+                    case 4: return [3 /*break*/, 7];
+                    case 5:
+                        if (this._enableDebug) {
+                            console.log(new Date(), 'Process Sub, Non - Cache', sub.publication, sub.running);
+                        }
+                        if (sub.running) {
+                            return [2 /*return*/];
+                        }
+                        return [4 /*yield*/, this.sendDataToAllWithRetry(sub, '', 'newSub')];
+                    case 6:
+                        _b.sent();
+                        _b.label = 7;
+                    case 7: return [3 /*break*/, 10];
+                    case 8:
+                        if (this._enableDebug) {
+                            console.log(new Date(), 'Process Sub Specific, Non - Cache', sub.publication, sub.running);
+                        }
+                        if (sub.running) {
+                            return [2 /*return*/];
+                        }
+                        return [4 /*yield*/, this.sendDataToOneWithRetry(ws, messageId, sub, '', 'newSub')];
+                    case 9:
+                        _b.sent();
+                        _b.label = 10;
+                    case 10: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    SubscriptionManager.prototype.sendDataToOne = function (ws, messageId, sub, collection, type) {
+        return __awaiter(this, void 0, void 0, function () {
+            var monitor, dependencySnapshot, res, execution, packedRes, payloadBytes, serverRes, err_1, _a, normalizedError, correlationId, serverRes, errorPayload;
+            var _b, _c;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        if (!ws || ws.readyState !== WebSocket.OPEN) {
+                            return [2 /*return*/];
+                        }
+                        monitor = this._monitorManagerFunction.startMonitorFunction('User Specific Publication', sub.publication, '', '', sub.subscriptionData);
+                        _d.label = 1;
+                    case 1:
+                        _d.trys.push([1, 3, 5, 7]);
+                        resolveio_server_app_1.ResolveIOServer.getMainServer().getMethodManager().callMethod.call(resolveio_server_app_1.ResolveIOServer.getMainServer().getMethodManager(), 'insertSubscriptionLog', type, sub.publication, collection, JSON.stringify(sub.subscriptionData));
+                        return [4 /*yield*/, this.runPublicationExecution(sub, ws['id_user'])];
+                    case 2:
+                        execution = _d.sent();
+                        res = execution.result;
+                        dependencySnapshot = execution.snapshot;
+                        this.updateSubscriptionDependencies(sub, dependencySnapshot);
+                        packedRes = (_b = execution.packedResult) !== null && _b !== void 0 ? _b : this.packCachePayload(res);
+                        payloadBytes = packedRes ? packedRes.byteLength : null;
+                        if (execution.packedResult) {
+                            this._websocketManager.sendPackedBuffer(ws, messageId, false, execution.packedResult, execution.encoding || 'msgpack', { passThrough: !!execution.workerUsed });
+                        }
+                        else {
+                            serverRes = {
+                                messageId: messageId,
+                                hasError: false,
+                                data: res
+                            };
+                            this.sendWS(ws, serverRes);
+                        }
+                        this.logAiSubSend({
+                            publication: sub.publication,
+                            subscriptionKey: sub.subscriptionKey,
+                            messageId: messageId,
+                            id_socket: ws['id_socket'],
+                            clients: 1,
+                            payloadBytes: payloadBytes,
+                            packed: !!execution.packedResult,
+                            cacheHit: false,
+                            collection: collection,
+                            type: type,
+                            subscriptionData: sub.subscriptionData
+                        });
+                        return [3 /*break*/, 7];
+                    case 3:
+                        err_1 = _d.sent();
+                        _a = (0, error_tracking_1.ensureErrorWithCorrelation)(err_1), normalizedError = _a.error, correlationId = _a.correlationId;
+                        serverRes = {
+                            messageId: messageId,
+                            hasError: true,
+                            data: Object.assign({}, normalizedError, { correlationId: correlationId })
+                        };
+                        this.sendWS(ws, serverRes);
+                        errorPayload = {
+                            publication: sub.publication,
+                            subscriptionData: sub.subscriptionData,
+                            type: type,
+                            collection: collection,
+                            messageId: messageId,
+                            correlationId: correlationId,
+                            error: {
+                                name: normalizedError === null || normalizedError === void 0 ? void 0 : normalizedError.name,
+                                message: normalizedError === null || normalizedError === void 0 ? void 0 : normalizedError.message,
+                                stack: normalizedError === null || normalizedError === void 0 ? void 0 : normalizedError.stack,
+                                code: normalizedError === null || normalizedError === void 0 ? void 0 : normalizedError.code,
+                                codeName: normalizedError === null || normalizedError === void 0 ? void 0 : normalizedError.codeName
+                            }
+                        };
+                        return [4 /*yield*/, error_reporter_1.ErrorReporter.report({
+                                sourceApp: 'subscription-manager',
+                                message: 'SERVER - Error Detected - ' + this.serverConfig['CLIENT_NAME'],
+                                environment: (_c = this.serverConfig) === null || _c === void 0 ? void 0 : _c.ROOT_URL,
+                                clientSlug: resolveio_server_app_1.ResolveIOServer.getClientName(),
+                                clientName: this.serverConfig['CLIENT_NAME'],
+                                stack: normalizedError === null || normalizedError === void 0 ? void 0 : normalizedError.stack,
+                                context: errorPayload,
+                                metadata: {
+                                    context: 'subscription-sendDataToOne',
+                                    publication: sub.publication,
+                                    correlationId: correlationId
+                                },
+                                correlationId: correlationId
+                            })];
+                    case 4:
+                        _d.sent();
+                        return [3 /*break*/, 7];
+                    case 5: return [4 /*yield*/, this._monitorManagerFunction.finishMonitorFunction(monitor)];
+                    case 6:
+                        _d.sent();
+                        return [7 /*endfinally*/];
+                    case 7: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    // Fetch pub once, send to all clients linked to this pub
+    SubscriptionManager.prototype.sendDataToAll = function (sub, collection, type) {
+        return __awaiter(this, void 0, void 0, function () {
+            var isAiPublication, seenSockets_1, activeClients, _a, _b, client, ws, subIndex, monitor, res, dependencySnapshot, execution, packedRes, passThrough, payloadBytes, shouldCache, cachedBuffer, isSame, sendStartMs, sentClients, activeClients_1, activeClients_1_1, entry, client, ws, serverRes, sendStartMs, sentClients, activeClients_2, activeClients_2_1, entry, client, ws, serverRes, nodeCacheSize, deleteCount, subArr, zz, err_2, _c, normalizedError, correlationId, _d, _e, client, ws, serverRes, errorPayload;
+            var e_6, _f, e_7, _g, e_8, _h, e_9, _j;
+            var _k, _l;
+            return __generator(this, function (_m) {
+                switch (_m.label) {
+                    case 0:
+                        isAiPublication = this.isAiPublication(sub.publication);
+                        if (isAiPublication && sub.clients.length > 1) {
+                            seenSockets_1 = new Set();
+                            sub.clients = sub.clients.filter(function (client) {
+                                if (seenSockets_1.has(client.id_socket)) {
+                                    return false;
+                                }
+                                seenSockets_1.add(client.id_socket);
+                                return true;
+                            });
+                        }
+                        activeClients = [];
+                        if (sub.clients.length) {
+                            try {
+                                for (_a = __values(sub.clients), _b = _a.next(); !_b.done; _b = _a.next()) {
+                                    client = _b.value;
+                                    ws = this._websocketManager.getWebSocket(client.id_socket);
+                                    if (ws && ws.readyState === WebSocket.OPEN) {
+                                        activeClients.push({ client: client, ws: ws });
+                                    }
+                                }
+                            }
+                            catch (e_6_1) { e_6 = { error: e_6_1 }; }
+                            finally {
+                                try {
+                                    if (_b && !_b.done && (_f = _a.return)) _f.call(_a);
+                                }
+                                finally { if (e_6) throw e_6.error; }
+                            }
+                        }
+                        if (!!activeClients.length) return [3 /*break*/, 1];
+                        if (sub.cacheId) {
+                            this._nodeCache.del(sub.cacheId);
+                            sub.cacheId = 0;
+                        }
+                        subIndex = this._subscriptions.findIndex(function (a) { return a.publication === sub.publication && a.subscriptionKey === sub.subscriptionKey; });
+                        if (subIndex >= 0) {
+                            this._subscriptions.splice(subIndex, 1);
+                        }
+                        return [2 /*return*/];
+                    case 1:
+                        if (activeClients.length !== sub.clients.length) {
+                            sub.clients = activeClients.map(function (entry) { return entry.client; });
+                        }
+                        monitor = this._monitorManagerFunction.startMonitorFunction('Publication', sub.publication, '', '', sub.subscriptionData);
+                        res = void 0;
+                        dependencySnapshot = void 0;
+                        _m.label = 2;
+                    case 2:
+                        _m.trys.push([2, 4, 6, 8]);
+                        if (sub.publication !== 'superadminAPM' && sub.publication !== 'loggedInUsers') {
+                            resolveio_server_app_1.ResolveIOServer.getMainServer().getMethodManager().callMethod.call(resolveio_server_app_1.ResolveIOServer.getMainServer().getMethodManager(), 'insertSubscriptionLog', type, sub.publication, collection, JSON.stringify(sub.subscriptionData));
+                        }
+                        return [4 /*yield*/, this.runPublicationExecution(sub)];
+                    case 3:
+                        execution = _m.sent();
+                        res = execution.result;
+                        dependencySnapshot = execution.snapshot;
+                        this.updateSubscriptionDependencies(sub, dependencySnapshot);
+                        packedRes = (_k = execution.packedResult) !== null && _k !== void 0 ? _k : this.packCachePayload(res);
+                        passThrough = !!execution.workerUsed;
+                        payloadBytes = packedRes ? packedRes.byteLength : null;
+                        shouldCache = this.shouldCachePayload(sub, packedRes);
+                        if (sub.cacheId) {
+                            cachedBuffer = this.getCacheBuffer(this._nodeCache.get(sub.cacheId));
+                            isSame = this.buffersEqual(cachedBuffer, packedRes);
+                            if (!isSame) {
+                                sendStartMs = Date.now();
+                                sentClients = 0;
+                                try {
+                                    for (activeClients_1 = __values(activeClients), activeClients_1_1 = activeClients_1.next(); !activeClients_1_1.done; activeClients_1_1 = activeClients_1.next()) {
+                                        entry = activeClients_1_1.value;
+                                        client = entry.client, ws = entry.ws;
+                                        if (packedRes) {
+                                            this._websocketManager.sendPackedBuffer(ws, client.messageId, false, packedRes, execution.encoding || 'msgpack', { passThrough: passThrough });
+                                        }
+                                        else {
+                                            serverRes = {
+                                                messageId: client.messageId,
+                                                hasError: false,
+                                                data: res
+                                            };
+                                            this.sendWS(ws, serverRes);
+                                        }
+                                        if (isAiPublication) {
+                                            this.logAiSubSend({
+                                                publication: sub.publication,
+                                                subscriptionKey: sub.subscriptionKey,
+                                                messageId: client.messageId,
+                                                id_socket: ws['id_socket'],
+                                                clients: activeClients.length,
+                                                payloadBytes: payloadBytes,
+                                                packed: !!packedRes,
+                                                cacheHit: false,
+                                                collection: collection,
+                                                type: type,
+                                                subscriptionData: sub.subscriptionData
+                                            });
+                                        }
+                                        sentClients += 1;
+                                    }
+                                }
+                                catch (e_7_1) { e_7 = { error: e_7_1 }; }
+                                finally {
+                                    try {
+                                        if (activeClients_1_1 && !activeClients_1_1.done && (_g = activeClients_1.return)) _g.call(activeClients_1);
+                                    }
+                                    finally { if (e_7) throw e_7.error; }
+                                }
+                                this.logSubSend(sub, {
+                                    collection: collection,
+                                    type: type,
+                                    clients: sentClients,
+                                    durationMs: Date.now() - sendStartMs,
+                                    payloadBytes: payloadBytes
+                                });
+                                this._nodeCache.del(sub.cacheId);
+                                if (shouldCache) {
+                                    this._nodeCache.set(sub.cacheId, packedRes);
+                                }
+                                else {
+                                    sub.cacheId = 0;
+                                }
+                            }
+                            else if (!cachedBuffer && shouldCache) {
+                                this._nodeCache.set(sub.cacheId, packedRes);
+                            }
+                            else if (!shouldCache) {
+                                this._nodeCache.del(sub.cacheId);
+                                sub.cacheId = 0;
+                            }
+                        }
+                        else {
+                            sendStartMs = Date.now();
+                            sentClients = 0;
+                            try {
+                                for (activeClients_2 = __values(activeClients), activeClients_2_1 = activeClients_2.next(); !activeClients_2_1.done; activeClients_2_1 = activeClients_2.next()) {
+                                    entry = activeClients_2_1.value;
+                                    client = entry.client, ws = entry.ws;
+                                    if (packedRes) {
+                                        this._websocketManager.sendPackedBuffer(ws, client.messageId, false, packedRes, execution.encoding || 'msgpack', { passThrough: passThrough });
+                                    }
+                                    else {
+                                        serverRes = {
+                                            messageId: client.messageId,
+                                            hasError: false,
+                                            data: res
+                                        };
+                                        this.sendWS(ws, serverRes);
+                                    }
+                                    if (isAiPublication) {
+                                        this.logAiSubSend({
+                                            publication: sub.publication,
+                                            subscriptionKey: sub.subscriptionKey,
+                                            messageId: client.messageId,
+                                            id_socket: ws['id_socket'],
+                                            clients: activeClients.length,
+                                            payloadBytes: payloadBytes,
+                                            packed: !!packedRes,
+                                            cacheHit: false,
+                                            collection: collection,
+                                            type: type,
+                                            subscriptionData: sub.subscriptionData
+                                        });
+                                    }
+                                    sentClients += 1;
+                                }
+                            }
+                            catch (e_8_1) { e_8 = { error: e_8_1 }; }
+                            finally {
+                                try {
+                                    if (activeClients_2_1 && !activeClients_2_1.done && (_h = activeClients_2.return)) _h.call(activeClients_2);
+                                }
+                                finally { if (e_8) throw e_8.error; }
+                            }
+                            this.logSubSend(sub, {
+                                collection: collection,
+                                type: type,
+                                clients: sentClients,
+                                durationMs: Date.now() - sendStartMs,
+                                payloadBytes: payloadBytes
+                            });
+                            if (shouldCache) {
+                                sub.cacheId = this._cacheId++;
+                                this._nodeCache.set(sub.cacheId, packedRes);
+                                nodeCacheSize = this._nodeCache.getStats().vsize;
+                                if (nodeCacheSize > this._heapLimit) {
+                                    deleteCount = 0;
+                                    subArr = this._subscriptions.filter(function (a) { return a.cacheId && !a.clients.length; });
+                                    for (zz = 0; zz < subArr.length; zz++) {
+                                        this._debugRemoveCacheHits += 1;
+                                        this._nodeCache.del(subArr[zz].cacheId);
+                                        subArr[zz].cacheId = 0;
+                                        deleteCount += 1;
+                                        if (this._nodeCache.getStats().vsize < this._heapLimit * 0.75) {
+                                            break;
+                                        }
+                                    }
+                                    if (this._enableDebug) {
+                                        console.log('Sub Cache: ' +
+                                            'Too Big - ' +
+                                            sub.publication +
+                                            ' - Deleted: ' +
+                                            deleteCount +
+                                            ' - ' +
+                                            nodeCacheSize);
+                                    }
+                                }
+                            }
+                            else {
+                                sub.cacheId = 0;
+                            }
+                        }
+                        return [3 /*break*/, 8];
+                    case 4:
+                        err_2 = _m.sent();
+                        _c = (0, error_tracking_1.ensureErrorWithCorrelation)(err_2), normalizedError = _c.error, correlationId = _c.correlationId;
+                        try {
+                            for (_d = __values(sub.clients), _e = _d.next(); !_e.done; _e = _d.next()) {
+                                client = _e.value;
+                                ws = this._websocketManager.getWebSocket(client.id_socket);
+                                if (ws && ws.readyState === WebSocket.OPEN) {
+                                    serverRes = {
+                                        messageId: client.messageId,
+                                        hasError: true,
+                                        data: Object.assign({}, normalizedError, { correlationId: correlationId })
+                                    };
+                                    this.sendWS(ws, serverRes);
+                                }
+                            }
+                        }
+                        catch (e_9_1) { e_9 = { error: e_9_1 }; }
+                        finally {
+                            try {
+                                if (_e && !_e.done && (_j = _d.return)) _j.call(_d);
+                            }
+                            finally { if (e_9) throw e_9.error; }
+                        }
+                        errorPayload = {
+                            publication: sub.publication,
+                            subscriptionData: sub.subscriptionData,
+                            type: type,
+                            collection: collection,
+                            correlationId: correlationId,
+                            error: {
+                                name: normalizedError === null || normalizedError === void 0 ? void 0 : normalizedError.name,
+                                message: normalizedError === null || normalizedError === void 0 ? void 0 : normalizedError.message,
+                                stack: normalizedError === null || normalizedError === void 0 ? void 0 : normalizedError.stack,
+                                code: normalizedError === null || normalizedError === void 0 ? void 0 : normalizedError.code,
+                                codeName: normalizedError === null || normalizedError === void 0 ? void 0 : normalizedError.codeName
+                            }
+                        };
+                        return [4 /*yield*/, error_reporter_1.ErrorReporter.report({
+                                sourceApp: 'subscription-manager',
+                                message: 'SERVER - Error Detected - ' + this.serverConfig['CLIENT_NAME'],
+                                environment: (_l = this.serverConfig) === null || _l === void 0 ? void 0 : _l.ROOT_URL,
+                                clientSlug: resolveio_server_app_1.ResolveIOServer.getClientName(),
+                                clientName: this.serverConfig['CLIENT_NAME'],
+                                stack: normalizedError === null || normalizedError === void 0 ? void 0 : normalizedError.stack,
+                                context: errorPayload,
+                                metadata: {
+                                    context: 'subscription-sendDataToAll',
+                                    publication: sub.publication,
+                                    correlationId: correlationId
+                                },
+                                correlationId: correlationId
+                            })];
+                    case 5:
+                        _m.sent();
+                        return [3 /*break*/, 8];
+                    case 6: return [4 /*yield*/, this._monitorManagerFunction.finishMonitorFunction(monitor)];
+                    case 7:
+                        _m.sent();
+                        return [7 /*endfinally*/];
+                    case 8: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    SubscriptionManager.prototype.ensureDependencyContainers = function (sub) {
+        if (!sub.collectionDependencies) {
+            sub.collectionDependencies = new Map();
+        }
+        if (!sub.collectionFilters) {
+            sub.collectionFilters = new Map();
+        }
+        if (!sub.watchAllCollections) {
+            sub.watchAllCollections = new Set();
+        }
+        if (!sub.collectionQueryMeta) {
+            sub.collectionQueryMeta = new Map();
+        }
+    };
+    SubscriptionManager.prototype.updateSubscriptionDependencies = function (sub, snapshot) {
+        this.ensureDependencyContainers(sub);
+        if (!snapshot) {
+            sub.collectionDependencies.clear();
+            sub.collectionFilters.clear();
+            sub.watchAllCollections.clear();
+            sub.collectionQueryMeta.clear();
+            this.dependencyDebug('Cleared dependency snapshot', { publication: sub.publication });
+            return;
+        }
+        sub.collectionDependencies = snapshot.dependencies;
+        sub.collectionFilters = snapshot.filters;
+        sub.watchAllCollections = snapshot.watchAllCollections;
+        sub.collectionQueryMeta = snapshot.queryMetadata;
+        this.logDependencySnapshot(sub, 'Snapshot updated');
+    };
+    SubscriptionManager.prototype.normalizeDocumentId = function (rawId) {
+        if (rawId === null || rawId === undefined) {
+            return null;
+        }
+        if (typeof rawId === 'string') {
+            return rawId;
+        }
+        if (typeof rawId === 'object' && typeof rawId.toHexString === 'function') {
+            return rawId.toHexString();
+        }
+        if (typeof (rawId === null || rawId === void 0 ? void 0 : rawId.toString) === 'function') {
+            var str = rawId.toString();
+            if (str && str !== '[object Object]') {
+                return str;
+            }
+        }
+        return null;
+    };
+    SubscriptionManager.prototype.getDocumentIdQueryCandidates = function (documentId) {
+        var candidates = [];
+        if (documentId === undefined || documentId === null) {
+            return [documentId];
+        }
+        var addCandidate = function (value) {
+            if (value === undefined || value === null) {
+                return;
+            }
+            if (!candidates.includes(value)) {
+                candidates.push(value);
+            }
+        };
+        addCandidate(documentId);
+        if (typeof documentId === 'object') {
+            if (typeof documentId.toHexString === 'function') {
+                addCandidate(documentId.toHexString());
+            }
+            if (typeof documentId.toString === 'function') {
+                var str = documentId.toString();
+                if (str && str !== '[object Object]') {
+                    addCandidate(str);
+                }
+            }
+        }
+        else if (typeof documentId !== 'string') {
+            addCandidate(String(documentId));
+        }
+        return candidates;
+    };
+    SubscriptionManager.prototype.isFilterSafeForInMemory = function (filter) {
+        if (!filter || typeof filter !== 'object') {
+            return false;
+        }
+        var allowedOperators = new Set([
+            '$and',
+            '$or',
+            '$nor',
+            '$in',
+            '$nin',
+            '$eq',
+            '$ne',
+            '$gt',
+            '$gte',
+            '$lt',
+            '$lte',
+            '$exists',
+            '$size',
+            '$all',
+            '$elemMatch',
+            '$regex',
+            '$options'
+        ]);
+        var disallowedOperators = new Set([
+            '$where',
+            '$expr',
+            '$text',
+            '$geoWithin',
+            '$geoIntersects',
+            '$near',
+            '$nearSphere',
+            '$jsonSchema',
+            '$mod',
+            '$type',
+            '$bitsAllSet',
+            '$bitsAllClear',
+            '$bitsAnySet',
+            '$bitsAnyClear'
+        ]);
+        var walk = function (value) {
+            var e_10, _a;
+            if (Array.isArray(value)) {
+                return value.every(function (item) { return walk(item); });
+            }
+            if (!value || typeof value !== 'object') {
+                return true;
+            }
+            try {
+                for (var _b = __values(Object.entries(value)), _c = _b.next(); !_c.done; _c = _b.next()) {
+                    var _d = __read(_c.value, 2), key = _d[0], entry = _d[1];
+                    if (key.startsWith('$')) {
+                        if (disallowedOperators.has(key)) {
+                            return false;
+                        }
+                        if (!allowedOperators.has(key)) {
+                            return false;
+                        }
+                    }
+                    if (!walk(entry)) {
+                        return false;
+                    }
+                }
+            }
+            catch (e_10_1) { e_10 = { error: e_10_1 }; }
+            finally {
+                try {
+                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+                }
+                finally { if (e_10) throw e_10.error; }
+            }
+            return true;
+        };
+        return walk(filter);
+    };
+    SubscriptionManager.prototype.documentIdMatchesEvent = function (documentId, document) {
+        var e_11, _a;
+        var _this = this;
+        if (!document || documentId === undefined || documentId === null) {
+            return true;
+        }
+        var eventCandidates = this.getDocumentIdQueryCandidates(documentId)
+            .map(function (id) { return _this.normalizeDocumentId(id); })
+            .filter(Boolean);
+        var docCandidates = this.getDocumentIdQueryCandidates(document === null || document === void 0 ? void 0 : document._id)
+            .map(function (id) { return _this.normalizeDocumentId(id); })
+            .filter(Boolean);
+        if (!eventCandidates.length || !docCandidates.length) {
+            return true;
+        }
+        var docSet = new Set(docCandidates);
+        try {
+            for (var eventCandidates_1 = __values(eventCandidates), eventCandidates_1_1 = eventCandidates_1.next(); !eventCandidates_1_1.done; eventCandidates_1_1 = eventCandidates_1.next()) {
+                var candidate = eventCandidates_1_1.value;
+                if (docSet.has(candidate)) {
+                    return true;
+                }
+            }
+        }
+        catch (e_11_1) { e_11 = { error: e_11_1 }; }
+        finally {
+            try {
+                if (eventCandidates_1_1 && !eventCandidates_1_1.done && (_a = eventCandidates_1.return)) _a.call(eventCandidates_1);
+            }
+            finally { if (e_11) throw e_11.error; }
+        }
+        return false;
+    };
+    SubscriptionManager.prototype.resolveFilterMatch = function (filter, document, documentId) {
+        if (!document || !filter || typeof filter !== 'object') {
+            return null;
+        }
+        if (!this.isFilterSafeForInMemory(filter)) {
+            return null;
+        }
+        if (!this.documentIdMatchesEvent(documentId, document)) {
+            return false;
+        }
+        try {
+            var matcher = sift(filter);
+            return matcher(document);
+        }
+        catch (_a) {
+            return null;
+        }
+    };
+    SubscriptionManager.prototype.documentMatchesFilter = function (collection, documentId, filter, document) {
+        return __awaiter(this, void 0, void 0, function () {
+            var inMemoryMatch, db, filterCopy, idCandidates, idCandidates_1, idCandidates_1_1, idValue, combinedFilter, doc, e_12_1, _a;
+            var e_12, _b;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        _c.trys.push([0, 9, , 10]);
+                        inMemoryMatch = this.resolveFilterMatch(filter, document, documentId);
+                        if (inMemoryMatch !== null) {
+                            return [2 /*return*/, inMemoryMatch];
+                        }
+                        db = resolveio_server_app_1.ResolveIOServer.getMainDB();
+                        filterCopy = (0, common_1.deepCopy)(filter) || {};
+                        idCandidates = this.getDocumentIdQueryCandidates(documentId);
+                        _c.label = 1;
+                    case 1:
+                        _c.trys.push([1, 6, 7, 8]);
+                        idCandidates_1 = __values(idCandidates), idCandidates_1_1 = idCandidates_1.next();
+                        _c.label = 2;
+                    case 2:
+                        if (!!idCandidates_1_1.done) return [3 /*break*/, 5];
+                        idValue = idCandidates_1_1.value;
+                        combinedFilter = {
+                            $and: [
+                                { _id: idValue },
+                                filterCopy
+                            ]
+                        };
+                        return [4 /*yield*/, db.collection(collection).findOne(combinedFilter)];
+                    case 3:
+                        doc = _c.sent();
+                        if (doc) {
+                            return [2 /*return*/, true];
+                        }
+                        _c.label = 4;
+                    case 4:
+                        idCandidates_1_1 = idCandidates_1.next();
+                        return [3 /*break*/, 2];
+                    case 5: return [3 /*break*/, 8];
+                    case 6:
+                        e_12_1 = _c.sent();
+                        e_12 = { error: e_12_1 };
+                        return [3 /*break*/, 8];
+                    case 7:
+                        try {
+                            if (idCandidates_1_1 && !idCandidates_1_1.done && (_b = idCandidates_1.return)) _b.call(idCandidates_1);
+                        }
+                        finally { if (e_12) throw e_12.error; }
+                        return [7 /*endfinally*/];
+                    case 8: return [2 /*return*/, false];
+                    case 9:
+                        _a = _c.sent();
+                        return [2 /*return*/, true];
+                    case 10: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    SubscriptionManager.prototype.shouldInvalidateSubscription = function (sub, collection, type, documentId, document) {
+        return __awaiter(this, void 0, void 0, function () {
+            var normalizedDocumentId, trackedIds, filters, hasTrackedIds, hasFilters, hasDependencyData, filters_1, filters_1_1, filter, e_13_1;
+            var e_13, _a;
+            var _b, _c;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        this.ensureDependencyContainers(sub);
+                        normalizedDocumentId = this.normalizeDocumentId(documentId);
+                        trackedIds = sub.collectionDependencies.get(collection);
+                        filters = sub.collectionFilters.get(collection);
+                        hasTrackedIds = !!(trackedIds && trackedIds.size);
+                        hasFilters = !!(filters && filters.length);
+                        hasDependencyData = (((_b = sub.collectionDependencies.get(collection)) === null || _b === void 0 ? void 0 : _b.size) || 0) > 0 ||
+                            (((_c = sub.collectionFilters.get(collection)) === null || _c === void 0 ? void 0 : _c.length) || 0) > 0 ||
+                            sub.watchAllCollections.has(collection);
+                        if (!normalizedDocumentId) {
+                            this.dependencyDebug('Invalidate due to missing documentId', { publication: sub.publication, collection: collection, type: type });
+                            return [2 /*return*/, true];
+                        }
+                        if (!hasDependencyData) {
+                            this.dependencyDebug('Invalidate due to missing dependency metadata', {
+                                publication: sub.publication,
+                                collection: collection,
+                                type: type
+                            });
+                            return [2 /*return*/, true];
+                        }
+                        if (sub.watchAllCollections.has(collection)) {
+                            this.dependencyDebug('Invalidate due to watch-all collection', { publication: sub.publication, collection: collection, type: type });
+                            return [2 /*return*/, true];
+                        }
+                        if (trackedIds && trackedIds.has(normalizedDocumentId)) {
+                            this.dependencyDebug('Invalidate due to tracked id', { publication: sub.publication, collection: collection, type: type, documentId: normalizedDocumentId });
+                            return [2 /*return*/, true];
+                        }
+                        if (type === 'delete') {
+                            if (hasFilters && !hasTrackedIds) {
+                                this.dependencyDebug('Invalidate delete due to filter-only dependency without tracked ids', {
+                                    publication: sub.publication,
+                                    collection: collection,
+                                    type: type,
+                                    documentId: normalizedDocumentId
+                                });
+                                return [2 /*return*/, true];
+                            }
+                            this.dependencyDebug('Skip invalidation on delete for unknown id', { publication: sub.publication, collection: collection, type: type, documentId: normalizedDocumentId });
+                            return [2 /*return*/, false];
+                        }
+                        if (type === 'update' && hasFilters && !hasTrackedIds) {
+                            this.dependencyDebug('Invalidate update due to filter-only dependency without tracked ids', {
+                                publication: sub.publication,
+                                collection: collection,
+                                type: type,
+                                documentId: normalizedDocumentId
+                            });
+                            return [2 /*return*/, true];
+                        }
+                        if (!(filters && filters.length)) return [3 /*break*/, 8];
+                        _d.label = 1;
+                    case 1:
+                        _d.trys.push([1, 6, 7, 8]);
+                        filters_1 = __values(filters), filters_1_1 = filters_1.next();
+                        _d.label = 2;
+                    case 2:
+                        if (!!filters_1_1.done) return [3 /*break*/, 5];
+                        filter = filters_1_1.value;
+                        return [4 /*yield*/, this.documentMatchesFilter(collection, documentId, filter, document)];
+                    case 3:
+                        if (_d.sent()) {
+                            this.dependencyDebug('Invalidate due to filter match', { publication: sub.publication, collection: collection, type: type, documentId: normalizedDocumentId, filter: filter });
+                            return [2 /*return*/, true];
+                        }
+                        _d.label = 4;
+                    case 4:
+                        filters_1_1 = filters_1.next();
+                        return [3 /*break*/, 2];
+                    case 5: return [3 /*break*/, 8];
+                    case 6:
+                        e_13_1 = _d.sent();
+                        e_13 = { error: e_13_1 };
+                        return [3 /*break*/, 8];
+                    case 7:
+                        try {
+                            if (filters_1_1 && !filters_1_1.done && (_a = filters_1.return)) _a.call(filters_1);
+                        }
+                        finally { if (e_13) throw e_13.error; }
+                        return [7 /*endfinally*/];
+                    case 8:
+                        this.dependencyDebug('Skip invalidation after dependency checks', { publication: sub.publication, collection: collection, type: type, documentId: normalizedDocumentId });
+                        return [2 /*return*/, false];
+                }
+            });
+        });
+    };
+    SubscriptionManager.prototype.shouldInvalidateSubscriptionForEvents = function (sub, collection, events) {
+        return __awaiter(this, void 0, void 0, function () {
+            var sawInsert, sawDelete, events_1, events_1_1, event_1, e_14_1, paginationMeta, paginationReasons;
+            var e_14, _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        sawInsert = false;
+                        sawDelete = false;
+                        _b.label = 1;
+                    case 1:
+                        _b.trys.push([1, 6, 7, 8]);
+                        events_1 = __values(events), events_1_1 = events_1.next();
+                        _b.label = 2;
+                    case 2:
+                        if (!!events_1_1.done) return [3 /*break*/, 5];
+                        event_1 = events_1_1.value;
+                        if (event_1.type === 'insert') {
+                            sawInsert = true;
+                        }
+                        else if (event_1.type === 'delete') {
+                            sawDelete = true;
+                        }
+                        return [4 /*yield*/, this.shouldInvalidateSubscription(sub, collection, event_1.type, event_1.documentId, event_1.document)];
+                    case 3:
+                        if (_b.sent()) {
+                            return [2 /*return*/, true];
+                        }
+                        _b.label = 4;
+                    case 4:
+                        events_1_1 = events_1.next();
+                        return [3 /*break*/, 2];
+                    case 5: return [3 /*break*/, 8];
+                    case 6:
+                        e_14_1 = _b.sent();
+                        e_14 = { error: e_14_1 };
+                        return [3 /*break*/, 8];
+                    case 7:
+                        try {
+                            if (events_1_1 && !events_1_1.done && (_a = events_1.return)) _a.call(events_1);
+                        }
+                        finally { if (e_14) throw e_14.error; }
+                        return [7 /*endfinally*/];
+                    case 8:
+                        paginationMeta = this.getPaginationMeta(sub, collection);
+                        paginationReasons = [];
+                        if (sawInsert) {
+                            paginationReasons.push('insert');
+                        }
+                        if (sawDelete) {
+                            paginationReasons.push('delete');
+                        }
+                        if ((paginationMeta === null || paginationMeta === void 0 ? void 0 : paginationMeta.length) && paginationReasons.length) {
+                            this.dependencyDebug('Invalidate due to pagination metadata', {
+                                publication: sub.publication,
+                                collection: collection,
+                                events: this.summarizeEvents(events),
+                                reasons: paginationReasons,
+                                queryMeta: paginationMeta.slice(0, 5)
+                            });
+                            return [2 /*return*/, true];
+                        }
+                        return [2 /*return*/, false];
+                }
+            });
+        });
+    };
+    SubscriptionManager.prototype.getPaginationMeta = function (sub, collection) {
+        var _a;
+        this.ensureDependencyContainers(sub);
+        var metaList = (_a = sub.collectionQueryMeta) === null || _a === void 0 ? void 0 : _a.get(collection);
+        if (!metaList || !metaList.length) {
+            return null;
+        }
+        var relevantMeta = metaList.filter(function (meta) {
+            if (!meta) {
+                return false;
+            }
+            var limitUsed = typeof meta.limit === 'number' && meta.limit > 0;
+            var skipUsed = typeof meta.skip === 'number' && meta.skip > 0;
+            return limitUsed || skipUsed;
+        });
+        return relevantMeta.length ? relevantMeta : null;
+    };
+    SubscriptionManager.prototype.sendWS = function (ws, data) {
+        this._websocketManager.send(ws, data);
+    };
+    SubscriptionManager.prototype.getEnableDebug = function () {
+        return this._enableDebug;
+    };
+    SubscriptionManager.prototype.dependencyDebug = function (message, details) {
+        if (!this._enableDependencyDebug) {
+            return;
+        }
+        if (details) {
+            console.log(new Date(), '[Dependency Debug]', message, JSON.stringify(details, null, 2));
+        }
+        else {
+            console.log(new Date(), '[Dependency Debug]', message);
+        }
+    };
+    SubscriptionManager.prototype.summarizeEvents = function (events) {
+        var _this = this;
+        return events.map(function (event) { return ({
+            type: event.type,
+            documentId: _this.normalizeDocumentId(event.documentId)
+        }); });
+    };
+    SubscriptionManager.prototype.logDependencySnapshot = function (sub, context) {
+        if (!this._enableDependencyDebug) {
+            return;
+        }
+        var dependencySummary = Array.from(sub.collectionDependencies.entries()).map(function (_a) {
+            var _b = __read(_a, 2), collectionName = _b[0], ids = _b[1];
+            var idList = Array.from(ids || []);
+            return {
+                collection: collectionName,
+                count: idList.length,
+                sample: idList.slice(0, 10)
+            };
+        });
+        var filterSummary = Array.from(sub.collectionFilters.entries()).map(function (_a) {
+            var _b = __read(_a, 2), collectionName = _b[0], filters = _b[1];
+            return ({
+                collection: collectionName,
+                count: filters.length
+            });
+        });
+        var queryMetaSummary = Array.from(sub.collectionQueryMeta.entries()).map(function (_a) {
+            var _b = __read(_a, 2), collectionName = _b[0], metaList = _b[1];
+            return ({
+                collection: collectionName,
+                count: metaList.length,
+                meta: metaList.slice(0, 5)
+            });
+        });
+        var watchAll = Array.from(sub.watchAllCollections || []);
+        this.dependencyDebug('Dependency snapshot updated', {
+            context: context,
+            publication: sub.publication,
+            dependencies: dependencySummary,
+            collectionsWithFilters: filterSummary,
+            collectionsWithMeta: queryMetaSummary,
+            watchAll: watchAll
+        });
+    };
+    SubscriptionManager.prototype.runPublicationOnce = function (publication_1) {
+        return __awaiter(this, arguments, void 0, function (publication, subscriptionData, options) {
+            var pub, context, metadata;
+            if (subscriptionData === void 0) { subscriptionData = []; }
+            return __generator(this, function (_a) {
+                pub = this._publications[publication];
+                if (!pub) {
+                    throw new Error("Publication not found: ".concat(publication));
+                }
+                context = Object.assign({}, this, SubscriptionManager.prototype);
+                metadata = {
+                    publication: publication,
+                    subscriptionData: subscriptionData
+                };
+                if (pub.user_specific) {
+                    return [2 /*return*/, (0, subscription_dependency_context_1.withDependencyTracking)(function () {
+                            var _a;
+                            return (_a = pub.function).call.apply(_a, __spreadArray([context, (options === null || options === void 0 ? void 0 : options.userId) || ''], __read(subscriptionData), false));
+                        }, metadata)];
+                }
+                return [2 /*return*/, (0, subscription_dependency_context_1.withDependencyTracking)(function () {
+                        var _a;
+                        return (_a = pub.function).call.apply(_a, __spreadArray([context], __read(subscriptionData), false));
+                    }, metadata)];
+            });
+        });
+    };
+    return SubscriptionManager;
+}());
+exports.SubscriptionManager = SubscriptionManager;
+
+//# sourceMappingURL=subscription.manager.js.map