@resolveio/server-lib 20.14.19 → 20.14.22

package/managers/subscription.manager.js

@@ -75,6 +75,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.SubscriptionManager = void 0;
 var NodeCache = require("node-cache");
 var msgpackr_1 = require("msgpackr");
+var os = require("os");
+var perf_hooks_1 = require("perf_hooks");
 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");
@@ -170,7 +172,46 @@ var SubscriptionManager = /** @class */ (function () {
         this._pendingInvalidations = new Map();
         this.DEBOUNCE_DELAY = 100; // 100ms debounce window
         this.MAX_WAIT_TIME = 500; // 500ms maximum delay
+        this._warmupEnabled = false;
+        this._warmupEndsAtMs = 0;
+        this._warmupQueue = [];
+        this._warmupQueueKeys = new Set();
+        this._warmupTimer = null;
+        this._warmupInFlight = 0;
+        this._warmupProcessing = false;
+        this._warmupMaxInFlight = 2;
+        this._warmupMaxPerTick = 2;
+        this._warmupTickMs = 200;
+        this._warmupQueueLimit = 0;
+        this._warmupLogIntervalMs = 10000;
+        this._warmupLastLogMs = 0;
+        this._warmupAllowPublications = new Set();
+        this._warmupRampMaxPerTick = 0;
+        this._warmupRampMaxInFlight = 0;
+        this._warmupWindowEndedLogged = false;
+        this._warmupAdaptiveEnabled = true;
+        this._warmupAdaptiveSampleMs = 1000;
+        this._warmupAdaptiveAlpha = 0.2;
+        this._warmupTargetCpuPct = 55;
+        this._warmupMaxCpuPct = 85;
+        this._warmupTargetMemPct = 70;
+        this._warmupMaxMemPct = 85;
+        this._warmupTargetLagMs = 80;
+        this._warmupMaxLagMs = 200;
+        this._warmupAdaptiveScale = 0;
+        this._warmupAdaptiveLastSampleAt = 0;
+        this._warmupAdaptiveMetrics = { cpuPct: 0, memPct: 0, rssMB: 0, lagMs: 0, pressure: 0 };
+        this._warmupCpuSampleUsage = process.cpuUsage();
+        this._warmupCpuSampleAt = process.hrtime.bigint();
+        this._warmupLagMonitor = null;
+        this._publicationWorkersEnabled = true;
+        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();
@@ -186,6 +227,10 @@ var SubscriptionManager = /** @class */ (function () {
         }); });
         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;
@@ -216,21 +261,7 @@ var SubscriptionManager = /** @class */ (function () {
                         this._wss = wss;
                         this._oplogMode = this.resolveOplogMode();
                         this._localOplogResyncIntervalMs = this.resolveLocalOplogResyncIntervalMs();
-                        // Publications
-                        (0, super_admin_1.loadSuperAdminPublications)(this);
-                        (0, ai_terminal_1.loadAiTerminalPublications)(this);
-                        (0, app_status_1.loadAppStatusPublications)(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, 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);
+                        this.registerCorePublications();
                         if (!(this._oplogMode === 'local')) return [3 /*break*/, 2];
                         return [4 /*yield*/, this.enableLocalOplogFallback('config')];
                     case 1:
@@ -368,11 +399,29 @@ var SubscriptionManager = /** @class */ (function () {
                             this._enableDependencyDebug = process.env.ENABLE_DEPENDENCY_DEBUG === 'true';
                         }
                         this.setCacheLimit();
+                        this.configureWarmup();
+                        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, 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, 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;
@@ -381,6 +430,438 @@ var SubscriptionManager = /** @class */ (function () {
             this._heapLimit = this._heapSize * 0.3; // Use 50% of total heap size
         }
     };
+    SubscriptionManager.prototype.configureWarmup = function () {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u;
+        var config = this.serverConfig || resolveio_server_app_1.ResolveIOServer.getServerConfig() || {};
+        var enabledRaw = (_a = process.env.SUBSCRIPTION_WARMUP_ENABLED) !== null && _a !== void 0 ? _a : config['SUBSCRIPTION_WARMUP_ENABLED'];
+        var warmupMs = this.parsePositiveNumber((_b = process.env.SUBSCRIPTION_WARMUP_MS) !== null && _b !== void 0 ? _b : config['SUBSCRIPTION_WARMUP_MS']);
+        var enabled = this.parseBoolean(enabledRaw) || warmupMs > 0;
+        if (!enabled) {
+            this._warmupEnabled = false;
+            return;
+        }
+        var durationMs = warmupMs || 60000;
+        this._warmupEnabled = true;
+        this._warmupEndsAtMs = Date.now() + durationMs;
+        this._warmupTickMs = this.parsePositiveNumber((_c = process.env.SUBSCRIPTION_WARMUP_TICK_MS) !== null && _c !== void 0 ? _c : config['SUBSCRIPTION_WARMUP_TICK_MS']) || this._warmupTickMs;
+        this._warmupMaxPerTick = this.parsePositiveNumber((_d = process.env.SUBSCRIPTION_WARMUP_MAX_PER_TICK) !== null && _d !== void 0 ? _d : config['SUBSCRIPTION_WARMUP_MAX_PER_TICK']) || this._warmupMaxPerTick;
+        this._warmupMaxInFlight = this.parsePositiveNumber((_e = process.env.SUBSCRIPTION_WARMUP_MAX_IN_FLIGHT) !== null && _e !== void 0 ? _e : config['SUBSCRIPTION_WARMUP_MAX_IN_FLIGHT']) || Math.max(1, this._warmupMaxPerTick);
+        this._warmupRampMaxPerTick = this.parsePositiveNumber((_f = process.env.SUBSCRIPTION_WARMUP_RAMP_MAX_PER_TICK) !== null && _f !== void 0 ? _f : config['SUBSCRIPTION_WARMUP_RAMP_MAX_PER_TICK']) || this._warmupMaxPerTick;
+        this._warmupRampMaxInFlight = this.parsePositiveNumber((_g = process.env.SUBSCRIPTION_WARMUP_RAMP_MAX_IN_FLIGHT) !== null && _g !== void 0 ? _g : config['SUBSCRIPTION_WARMUP_RAMP_MAX_IN_FLIGHT']) || this._warmupMaxInFlight;
+        this._warmupQueueLimit = this.parsePositiveNumber((_h = process.env.SUBSCRIPTION_WARMUP_QUEUE_LIMIT) !== null && _h !== void 0 ? _h : config['SUBSCRIPTION_WARMUP_QUEUE_LIMIT']) || this._warmupQueueLimit;
+        this._warmupLogIntervalMs = this.parsePositiveNumber((_j = process.env.SUBSCRIPTION_WARMUP_LOG_INTERVAL_MS) !== null && _j !== void 0 ? _j : config['SUBSCRIPTION_WARMUP_LOG_INTERVAL_MS']) || this._warmupLogIntervalMs;
+        var adaptiveRaw = (_k = process.env.SUBSCRIPTION_WARMUP_ADAPTIVE_ENABLED) !== null && _k !== void 0 ? _k : config['SUBSCRIPTION_WARMUP_ADAPTIVE_ENABLED'];
+        this._warmupAdaptiveEnabled = adaptiveRaw === undefined ? true : this.parseBoolean(adaptiveRaw);
+        this._warmupAdaptiveSampleMs = this.parsePositiveNumber((_l = process.env.SUBSCRIPTION_WARMUP_ADAPTIVE_SAMPLE_MS) !== null && _l !== void 0 ? _l : config['SUBSCRIPTION_WARMUP_ADAPTIVE_SAMPLE_MS']) || this._warmupAdaptiveSampleMs;
+        this._warmupAdaptiveAlpha = this.parsePositiveFloat((_m = process.env.SUBSCRIPTION_WARMUP_ADAPTIVE_ALPHA) !== null && _m !== void 0 ? _m : config['SUBSCRIPTION_WARMUP_ADAPTIVE_ALPHA']) || this._warmupAdaptiveAlpha;
+        this._warmupTargetCpuPct = this.parsePositiveNumber((_o = process.env.SUBSCRIPTION_WARMUP_TARGET_CPU_PCT) !== null && _o !== void 0 ? _o : config['SUBSCRIPTION_WARMUP_TARGET_CPU_PCT']) || this._warmupTargetCpuPct;
+        this._warmupMaxCpuPct = this.parsePositiveNumber((_p = process.env.SUBSCRIPTION_WARMUP_MAX_CPU_PCT) !== null && _p !== void 0 ? _p : config['SUBSCRIPTION_WARMUP_MAX_CPU_PCT']) || this._warmupMaxCpuPct;
+        this._warmupTargetMemPct = this.parsePositiveNumber((_q = process.env.SUBSCRIPTION_WARMUP_TARGET_MEM_PCT) !== null && _q !== void 0 ? _q : config['SUBSCRIPTION_WARMUP_TARGET_MEM_PCT']) || this._warmupTargetMemPct;
+        this._warmupMaxMemPct = this.parsePositiveNumber((_r = process.env.SUBSCRIPTION_WARMUP_MAX_MEM_PCT) !== null && _r !== void 0 ? _r : config['SUBSCRIPTION_WARMUP_MAX_MEM_PCT']) || this._warmupMaxMemPct;
+        this._warmupTargetLagMs = this.parsePositiveNumber((_s = process.env.SUBSCRIPTION_WARMUP_TARGET_LAG_MS) !== null && _s !== void 0 ? _s : config['SUBSCRIPTION_WARMUP_TARGET_LAG_MS']) || this._warmupTargetLagMs;
+        this._warmupMaxLagMs = this.parsePositiveNumber((_t = process.env.SUBSCRIPTION_WARMUP_MAX_LAG_MS) !== null && _t !== void 0 ? _t : config['SUBSCRIPTION_WARMUP_MAX_LAG_MS']) || this._warmupMaxLagMs;
+        this._warmupAdaptiveScale = 0;
+        this._warmupAdaptiveLastSampleAt = 0;
+        this._warmupWindowEndedLogged = false;
+        if (this._warmupAdaptiveEnabled) {
+            this.ensureWarmupAdaptiveMonitor();
+        }
+        var allowRaw = (_u = process.env.SUBSCRIPTION_WARMUP_ALLOW_PUBS) !== null && _u !== void 0 ? _u : config['SUBSCRIPTION_WARMUP_ALLOW_PUBS'];
+        if (typeof allowRaw === 'string' && allowRaw.trim()) {
+            this._warmupAllowPublications = new Set(allowRaw
+                .split(',')
+                .map(function (entry) { return entry.trim(); })
+                .filter(Boolean));
+        }
+        this.startWarmupTimer();
+        console.log(new Date(), 'Sub Manager', 'Warmup enabled', {
+            durationMs: durationMs,
+            tickMs: this._warmupTickMs,
+            maxPerTick: this._warmupMaxPerTick,
+            maxInFlight: this._warmupMaxInFlight,
+            rampMaxPerTick: this._warmupRampMaxPerTick,
+            rampMaxInFlight: this._warmupRampMaxInFlight,
+            adaptiveEnabled: this._warmupAdaptiveEnabled,
+            adaptiveSampleMs: this._warmupAdaptiveSampleMs,
+            adaptiveAlpha: this._warmupAdaptiveAlpha,
+            targetCpuPct: this._warmupTargetCpuPct,
+            maxCpuPct: this._warmupMaxCpuPct,
+            targetMemPct: this._warmupTargetMemPct,
+            maxMemPct: this._warmupMaxMemPct,
+            targetLagMs: this._warmupTargetLagMs,
+            maxLagMs: this._warmupMaxLagMs,
+            queueLimit: this._warmupQueueLimit,
+            allowPubs: Array.from(this._warmupAllowPublications.values())
+        });
+    };
+    SubscriptionManager.prototype.configurePublicationWorkers = function () {
+        var _a, _b;
+        var config = this.serverConfig || resolveio_server_app_1.ResolveIOServer.getServerConfig() || {};
+        var enabledRaw = (_a = process.env.SUBSCRIPTION_WORKERS_ENABLED) !== null && _a !== void 0 ? _a : config['SUBSCRIPTION_WORKERS_ENABLED'];
+        this._publicationWorkersEnabled = enabledRaw === undefined ? true : this.parseBoolean(enabledRaw);
+        this._publicationWorkerQueueLimit = this.parsePositiveNumber((_b = process.env.SUBSCRIPTION_WORKER_QUEUE_MAX) !== null && _b !== void 0 ? _b : 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.ensureWarmupAdaptiveMonitor = function () {
+        if (this._warmupLagMonitor) {
+            return;
+        }
+        this._warmupLagMonitor = (0, perf_hooks_1.monitorEventLoopDelay)({ resolution: 20 });
+        this._warmupLagMonitor.enable();
+        this._warmupCpuSampleUsage = process.cpuUsage();
+        this._warmupCpuSampleAt = process.hrtime.bigint();
+        this._warmupAdaptiveLastSampleAt = Date.now();
+    };
+    SubscriptionManager.prototype.normalizePressure = function (value, target, max) {
+        if (!Number.isFinite(value)) {
+            return 0;
+        }
+        if (max <= target) {
+            return value > target ? 1 : 0;
+        }
+        var pressure = (value - target) / (max - target);
+        return this.clampNumber(pressure, 0, 1);
+    };
+    SubscriptionManager.prototype.sampleCpuPercent = function () {
+        var _a, _b, _c;
+        var usage = process.cpuUsage();
+        var now = process.hrtime.bigint();
+        var elapsedMicros = Number(now - this._warmupCpuSampleAt) / 1000;
+        var usageDelta = (usage.user - this._warmupCpuSampleUsage.user) + (usage.system - this._warmupCpuSampleUsage.system);
+        this._warmupCpuSampleUsage = usage;
+        this._warmupCpuSampleAt = now;
+        if (!elapsedMicros || elapsedMicros <= 0) {
+            return (_b = (_a = this._warmupAdaptiveMetrics) === null || _a === void 0 ? void 0 : _a.cpuPct) !== null && _b !== void 0 ? _b : 0;
+        }
+        var cores = Math.max(1, ((_c = os.cpus()) === null || _c === void 0 ? void 0 : _c.length) || 1);
+        var cpuPct = (usageDelta / (elapsedMicros * cores)) * 100;
+        return this.clampNumber(cpuPct, 0, 100);
+    };
+    SubscriptionManager.prototype.sampleWarmupAdaptiveMetrics = function (nowMs) {
+        if (!this._warmupAdaptiveEnabled) {
+            return this._warmupAdaptiveMetrics;
+        }
+        if (this._warmupAdaptiveLastSampleAt && (nowMs - this._warmupAdaptiveLastSampleAt) < this._warmupAdaptiveSampleMs) {
+            return this._warmupAdaptiveMetrics;
+        }
+        this.ensureWarmupAdaptiveMonitor();
+        var cpuPct = this.sampleCpuPercent();
+        var mem = process.memoryUsage();
+        var totalMem = os.totalmem();
+        var rssMB = mem.rss / (1024 * 1024);
+        var rssPct = totalMem > 0 ? (mem.rss / totalMem) * 100 : 0;
+        var systemMemPct = totalMem > 0 ? ((totalMem - os.freemem()) / totalMem) * 100 : 0;
+        var memPct = this.clampNumber(Math.max(rssPct, systemMemPct), 0, 100);
+        var lagMs = 0;
+        if (this._warmupLagMonitor) {
+            lagMs = this._warmupLagMonitor.percentile(99) / 1e6;
+            this._warmupLagMonitor.reset();
+        }
+        var cpuPressure = this.normalizePressure(cpuPct, this._warmupTargetCpuPct, this._warmupMaxCpuPct);
+        var memPressure = this.normalizePressure(memPct, this._warmupTargetMemPct, this._warmupMaxMemPct);
+        var lagPressure = this.normalizePressure(lagMs, this._warmupTargetLagMs, this._warmupMaxLagMs);
+        var pressure = Math.max(cpuPressure, memPressure, lagPressure);
+        this._warmupAdaptiveMetrics = {
+            cpuPct: cpuPct,
+            memPct: memPct,
+            rssMB: rssMB,
+            lagMs: lagMs,
+            pressure: pressure
+        };
+        this._warmupAdaptiveLastSampleAt = nowMs;
+        return this._warmupAdaptiveMetrics;
+    };
+    SubscriptionManager.prototype.updateAdaptiveScale = function (targetScale) {
+        var alpha = this.clampNumber(this._warmupAdaptiveAlpha, 0, 1);
+        if (!Number.isFinite(this._warmupAdaptiveScale)) {
+            this._warmupAdaptiveScale = targetScale;
+            return this._warmupAdaptiveScale;
+        }
+        this._warmupAdaptiveScale = this.clampNumber((alpha * targetScale) + ((1 - alpha) * this._warmupAdaptiveScale), 0, 1);
+        return this._warmupAdaptiveScale;
+    };
+    SubscriptionManager.prototype.isWarmupGateActive = function () {
+        if (!this._warmupEnabled) {
+            return false;
+        }
+        return true;
+    };
+    SubscriptionManager.prototype.shouldQueueWarmup = function (publication, messageRoute) {
+        if (!this.isWarmupGateActive()) {
+            return false;
+        }
+        if (messageRoute === 'Bypass') {
+            return false;
+        }
+        if (this._warmupAllowPublications.has(publication)) {
+            return false;
+        }
+        return true;
+    };
+    SubscriptionManager.prototype.buildWarmupKey = function (socketId, messageId, publication, subscriptionData) {
+        var normalizedSubscriptionData = Array.isArray(subscriptionData) ? subscriptionData : [];
+        return "".concat(socketId, ":").concat(messageId, ":").concat(publication, ":").concat(JSON.stringify(normalizedSubscriptionData));
+    };
+    SubscriptionManager.prototype.queueWarmupSubscription = function (params) {
+        var _a;
+        if (!this.isWarmupGateActive()) {
+            return false;
+        }
+        if (this._warmupQueueLimit > 0 && this._warmupQueue.length >= this._warmupQueueLimit) {
+            if (this._enableDebug) {
+                console.log(new Date(), 'Sub Manager', 'Warmup queue full; processing immediately', this._warmupQueue.length);
+            }
+            return false;
+        }
+        var socketId = (_a = params.ws) === null || _a === void 0 ? void 0 : _a['id_socket'];
+        if (!socketId) {
+            return false;
+        }
+        var key = this.buildWarmupKey(socketId, params.messageId, params.publication, params.subscriptionData);
+        if (this._warmupQueueKeys.has(key)) {
+            return true;
+        }
+        this._warmupQueue.push({
+            key: key,
+            socketId: socketId,
+            messageRoute: params.messageRoute,
+            messageDate: params.messageDate,
+            messageId: params.messageId,
+            publication: params.publication,
+            subscriptionData: params.subscriptionData,
+            enqueuedAt: Date.now()
+        });
+        this._warmupQueueKeys.add(key);
+        this.startWarmupTimer();
+        this.logWarmupStatus('queued');
+        return true;
+    };
+    SubscriptionManager.prototype.startWarmupTimer = function () {
+        var _this = this;
+        if (this._warmupTimer) {
+            return;
+        }
+        this._warmupTimer = setInterval(function () { return __awaiter(_this, void 0, void 0, function () {
+            var error_1;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 2, , 3]);
+                        return [4 /*yield*/, this.processWarmupQueue()];
+                    case 1:
+                        _a.sent();
+                        return [3 /*break*/, 3];
+                    case 2:
+                        error_1 = _a.sent();
+                        console.error(new Date(), 'Sub Manager', 'Warmup queue processing failed', error_1);
+                        return [3 /*break*/, 3];
+                    case 3: return [2 /*return*/];
+                }
+            });
+        }); }, this._warmupTickMs);
+    };
+    SubscriptionManager.prototype.stopWarmupTimerIfIdle = function () {
+        if (!this._warmupTimer) {
+            return;
+        }
+        if (this._warmupQueue.length > 0 || this._warmupInFlight > 0) {
+            return;
+        }
+        clearInterval(this._warmupTimer);
+        this._warmupTimer = null;
+    };
+    SubscriptionManager.prototype.processWarmupQueue = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var pendingTasks, now, limits, processed, _loop_3, this_3, state_1;
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (this._warmupProcessing) {
+                            return [2 /*return*/];
+                        }
+                        this._warmupProcessing = true;
+                        _b.label = 1;
+                    case 1:
+                        _b.trys.push([1, , 4, 5]);
+                        pendingTasks = [];
+                        now = Date.now();
+                        if (this._warmupEnabled && now >= this._warmupEndsAtMs && !this._warmupWindowEndedLogged) {
+                            this._warmupWindowEndedLogged = true;
+                            console.log(new Date(), 'Sub Manager', 'Warmup minimum window ended', {
+                                queued: this._warmupQueue.length
+                            });
+                        }
+                        if (!this._warmupQueue.length) {
+                            this.stopWarmupTimerIfIdle();
+                            return [2 /*return*/];
+                        }
+                        limits = this.getWarmupLimits(now);
+                        processed = 0;
+                        _loop_3 = function () {
+                            var item = this_3._warmupQueue.shift();
+                            if (!item) {
+                                return "break";
+                            }
+                            this_3._warmupQueueKeys.delete(item.key);
+                            var wasLastItem = this_3._warmupQueue.length === 0;
+                            var ws = this_3._websocketManager.getWebSocket(item.socketId);
+                            if (!ws || ws.readyState !== ws.OPEN) {
+                                return "continue";
+                            }
+                            var normalizedSubscriptionData = Array.isArray(item.subscriptionData) ? item.subscriptionData : [];
+                            var subscriptionKey = JSON.stringify(normalizedSubscriptionData);
+                            var sub = this_3._subscriptions.find(function (a) { return a.publication === item.publication && a.subscriptionKey === subscriptionKey; });
+                            if (!sub || !((_a = sub.clients) === null || _a === void 0 ? void 0 : _a.length)) {
+                                return "continue";
+                            }
+                            if (sub.running) {
+                                this_3.requeueWarmupItem(item);
+                                processed += 1;
+                                if (wasLastItem) {
+                                    return "break";
+                                }
+                                return "continue";
+                            }
+                            this_3._warmupInFlight += 1;
+                            processed += 1;
+                            pendingTasks.push(this_3.processWarmupItemWithCleanup(item, ws, sub));
+                        };
+                        this_3 = this;
+                        while (this._warmupQueue.length &&
+                            processed < limits.maxPerTick &&
+                            this._warmupInFlight < limits.maxInFlight) {
+                            state_1 = _loop_3();
+                            if (state_1 === "break")
+                                break;
+                        }
+                        this.logWarmupStatus('tick', limits);
+                        if (!pendingTasks.length) return [3 /*break*/, 3];
+                        return [4 /*yield*/, Promise.allSettled(pendingTasks)];
+                    case 2:
+                        _b.sent();
+                        _b.label = 3;
+                    case 3: return [3 /*break*/, 5];
+                    case 4:
+                        this._warmupProcessing = false;
+                        return [7 /*endfinally*/];
+                    case 5: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    SubscriptionManager.prototype.processWarmupItem = function (item, ws, sub) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.processSubscription(sub, ws, item.messageId)];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    SubscriptionManager.prototype.processWarmupItemWithCleanup = function (item, ws, sub) {
+        return __awaiter(this, void 0, void 0, function () {
+            var error_2;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 2, 3, 4]);
+                        return [4 /*yield*/, this.processWarmupItem(item, ws, sub)];
+                    case 1:
+                        _a.sent();
+                        return [3 /*break*/, 4];
+                    case 2:
+                        error_2 = _a.sent();
+                        console.error(new Date(), 'Sub Manager', 'Warmup item failed', error_2);
+                        return [3 /*break*/, 4];
+                    case 3:
+                        this._warmupInFlight -= 1;
+                        this.stopWarmupTimerIfIdle();
+                        return [7 /*endfinally*/];
+                    case 4: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    SubscriptionManager.prototype.getWarmupLimits = function (nowMs) {
+        var basePerTick = Math.max(1, this._warmupMaxPerTick);
+        var baseInFlight = Math.max(1, this._warmupMaxInFlight);
+        var targetPerTick = Math.max(basePerTick, this._warmupRampMaxPerTick || basePerTick);
+        var targetInFlight = Math.max(baseInFlight, this._warmupRampMaxInFlight || baseInFlight);
+        if (!this._warmupAdaptiveEnabled) {
+            return { maxPerTick: basePerTick, maxInFlight: baseInFlight, rampActive: false, rampProgress: 0 };
+        }
+        var metrics = this.sampleWarmupAdaptiveMetrics(nowMs);
+        var targetScale = this.clampNumber(1 - metrics.pressure, 0, 1);
+        var scale = this.updateAdaptiveScale(targetScale);
+        var maxPerTick = Math.max(1, (0, common_1.round)(basePerTick + (targetPerTick - basePerTick) * scale));
+        var maxInFlight = Math.max(1, (0, common_1.round)(baseInFlight + (targetInFlight - baseInFlight) * scale));
+        return { maxPerTick: maxPerTick, maxInFlight: maxInFlight, rampActive: true, rampProgress: scale, adaptiveScale: scale, metrics: metrics };
+    };
+    SubscriptionManager.prototype.requeueWarmupItem = function (item) {
+        if (this._warmupQueueKeys.has(item.key)) {
+            return;
+        }
+        item.enqueuedAt = Date.now();
+        this._warmupQueue.push(item);
+        this._warmupQueueKeys.add(item.key);
+    };
+    SubscriptionManager.prototype.logWarmupStatus = function (reason, limits) {
+        var _a, _b, _c;
+        if (!this._warmupLogIntervalMs) {
+            return;
+        }
+        var now = Date.now();
+        if (now - this._warmupLastLogMs < this._warmupLogIntervalMs) {
+            return;
+        }
+        this._warmupLastLogMs = now;
+        var metrics = limits === null || limits === void 0 ? void 0 : limits.metrics;
+        console.log(new Date(), 'Sub Manager', 'Warmup status', {
+            reason: reason,
+            enabled: this._warmupEnabled,
+            endsInMs: this._warmupEnabled ? Math.max(0, this._warmupEndsAtMs - now) : 0,
+            queued: this._warmupQueue.length,
+            inFlight: this._warmupInFlight,
+            maxPerTick: (_a = limits === null || limits === void 0 ? void 0 : limits.maxPerTick) !== null && _a !== void 0 ? _a : this._warmupMaxPerTick,
+            maxInFlight: (_b = limits === null || limits === void 0 ? void 0 : limits.maxInFlight) !== null && _b !== void 0 ? _b : this._warmupMaxInFlight,
+            rampActive: (_c = limits === null || limits === void 0 ? void 0 : limits.rampActive) !== null && _c !== void 0 ? _c : false,
+            rampProgress: typeof (limits === null || limits === void 0 ? void 0 : limits.rampProgress) === 'number' ? (0, common_1.round)(limits.rampProgress * 100) : 0,
+            adaptiveScale: typeof (limits === null || limits === void 0 ? void 0 : limits.adaptiveScale) === 'number' ? (0, common_1.round)(limits.adaptiveScale * 100) : 0,
+            cpuPct: metrics ? (0, common_1.round)(metrics.cpuPct) : undefined,
+            memPct: metrics ? (0, common_1.round)(metrics.memPct) : undefined,
+            rssMB: metrics ? (0, common_1.round)(metrics.rssMB) : undefined,
+            lagMs: metrics ? (0, common_1.round)(metrics.lagMs) : undefined,
+            pressure: metrics ? (0, common_1.round)(metrics.pressure * 100) : undefined
+        });
+    };
     SubscriptionManager.prototype.invalidatePubsCache = function (collection, type, documentId, document) {
         return __awaiter(this, void 0, void 0, function () {
             var queue, debounceKey, now, firstInvalidationTime, waitedTooLong;
@@ -598,6 +1079,141 @@ var SubscriptionManager = /** @class */ (function () {
         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 () {
+        if (!this._publicationWorkersEnabled) {
+            return false;
+        }
+        var dispatcher = this.getPublicationWorkerDispatcher();
+        if (!dispatcher || !dispatcher.hasWorkers()) {
+            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_3;
+            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_3 = _a.sent();
+                        if (this._enableDebug) {
+                            console.log(new Date(), 'Sub Manager', 'Worker publication failed, falling back', sub.publication, (error_3 === null || error_3 === void 0 ? void 0 : error_3.message) || error_3);
+                        }
+                        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) {
@@ -668,6 +1284,12 @@ var SubscriptionManager = /** @class */ (function () {
     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 _a, _b, _c, _d;
@@ -724,7 +1346,7 @@ var SubscriptionManager = /** @class */ (function () {
     // Method to flush buffered latency updates in bulk
     SubscriptionManager.prototype.flushThrottledLatencyUpdates = function () {
         return __awaiter(this, void 0, void 0, function () {
-            var pendingEntries, updates, error_1, pendingEntries_1, pendingEntries_1_1, _a, id_ws, payload, current;
+            var pendingEntries, updates, error_4, pendingEntries_1, pendingEntries_1_1, _a, id_ws, payload, current;
             var e_3, _b;
             var _this = this;
             return __generator(this, function (_c) {
@@ -759,7 +1381,7 @@ var SubscriptionManager = /** @class */ (function () {
                         }
                         return [3 /*break*/, 5];
                     case 3:
-                        error_1 = _c.sent();
+                        error_4 = _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];
@@ -776,7 +1398,7 @@ var SubscriptionManager = /** @class */ (function () {
                             }
                             finally { if (e_3) throw e_3.error; }
                         }
-                        console.error(new Date(), 'Sub Manager', 'Throttled latency batch update failed', error_1);
+                        console.error(new Date(), 'Sub Manager', 'Throttled latency batch update failed', error_4);
                         return [3 /*break*/, 5];
                     case 4:
                         this._latencyFlushInProgress = false;
@@ -793,7 +1415,7 @@ var SubscriptionManager = /** @class */ (function () {
     // 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;
+            var pub, valObj, valKeys, rootKeys, i, staleRouteMessage, urlData, urlModule_1, urlNext, otherRouteSubs, normalizedSubscriptionData, subscriptionKey_1, sub, queued;
             var _this = this;
             return __generator(this, function (_a) {
                 switch (_a.label) {
@@ -906,6 +1528,19 @@ var SubscriptionManager = /** @class */ (function () {
                         if (this._enableDebug) {
                             console.log(new Date(), 'New Sub', sub.publication, sub.running, sub.runAgain, sub.clients.length);
                         }
+                        if (this.shouldQueueWarmup(publication, messageRoute)) {
+                            queued = this.queueWarmupSubscription({
+                                ws: ws,
+                                messageRoute: messageRoute,
+                                messageDate: messageDate,
+                                messageId: messageId,
+                                publication: publication,
+                                subscriptionData: normalizedSubscriptionData
+                            });
+                            if (queued) {
+                                return [2 /*return*/];
+                            }
+                        }
                         // Immediately send data to the new client
                         return [4 /*yield*/, this.processSubscription(sub, ws, messageId)];
                     case 2:
@@ -1058,6 +1693,18 @@ var SubscriptionManager = /** @class */ (function () {
         }
         return 0;
     };
+    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() : '';
@@ -1177,7 +1824,7 @@ var SubscriptionManager = /** @class */ (function () {
     };
     SubscriptionManager.prototype.loadResumeToken = function () {
         return __awaiter(this, void 0, void 0, function () {
-            var db, doc, error_2;
+            var db, doc, error_5;
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
@@ -1191,8 +1838,8 @@ var SubscriptionManager = /** @class */ (function () {
                         doc = _a.sent();
                         return [2 /*return*/, (doc === null || doc === void 0 ? void 0 : doc.token) || null];
                     case 2:
-                        error_2 = _a.sent();
-                        console.log(new Date(), 'Sub Manager', 'Failed to load oplog resume token', error_2);
+                        error_5 = _a.sent();
+                        console.log(new Date(), 'Sub Manager', 'Failed to load oplog resume token', error_5);
                         return [2 /*return*/, null];
                     case 3: return [2 /*return*/];
                 }
@@ -1201,7 +1848,7 @@ var SubscriptionManager = /** @class */ (function () {
     };
     SubscriptionManager.prototype.saveResumeToken = function (token) {
         return __awaiter(this, void 0, void 0, function () {
-            var db, error_3;
+            var db, error_6;
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
@@ -1220,8 +1867,8 @@ var SubscriptionManager = /** @class */ (function () {
                         _a.sent();
                         return [3 /*break*/, 4];
                     case 3:
-                        error_3 = _a.sent();
-                        console.log(new Date(), 'Sub Manager', 'Failed to persist oplog resume token', error_3);
+                        error_6 = _a.sent();
+                        console.log(new Date(), 'Sub Manager', 'Failed to persist oplog resume token', error_6);
                         return [3 /*break*/, 4];
                     case 4: return [2 /*return*/];
                 }
@@ -1230,7 +1877,7 @@ var SubscriptionManager = /** @class */ (function () {
     };
     SubscriptionManager.prototype.clearResumeToken = function () {
         return __awaiter(this, void 0, void 0, function () {
-            var db, error_4;
+            var db, error_7;
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
@@ -1244,8 +1891,8 @@ var SubscriptionManager = /** @class */ (function () {
                         _a.sent();
                         return [3 /*break*/, 3];
                     case 2:
-                        error_4 = _a.sent();
-                        console.log(new Date(), 'Sub Manager', 'Failed to clear oplog resume token', error_4);
+                        error_7 = _a.sent();
+                        console.log(new Date(), 'Sub Manager', 'Failed to clear oplog resume token', error_7);
                         return [3 /*break*/, 3];
                     case 3: return [2 /*return*/];
                 }
@@ -1316,7 +1963,7 @@ var SubscriptionManager = /** @class */ (function () {
     };
     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_5;
+            var subs, subs_1, subs_1_1, sub, pub, _a, _b, client, ws, _c, e_4_1, e_5_1, error_8;
             var e_5, _d, e_4, _e;
             var _f, _g, _h, _j, _k;
             return __generator(this, function (_l) {
@@ -1414,8 +2061,8 @@ var SubscriptionManager = /** @class */ (function () {
                         return [7 /*endfinally*/];
                     case 19: return [3 /*break*/, 21];
                     case 20:
-                        error_5 = _l.sent();
-                        console.log(new Date(), 'Sub Manager', 'Full resync failed', reason, error_5);
+                        error_8 = _l.sent();
+                        console.log(new Date(), 'Sub Manager', 'Full resync failed', reason, error_8);
                         return [3 /*break*/, 21];
                     case 21: return [2 /*return*/];
                 }
@@ -1425,7 +2072,7 @@ var SubscriptionManager = /** @class */ (function () {
     // 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, error_6, innerError_1, error_7;
+            var watchDatabases, pipeline, lastResumeToken_1, startedWithResumeToken, error_9, innerError_1, error_10;
             var _this = this;
             return __generator(this, function (_a) {
                 switch (_a.label) {
@@ -1486,9 +2133,9 @@ var SubscriptionManager = /** @class */ (function () {
                         startedWithResumeToken = true;
                         return [3 /*break*/, 16];
                     case 5:
-                        error_6 = _a.sent();
-                        if (!this.isChangeStreamUnsupported(error_6)) return [3 /*break*/, 7];
-                        return [4 /*yield*/, this.enableLocalOplogFallback('change-stream-unsupported', error_6)];
+                        error_9 = _a.sent();
+                        if (!this.isChangeStreamUnsupported(error_9)) return [3 /*break*/, 7];
+                        return [4 /*yield*/, this.enableLocalOplogFallback('change-stream-unsupported', error_9)];
                     case 6:
                         _a.sent();
                         return [2 /*return*/];
@@ -1504,7 +2151,7 @@ var SubscriptionManager = /** @class */ (function () {
                     case 10:
                         _a.sent();
                         lastResumeToken_1 = null;
-                        console.log(new Date(), 'oplog resumeAfter failed, starting fresh', error_6);
+                        console.log(new Date(), 'oplog resumeAfter failed, starting fresh', error_9);
                         _a.label = 11;
                     case 11:
                         _a.trys.push([11, 12, , 15]);
@@ -1528,13 +2175,13 @@ var SubscriptionManager = /** @class */ (function () {
                         this._oplog$ = resolveio_server_app_1.ResolveIOServer.getMongoConnection().watch(pipeline, { fullDocument: 'updateLookup' });
                         return [3 /*break*/, 21];
                     case 18:
-                        error_7 = _a.sent();
-                        if (!this.isChangeStreamUnsupported(error_7)) return [3 /*break*/, 20];
-                        return [4 /*yield*/, this.enableLocalOplogFallback('change-stream-unsupported', error_7)];
+                        error_10 = _a.sent();
+                        if (!this.isChangeStreamUnsupported(error_10)) return [3 /*break*/, 20];
+                        return [4 /*yield*/, this.enableLocalOplogFallback('change-stream-unsupported', error_10)];
                     case 19:
                         _a.sent();
                         return [2 /*return*/];
-                    case 20: throw error_7;
+                    case 20: throw error_10;
                     case 21:
                         console.log(new Date(), 'oplog started', startedWithResumeToken ? '(resumeAfter)' : '');
                         this._oplog$.on('change', function (doc) { return __awaiter(_this, void 0, void 0, function () {
@@ -1784,7 +2431,7 @@ var SubscriptionManager = /** @class */ (function () {
     };
     SubscriptionManager.prototype.processSubscription = function (sub, ws, messageId) {
         return __awaiter(this, void 0, void 0, function () {
-            var cacheData, serverRes, _a;
+            var cachedRaw, cachedBuffer, cacheData, serverRes, _a;
             return __generator(this, function (_b) {
                 switch (_b.label) {
                     case 0:
@@ -1793,19 +2440,29 @@ var SubscriptionManager = /** @class */ (function () {
                         _b.label = 1;
                     case 1:
                         _b.trys.push([1, 2, , 4]);
-                        cacheData = this.decodeCachePayload(this._nodeCache.get(sub.cacheId));
-                        if (cacheData === null || cacheData === undefined) {
-                            throw new Error('cache-miss');
+                        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');
                         }
-                        serverRes = {
-                            messageId: messageId,
-                            hasError: false,
-                            data: cacheData
-                        };
-                        if (this._enableDebug) {
-                            console.log(new Date(), 'Process Sub, Cache', sub.publication);
+                        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.sendWS(ws, serverRes);
                         return [3 /*break*/, 4];
                     case 2:
                         _a = _b.sent();
@@ -1847,7 +2504,6 @@ var SubscriptionManager = /** @class */ (function () {
     SubscriptionManager.prototype.sendDataToOne = function (ws, messageId, sub, collection, type) {
         return __awaiter(this, void 0, void 0, function () {
             var startMs, monitor, dependencySnapshot, res, execution, serverRes, err_1, _a, normalizedError, correlationId, serverRes, errorPayload, durationMs;
-            var _this = this;
             var _b;
             return __generator(this, function (_c) {
                 switch (_c.label) {
@@ -1858,24 +2514,23 @@ var SubscriptionManager = /** @class */ (function () {
                     case 1:
                         _c.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*/, (0, subscription_dependency_context_1.withDependencyTracking)(function () {
-                                var _a;
-                                return (_a = _this._publications[sub.publication].function).call.apply(_a, __spreadArray([Object.assign({}, _this, SubscriptionManager.prototype), ws['id_user']], __read(sub.subscriptionData), false));
-                            }, {
-                                publication: sub.publication,
-                                subscriptionData: sub.subscriptionData
-                            })];
+                        return [4 /*yield*/, this.runPublicationExecution(sub, ws['id_user'])];
                     case 2:
                         execution = _c.sent();
                         res = execution.result;
                         dependencySnapshot = execution.snapshot;
                         this.updateSubscriptionDependencies(sub, dependencySnapshot);
-                        serverRes = {
-                            messageId: messageId,
-                            hasError: false,
-                            data: res
-                        };
-                        this.sendWS(ws, serverRes);
+                        if (execution.packedResult) {
+                            this._websocketManager.sendPackedBuffer(ws, messageId, false, execution.packedResult, execution.encoding || 'msgpack');
+                        }
+                        else {
+                            serverRes = {
+                                messageId: messageId,
+                                hasError: false,
+                                data: res
+                            };
+                            this.sendWS(ws, serverRes);
+                        }
                         return [3 /*break*/, 7];
                     case 3:
                         err_1 = _c.sent();
@@ -1948,10 +2603,9 @@ var SubscriptionManager = /** @class */ (function () {
         return __awaiter(this, void 0, void 0, function () {
             var subIndex, startMs, monitor, res, dependencySnapshot, execution, packedRes, shouldCache, cachedBuffer, isSame, _a, _b, client, ws, serverRes, _c, _d, client, ws, serverRes, nodeCacheSize, deleteCount, subArr, zz, err_2, _e, normalizedError, correlationId, _f, _g, client, ws, serverRes, errorPayload, durationMs;
             var e_6, _h, e_7, _j, e_8, _k;
-            var _this = this;
-            var _l;
-            return __generator(this, function (_m) {
-                switch (_m.label) {
+            var _l, _m;
+            return __generator(this, function (_o) {
+                switch (_o.label) {
                     case 0:
                         if (!!sub.clients.length) return [3 /*break*/, 1];
                         if (sub.cacheId) {
@@ -1968,25 +2622,19 @@ var SubscriptionManager = /** @class */ (function () {
                         monitor = this._monitorManagerFunction.startMonitorFunction('Publication', sub.publication, '', '', sub.subscriptionData);
                         res = void 0;
                         dependencySnapshot = void 0;
-                        _m.label = 2;
+                        _o.label = 2;
                     case 2:
-                        _m.trys.push([2, 4, 6, 8]);
+                        _o.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*/, (0, subscription_dependency_context_1.withDependencyTracking)(function () {
-                                var _a;
-                                return (_a = _this._publications[sub.publication].function).call.apply(_a, __spreadArray([Object.assign({}, _this, SubscriptionManager.prototype)], __read(sub.subscriptionData), false));
-                            }, {
-                                publication: sub.publication,
-                                subscriptionData: sub.subscriptionData
-                            })];
+                        return [4 /*yield*/, this.runPublicationExecution(sub)];
                     case 3:
-                        execution = _m.sent();
+                        execution = _o.sent();
                         res = execution.result;
                         dependencySnapshot = execution.snapshot;
                         this.updateSubscriptionDependencies(sub, dependencySnapshot);
-                        packedRes = this.packCachePayload(res);
+                        packedRes = (_l = execution.packedResult) !== null && _l !== void 0 ? _l : this.packCachePayload(res);
                         shouldCache = this.shouldCachePayload(sub, packedRes);
                         if (sub.cacheId) {
                             cachedBuffer = this.getCacheBuffer(this._nodeCache.get(sub.cacheId));
@@ -1997,12 +2645,17 @@ var SubscriptionManager = /** @class */ (function () {
                                         client = _b.value;
                                         ws = this._websocketManager.getWebSocket(client.id_socket);
                                         if (ws && ws.readyState === ws.OPEN) {
-                                            serverRes = {
-                                                messageId: client.messageId,
-                                                hasError: false,
-                                                data: res
-                                            };
-                                            this.sendWS(ws, serverRes);
+                                            if (packedRes) {
+                                                this._websocketManager.sendPackedBuffer(ws, client.messageId, false, packedRes, execution.encoding || 'msgpack');
+                                            }
+                                            else {
+                                                serverRes = {
+                                                    messageId: client.messageId,
+                                                    hasError: false,
+                                                    data: res
+                                                };
+                                                this.sendWS(ws, serverRes);
+                                            }
                                         }
                                     }
                                 }
@@ -2035,12 +2688,17 @@ var SubscriptionManager = /** @class */ (function () {
                                     client = _d.value;
                                     ws = this._websocketManager.getWebSocket(client.id_socket);
                                     if (ws && ws.readyState === ws.OPEN) {
-                                        serverRes = {
-                                            messageId: client.messageId,
-                                            hasError: false,
-                                            data: res
-                                        };
-                                        this.sendWS(ws, serverRes);
+                                        if (packedRes) {
+                                            this._websocketManager.sendPackedBuffer(ws, client.messageId, false, packedRes, execution.encoding || 'msgpack');
+                                        }
+                                        else {
+                                            serverRes = {
+                                                messageId: client.messageId,
+                                                hasError: false,
+                                                data: res
+                                            };
+                                            this.sendWS(ws, serverRes);
+                                        }
                                     }
                                 }
                             }
@@ -2084,7 +2742,7 @@ var SubscriptionManager = /** @class */ (function () {
                         }
                         return [3 /*break*/, 8];
                     case 4:
-                        err_2 = _m.sent();
+                        err_2 = _o.sent();
                         _e = (0, error_tracking_1.ensureErrorWithCorrelation)(err_2), normalizedError = _e.error, correlationId = _e.correlationId;
                         try {
                             for (_f = __values(sub.clients), _g = _f.next(); !_g.done; _g = _f.next()) {
@@ -2124,7 +2782,7 @@ var SubscriptionManager = /** @class */ (function () {
                         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,
+                                environment: (_m = this.serverConfig) === null || _m === void 0 ? void 0 : _m.ROOT_URL,
                                 clientSlug: resolveio_server_app_1.ResolveIOServer.getClientName(),
                                 clientName: this.serverConfig['CLIENT_NAME'],
                                 stack: normalizedError === null || normalizedError === void 0 ? void 0 : normalizedError.stack,
@@ -2137,7 +2795,7 @@ var SubscriptionManager = /** @class */ (function () {
                                 correlationId: correlationId
                             })];
                     case 5:
-                        _m.sent();
+                        _o.sent();
                         return [3 /*break*/, 8];
                     case 6:
                         durationMs = Date.now() - startMs;
@@ -2155,7 +2813,7 @@ var SubscriptionManager = /** @class */ (function () {
                         }
                         return [4 /*yield*/, this._monitorManagerFunction.finishMonitorFunction(monitor)];
                     case 7:
-                        _m.sent();
+                        _o.sent();
                         return [7 /*endfinally*/];
                     case 8: return [2 /*return*/];
                 }