@resolveio/server-lib 22.2.34 → 22.2.36

package/server-app.js

@@ -0,0 +1,2784 @@
+"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.ResolveIOMainServer = void 0;
+var express = require("express");
+var xmlParser = require("express-xml-bodyparser");
+var http_1 = require("http");
+var crypto = require("crypto");
+var fs = require("fs");
+var jwt = require("jsonwebtoken");
+var moment = require("moment-timezone");
+var msgpackr_1 = require("msgpackr");
+var os = require("os");
+var path = require("path");
+var perf_hooks_1 = require("perf_hooks");
+var inspector = require("inspector");
+var url_1 = require("url");
+var WebSocket = require("ws");
+var log_collection_1 = require("./collections/log.collection");
+var user_collection_1 = require("./collections/user.collection");
+var cron_manager_1 = require("./managers/cron.manager");
+var method_manager_1 = require("./managers/method.manager");
+var monitor_manager_1 = require("./managers/monitor.manager");
+var subscription_manager_1 = require("./managers/subscription.manager");
+var common_1 = require("./util/common");
+var error_reporter_1 = require("./util/error-reporter");
+var error_tracking_1 = require("./util/error-tracking");
+var mongodb_1 = require("mongodb");
+var auth_1 = require("./http/auth");
+var health_1 = require("./http/health");
+var home_1 = require("./http/home");
+var slow_query_publication_1 = require("./http/slow-query-publication");
+var websocket_manager_1 = require("./managers/websocket.manager");
+var worker_dispatcher_manager_1 = require("./managers/worker-dispatcher.manager");
+var worker_server_manager_1 = require("./managers/worker-server.manager");
+var resolveio_server_app_1 = require("./resolveio-server-app");
+var ResolveIOMainServer = /** @class */ (function () {
+    function ResolveIOMainServer() {
+        this._offlineUpdates = [];
+        this.sesMail = false;
+        this.publicProgram = false;
+        this._rebootFlag = false;
+        this.LOGGER = 'ERROR'; //ERROR / DEBUG
+        this._clientRoutes = [];
+        this._httpServerClosePromise = null;
+        this._websocketServerClosePromise = null;
+        this._wsConnectDebug = false;
+        this._perfDebug = false;
+        this._perfDebugIntervalMs = 2000;
+        this._perfDebugTimer = null;
+        this._perfDebugLastCpu = null;
+        this._perfDebugLastTs = 0;
+        this._eventLoopHistogram = null;
+        this._cpuProfileOnStart = false;
+        this._cpuProfileAuto = false;
+        this._cpuProfileDurationMs = 15000;
+        this._cpuProfileThresholdPct = 90;
+        this._cpuProfileTriggerCount = 3;
+        this._cpuProfileHighCount = 0;
+        this._cpuProfileDir = null;
+        this._cpuProfileSession = null;
+        this._timerDebug = false;
+        this._timerDebugThresholdMs = 50;
+        this._timerDebugMinDelayMs = 5;
+        this._timerDebugSampleRate = 1;
+        this._timerDebugLogLimit = 100;
+        this._timerDebugLogCount = 0;
+        this._aiWorkerDebug = false;
+        this._lastErrorMsg = null;
+        this._debugMsgRecv = 0;
+        this._debugMsgQueue = 0;
+        this._isWorkersEnabled = false;
+        this._isWorkerInstance = false;
+        this._safeShutdown = false;
+        this._dynamicAppGatewayEnabled = false;
+        this._dynamicAppGatewayCache = new Map();
+        this._socketTier = '';
+        this._maxClientSockets = 0;
+        this._singleIpPerUser = false;
+        this._socketPolicyUpgradeUrl = '';
+        this._clientHeartbeatIntervalMs = 20000;
+        this._clientHeartbeatInitialDelayMs = 5000;
+        this._clientHeartbeatBackpressureBytes = 5 * 1024 * 1024;
+        this._dynamicAppGatewayCacheMs = 30 * 1000;
+    }
+    ResolveIOMainServer.create = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var resolveioMainServer;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        resolveioMainServer = new ResolveIOMainServer();
+                        return [4 /*yield*/, resolveioMainServer.initialize()];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/, resolveioMainServer];
+                }
+            });
+        });
+    };
+    ResolveIOMainServer.prototype.initialize = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, workerRole, workerIndex, workerInstance;
+            var _this = this;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        this._serverStartTime = new Date();
+                        this._lastErrorMsg = null;
+                        this._wsConnectDebug = this.resolveConnectDebug();
+                        this._perfDebug = this.resolvePerfDebug();
+                        this._cpuProfileOnStart = this.resolveCpuProfileOnStart();
+                        this._cpuProfileAuto = this.resolveCpuProfileAuto();
+                        this._cpuProfileDurationMs = this.resolveCpuProfileDurationMs();
+                        this._cpuProfileThresholdPct = this.resolveCpuProfileThresholdPct();
+                        this._cpuProfileTriggerCount = this.resolveCpuProfileTriggerCount();
+                        this._cpuProfileDir = this.resolveCpuProfileDir();
+                        this._timerDebug = this.resolveTimerDebug();
+                        this._timerDebugThresholdMs = this.resolveTimerDebugThresholdMs();
+                        this._timerDebugMinDelayMs = this.resolveTimerDebugMinDelayMs();
+                        this._timerDebugSampleRate = this.resolveTimerDebugSampleRate();
+                        this._timerDebugLogLimit = this.resolveTimerDebugLogLimit();
+                        this._aiWorkerDebug = this.parseDebugFlag(process.env.AI_ASSISTANT_WORKER_DEBUG);
+                        this._dynamicAppGatewayEnabled = this.resolveDynamicAppGatewayEnabled();
+                        this._socketTier = this.resolveSocketTier();
+                        this._maxClientSockets = this.resolveMaxClientSockets(this._socketTier);
+                        this._singleIpPerUser = this.resolveSingleIpPerUserPolicy(this._socketTier);
+                        this._socketPolicyUpgradeUrl = this.resolveSocketPolicyUpgradeUrl();
+                        if (this._maxClientSockets > 0 || this._singleIpPerUser) {
+                            console.info(new Date(), '[Socket Policy] configured', {
+                                tier: this._socketTier || 'none',
+                                maxClientSockets: this._maxClientSockets,
+                                singleIpPerUser: this._singleIpPerUser
+                            });
+                        }
+                        _a = this;
+                        return [4 /*yield*/, monitor_manager_1.MonitorManager.create()];
+                    case 1:
+                        _a._monitorManager = _b.sent();
+                        this._monitorManagerFunction = new monitor_manager_1.MonitorManagerFunction();
+                        this.installTimerDebug();
+                        this.startPerfDebug();
+                        if (this._cpuProfileOnStart) {
+                            this.startCpuProfile('on-start');
+                        }
+                        // Check for workers and decide what to start
+                        this._isWorkersEnabled = process.env.IS_WORKERS_ENABLED === 'true';
+                        this._isWorkerInstance = process.env.IS_WORKER_INSTANCE === 'true';
+                        setInterval(function () {
+                            if (_this._methodManager && _this._methodManager.getEnableDebug()) {
+                                console.log(new Date(), 'Server App', 'Msg Recv Hits', _this._debugMsgRecv);
+                                console.log(new Date(), 'Server App', 'Msg Queue Hits', _this._debugMsgQueue);
+                            }
+                            _this._debugMsgQueue = 0;
+                            _this._debugMsgRecv = 0;
+                        }, 60000);
+                        process.removeAllListeners('unhandledRejection');
+                        process.on('unhandledRejection', function (error, rej) { return __awaiter(_this, void 0, void 0, function () {
+                            var _a, normalizedError, correlationId, errorDetails, diffTimeSec;
+                            var _this = this;
+                            return __generator(this, function (_b) {
+                                switch (_b.label) {
+                                    case 0:
+                                        _a = (0, error_tracking_1.ensureErrorWithCorrelation)(error), normalizedError = _a.error, correlationId = _a.correlationId;
+                                        if (this._methodManager.getEnableDebug()) {
+                                            console.error(new Date(), 'ERROR DETECTED w/ Debug Flag Active: unhandledRejection', [normalizedError, rej, { correlationId: correlationId }]);
+                                        }
+                                        // Condition to filter out the MongoError with specific codes
+                                        if (normalizedError && normalizedError['name'] === 'MongoError' && (normalizedError['code'] === 48 || normalizedError['code'] === 26 || normalizedError['code'] === 11000 || normalizedError['code'] === 251)) {
+                                            return [2 /*return*/]; // Simply return without doing anything further
+                                        }
+                                        // if (normalizedError && normalizedError['name'] === 'MongoServerError' && (!initServerFlag || normalizedError['code'] === 26 || normalizedError['code'] === 11000 || normalizedError['code'] === 86 || normalizedError['code'] === 251)) {
+                                        // 	return; // Simply return without doing anything further
+                                        // }
+                                        if (normalizedError && normalizedError['name'] === 'MongoServerError') {
+                                            return [2 /*return*/]; // Simply return without doing anything further
+                                        }
+                                        errorDetails = {
+                                            id: correlationId,
+                                            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
+                                        };
+                                        console.error(new Date(), 'Unhandled Rejection at Promise', [errorDetails]);
+                                        diffTimeSec = moment().diff(this._serverStartTime, 'seconds');
+                                        if (!(normalizedError && (normalizedError['name'] === 'MongoNetworkTimeoutError' || normalizedError instanceof mongodb_1.MongoNetworkTimeoutError))) return [3 /*break*/, 1];
+                                        if (diffTimeSec > 60 && !this._lastErrorMsg) {
+                                            this._lastErrorMsg = new Date();
+                                            setTimeout(function () {
+                                                _this._lastErrorMsg = null;
+                                            }, 60000);
+                                            // Exiting the process
+                                            process.exit(1);
+                                        }
+                                        return [3 /*break*/, 5];
+                                    case 1:
+                                        if (!(normalizedError && normalizedError['name'] === 'MongoError' && normalizedError['message'] === 'not master')) return [3 /*break*/, 2];
+                                        if (diffTimeSec > 60 && !this._lastErrorMsg) {
+                                            this._lastErrorMsg = new Date();
+                                            setTimeout(function () {
+                                                _this._lastErrorMsg = null;
+                                            }, 60000);
+                                        }
+                                        process.exit(1);
+                                        return [3 /*break*/, 5];
+                                    case 2:
+                                        if (!(normalizedError && normalizedError['name'] === 'MongoError' && normalizedError['message'] === 'not master and slaveOk=false')) return [3 /*break*/, 3];
+                                        if (diffTimeSec > 60 && !this._lastErrorMsg) {
+                                            this._lastErrorMsg = new Date();
+                                            setTimeout(function () {
+                                                _this._lastErrorMsg = null;
+                                            }, 60000);
+                                        }
+                                        process.exit(1);
+                                        return [3 /*break*/, 5];
+                                    case 3:
+                                        if (!(normalizedError && normalizedError['name'] !== 'StatusError' && normalizedError['message'] !== '')) return [3 /*break*/, 5];
+                                        if (!(diffTimeSec > 60 && !this._lastErrorMsg)) return [3 /*break*/, 5];
+                                        this._lastErrorMsg = new Date();
+                                        setTimeout(function () {
+                                            _this._lastErrorMsg = null;
+                                        }, 60000);
+                                        return [4 /*yield*/, this.reportServerError('SERVER - Unhandled Rejection - ' + resolveio_server_app_1.ResolveIOServer.getServerConfig()['CLIENT_NAME'], correlationId, errorDetails, {
+                                                context: 'unhandledRejection',
+                                                scenario: 'General'
+                                            })];
+                                    case 4:
+                                        _b.sent();
+                                        _b.label = 5;
+                                    case 5: return [2 /*return*/];
+                                }
+                            });
+                        }); });
+                        process.on('uncaughtException', function (error) { return __awaiter(_this, void 0, void 0, function () {
+                            var _a, normalizedError, correlationId, diffTimeSec, errorDetails;
+                            var _this = this;
+                            return __generator(this, function (_b) {
+                                switch (_b.label) {
+                                    case 0:
+                                        _a = (0, error_tracking_1.ensureErrorWithCorrelation)(error), normalizedError = _a.error, correlationId = _a.correlationId;
+                                        console.error(normalizedError, 'Uncaught Exception thrown', { correlationId: correlationId });
+                                        diffTimeSec = moment().diff(this._serverStartTime, 'seconds');
+                                        if (!(diffTimeSec > 60 && !this._lastErrorMsg)) return [3 /*break*/, 2];
+                                        this._lastErrorMsg = new Date();
+                                        setTimeout(function () {
+                                            _this._lastErrorMsg = null;
+                                        }, 60000);
+                                        errorDetails = {
+                                            id: correlationId,
+                                            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*/, this.reportServerError('SERVER - Unhandled Exception - ' + resolveio_server_app_1.ResolveIOServer.getServerConfig()['CLIENT_NAME'], correlationId, errorDetails, {
+                                                context: 'uncaughtException'
+                                            })];
+                                    case 1:
+                                        _b.sent();
+                                        _b.label = 2;
+                                    case 2: return [2 /*return*/];
+                                }
+                            });
+                        }); });
+                        //PM2 wants to reboot/restart
+                        process.on('SIGINT', function () { return __awaiter(_this, void 0, void 0, function () {
+                            var error_1;
+                            return __generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0:
+                                        this._rebootFlag = true;
+                                        _a.label = 1;
+                                    case 1:
+                                        _a.trys.push([1, 3, , 4]);
+                                        return [4 /*yield*/, this.shutdownNetworkServers()];
+                                    case 2:
+                                        _a.sent();
+                                        return [3 /*break*/, 4];
+                                    case 3:
+                                        error_1 = _a.sent();
+                                        console.error(new Date(), 'Error closing network servers (SIGINT)', error_1);
+                                        return [3 /*break*/, 4];
+                                    case 4: return [4 /*yield*/, this.safeShutdown()];
+                                    case 5:
+                                        _a.sent();
+                                        return [2 /*return*/];
+                                }
+                            });
+                        }); });
+                        process.on('SIGTERM', function () { return __awaiter(_this, void 0, void 0, function () {
+                            var error_2;
+                            return __generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0:
+                                        this._rebootFlag = true;
+                                        _a.label = 1;
+                                    case 1:
+                                        _a.trys.push([1, 3, , 4]);
+                                        return [4 /*yield*/, this.shutdownNetworkServers()];
+                                    case 2:
+                                        _a.sent();
+                                        return [3 /*break*/, 4];
+                                    case 3:
+                                        error_2 = _a.sent();
+                                        console.error(new Date(), 'Error closing network servers (SIGTERM)', error_2);
+                                        return [3 /*break*/, 4];
+                                    case 4: return [4 /*yield*/, this.safeShutdown()];
+                                    case 5:
+                                        _a.sent();
+                                        return [2 /*return*/];
+                                }
+                            });
+                        }); });
+                        process.on('SIGQUIT', function () { return __awaiter(_this, void 0, void 0, function () {
+                            var error_3;
+                            return __generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0:
+                                        this._rebootFlag = true;
+                                        _a.label = 1;
+                                    case 1:
+                                        _a.trys.push([1, 3, , 4]);
+                                        return [4 /*yield*/, this.shutdownNetworkServers()];
+                                    case 2:
+                                        _a.sent();
+                                        return [3 /*break*/, 4];
+                                    case 3:
+                                        error_3 = _a.sent();
+                                        console.error(new Date(), 'Error closing network servers (SIGQUIT)', error_3);
+                                        return [3 /*break*/, 4];
+                                    case 4: return [4 /*yield*/, this.safeShutdown()];
+                                    case 5:
+                                        _a.sent();
+                                        return [2 /*return*/];
+                                }
+                            });
+                        }); });
+                        if (this.LOGGER === 'DEBUG') {
+                            console.log('Starting ResolveIO Server');
+                        }
+                        if (this._isWorkersEnabled) {
+                            if (this._isWorkerInstance) {
+                                workerRole = this.resolveWorkerRole();
+                                workerIndex = this.normalizeWorkerSelectorValue(process.env.WORKER_INDEX) || 'UNKNOWN';
+                                workerInstance = this.normalizeWorkerSelectorValue(process.env.NODE_APP_INSTANCE) || 'UNKNOWN';
+                                console.log("Running as Worker: ".concat(workerRole), workerIndex, workerInstance);
+                                this._methodManager = method_manager_1.MethodManager.create(null, this._monitorManagerFunction, this._isWorkersEnabled, this._isWorkerInstance);
+                                this._subscriptionManager = subscription_manager_1.SubscriptionManager.createPublicationRegistry(resolveio_server_app_1.ResolveIOServer.getServerConfig());
+                                this._workerServerManager = worker_server_manager_1.WorkerServerManager.create(this._methodManager, this.getServerConfig());
+                                if (process.env.WORKER_INDEX === '0') {
+                                    this._cronManager = cron_manager_1.CronManager.create();
+                                }
+                            }
+                            else {
+                                console.log('Running as a Server instance', process.env.NODE_APP_INSTANCE);
+                                this._websocketManager = websocket_manager_1.WebSocketManager.create(this);
+                                this._methodManager = method_manager_1.MethodManager.create(this._websocketManager, this._monitorManagerFunction, this._isWorkersEnabled, this._isWorkerInstance);
+                                this._workerDispatcherManager = worker_dispatcher_manager_1.WorkerDispatcherManager.create(this._websocketManager, this._methodManager);
+                                this._subscriptionManager = subscription_manager_1.SubscriptionManager.create(this._serverWSS, resolveio_server_app_1.ResolveIOServer.getServerConfig(), this._monitorManagerFunction);
+                                this.startServerInstance();
+                                this.listen();
+                            }
+                        }
+                        else {
+                            console.log('Running with Workers Disabled', process.env.NODE_APP_INSTANCE);
+                            this._websocketManager = websocket_manager_1.WebSocketManager.create(this);
+                            this._methodManager = method_manager_1.MethodManager.create(this._websocketManager, this._monitorManagerFunction, this._isWorkersEnabled, this._isWorkerInstance);
+                            this._subscriptionManager = subscription_manager_1.SubscriptionManager.create(this._serverWSS, resolveio_server_app_1.ResolveIOServer.getServerConfig(), this._monitorManagerFunction);
+                            this._cronManager = cron_manager_1.CronManager.create();
+                            this.startServerInstance();
+                            this.listen();
+                        }
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    ResolveIOMainServer.prototype.shutdownNetworkServers = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.closeWebSocketServerGracefully()];
+                    case 1:
+                        _a.sent();
+                        return [4 /*yield*/, this.closeHttpServerGracefully()];
+                    case 2:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    ResolveIOMainServer.prototype.closeHttpServerGracefully = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!this._serverHTTP) {
+                            return [2 /*return*/];
+                        }
+                        if (!(this._httpServerClosePromise !== null)) return [3 /*break*/, 2];
+                        return [4 /*yield*/, this._httpServerClosePromise];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                    case 2:
+                        // eslint-disable-next-line no-restricted-syntax
+                        this._httpServerClosePromise = new Promise(function (resolve) {
+                            try {
+                                _this._serverHTTP.close(function (error) {
+                                    if (error && error['code'] !== 'ERR_SERVER_NOT_RUNNING') {
+                                        console.error(new Date(), 'Error closing HTTP server before shutdown', error);
+                                    }
+                                    resolve();
+                                });
+                            }
+                            catch (error) {
+                                if (error && error['code'] !== 'ERR_SERVER_NOT_RUNNING') {
+                                    console.error(new Date(), 'Error closing HTTP server before shutdown', error);
+                                }
+                                resolve();
+                            }
+                        });
+                        return [4 /*yield*/, this._httpServerClosePromise];
+                    case 3:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    ResolveIOMainServer.prototype.closeWebSocketServerGracefully = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!this._serverWSS) {
+                            return [2 /*return*/];
+                        }
+                        if (!(this._websocketServerClosePromise !== null)) return [3 /*break*/, 2];
+                        return [4 /*yield*/, this._websocketServerClosePromise];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                    case 2:
+                        this._serverWSS.clients.forEach(function (ws) {
+                            try {
+                                ws.close(1001, 'Server restarting');
+                            }
+                            catch (error) {
+                                console.error(new Date(), 'Error closing WebSocket client before shutdown', error);
+                            }
+                        });
+                        // eslint-disable-next-line no-restricted-syntax
+                        this._websocketServerClosePromise = new Promise(function (resolve) {
+                            try {
+                                _this._serverWSS.close(function (error) {
+                                    if (error) {
+                                        console.error(new Date(), 'Error closing WebSocket server before shutdown', error);
+                                    }
+                                    resolve();
+                                });
+                            }
+                            catch (error) {
+                                console.error(new Date(), 'Error closing WebSocket server before shutdown', error);
+                                resolve();
+                            }
+                        });
+                        return [4 /*yield*/, this._websocketServerClosePromise];
+                    case 3:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    ResolveIOMainServer.prototype.startServerInstance = function () {
+        // Start express app
+        this._app = express();
+        // Use built-in express JSON parser
+        this._app.use(express.json({
+            limit: '50mb',
+            reviver: common_1.dateReviver // Note: 'reviver' is an option for JSON.parse, which can be passed here
+        }));
+        // Use built-in express URL-encoded parser
+        this._app.use(express.urlencoded({
+            limit: '50mb',
+            extended: true, // `extended` must be explicitly true or false
+            parameterLimit: 1000000
+        }));
+        this._app.use(xmlParser());
+        // Set port
+        this._portHTTP = process.env.NODE_APP_INSTANCE ? parseInt('808' + process.env.NODE_APP_INSTANCE) : 8080;
+        if (this.LOGGER === 'DEBUG') {
+            console.log('Setup ports');
+        }
+        // Create http server and websock server
+        this.createServer();
+        if (this.LOGGER === 'DEBUG') {
+            console.log('Create server');
+        }
+        // Set CORS
+        this._app.use(function (req, res, next) {
+            res.setHeader('Access-Control-Allow-Origin', '*');
+            res.setHeader('Access-Control-Allow-Methods', 'GET, POST');
+            res.setHeader('Access-Control-Allow-Headers', 'X-Requested-With,content-type');
+            res.setHeader('Access-Control-Allow-Credentials', 'false');
+            next();
+        });
+        if (this.LOGGER === 'DEBUG') {
+            console.log('Setup cors');
+        }
+        this.installDynamicAppGatewayMiddleware();
+        // Set up http login route
+        (0, auth_1.setupAuthRoutes)(this, this._app, resolveio_server_app_1.ResolveIOServer.getServerConfig());
+        (0, health_1.setupHealthRoutes)(this._app);
+        (0, slow_query_publication_1.setupSlowQueryPublicationRoutes)(this._app);
+        if (resolveio_server_app_1.ResolveIOServer.getServerConfig()['CLIENT_NAME'] === 'ResolveIO' || this.publicProgram) {
+            (0, home_1.setupHomeRoutes)(this, this._app, resolveio_server_app_1.ResolveIOServer.getServerConfig());
+        }
+        if (this.LOGGER === 'DEBUG') {
+            console.log('Setup express routes');
+        }
+    };
+    ResolveIOMainServer.prototype.installDynamicAppGatewayMiddleware = function () {
+        var _this = this;
+        if (!this._dynamicAppGatewayEnabled) {
+            return;
+        }
+        this._app.use(function (req, res, next) { return __awaiter(_this, void 0, void 0, function () {
+            var appId, appDoc, allowedHosts, controlHosts, requestHost, originHeader, originHost, expectedToken, providedToken, error_4;
+            var _a, _b, _c;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        appId = this.extractDynamicAppGatewayId(req);
+                        if (!appId) {
+                            next();
+                            return [2 /*return*/];
+                        }
+                        _d.label = 1;
+                    case 1:
+                        _d.trys.push([1, 3, , 4]);
+                        return [4 /*yield*/, this.resolveCachedDynamicAppGatewayApp(appId)];
+                    case 2:
+                        appDoc = _d.sent();
+                        if (!appDoc) {
+                            res.status(404).send(JSON.stringify({
+                                error: true,
+                                result: 'App not found.'
+                            }));
+                            return [2 /*return*/];
+                        }
+                        allowedHosts = this.resolveDynamicAppAllowedHosts(appDoc);
+                        controlHosts = this.resolveDynamicAppControlHosts();
+                        requestHost = this.normalizeHostname(this.normalizeHeaderValue((_a = req.headers) === null || _a === void 0 ? void 0 : _a['x-forwarded-host'])
+                            || this.normalizeHeaderValue((_b = req.headers) === null || _b === void 0 ? void 0 : _b.host));
+                        originHeader = this.normalizeHeaderValue((_c = req.headers) === null || _c === void 0 ? void 0 : _c.origin);
+                        originHost = this.resolveOriginHostname(originHeader);
+                        if (requestHost && controlHosts.has(requestHost) && !this.isLocalHostname(requestHost)) {
+                            res.status(403).send(JSON.stringify({
+                                error: true,
+                                result: 'App API must be requested from an app domain.'
+                            }));
+                            return [2 /*return*/];
+                        }
+                        if (requestHost && !allowedHosts.has(requestHost) && !this.isLocalHostname(requestHost)) {
+                            res.status(403).send(JSON.stringify({
+                                error: true,
+                                result: 'Host not allowed for app API.'
+                            }));
+                            return [2 /*return*/];
+                        }
+                        if (originHost && controlHosts.has(originHost) && !this.isLocalHostname(originHost)) {
+                            res.status(403).send(JSON.stringify({
+                                error: true,
+                                result: 'App API origin must be an app domain.'
+                            }));
+                            return [2 /*return*/];
+                        }
+                        if (originHost && !allowedHosts.has(originHost)) {
+                            res.status(403).send(JSON.stringify({
+                                error: true,
+                                result: 'Origin not allowed for app API.'
+                            }));
+                            return [2 /*return*/];
+                        }
+                        if (originHeader) {
+                            this.applyDynamicAppGatewayCorsHeaders(res, originHeader);
+                        }
+                        if (req.method === 'OPTIONS') {
+                            res.status(204).end();
+                            return [2 /*return*/];
+                        }
+                        expectedToken = this.normalizeHeaderValue(appDoc === null || appDoc === void 0 ? void 0 : appDoc.rio_token);
+                        if (!expectedToken) {
+                            res.status(500).send(JSON.stringify({
+                                error: true,
+                                result: 'App token is not configured.'
+                            }));
+                            return [2 /*return*/];
+                        }
+                        providedToken = this.resolveDynamicAppGatewayToken(req);
+                        if (!providedToken || providedToken !== expectedToken) {
+                            res.status(401).send(JSON.stringify({
+                                error: true,
+                                result: 'Invalid or missing RIO token.'
+                            }));
+                            return [2 /*return*/];
+                        }
+                        next();
+                        return [3 /*break*/, 4];
+                    case 3:
+                        error_4 = _d.sent();
+                        console.error(new Date(), '[DynamicAppGateway] middleware failure', error_4);
+                        res.status(500).send(JSON.stringify({
+                            error: true,
+                            result: (error_4 === null || error_4 === void 0 ? void 0 : error_4.message) || 'Dynamic app gateway error.'
+                        }));
+                        return [3 /*break*/, 4];
+                    case 4: return [2 /*return*/];
+                }
+            });
+        }); });
+    };
+    ResolveIOMainServer.prototype.resolveDynamicAppGatewayEnabled = function () {
+        var _a;
+        var config = resolveio_server_app_1.ResolveIOServer.getServerConfig() || {};
+        var raw = (_a = config['AI_CODER_DYNAMIC_APP_GATEWAY']) !== null && _a !== void 0 ? _a : process.env.AI_CODER_DYNAMIC_APP_GATEWAY;
+        if (raw !== undefined && raw !== null && "".concat(raw).trim() !== '') {
+            return this.parseDebugFlag(raw);
+        }
+        var urls = [
+            config['ROOT_URL'],
+            config['SEC_ROOT_URL'],
+            config['SERVER_URL'],
+            process.env.ROOT_URL,
+            process.env.SEC_ROOT_URL,
+            process.env.SERVER_URL
+        ]
+            .map(function (value) { return "".concat(value || '').trim().toLowerCase(); })
+            .filter(Boolean);
+        return urls.some(function (value) { return value.includes('aicoder'); });
+    };
+    ResolveIOMainServer.prototype.extractDynamicAppGatewayId = function (req) {
+        var rawPath = "".concat(req.originalUrl || req.url || req.path || '');
+        var normalizedPath = rawPath.split('?')[0];
+        if (!normalizedPath.startsWith('/api/apps/')) {
+            return '';
+        }
+        var parts = normalizedPath.split('/').filter(Boolean);
+        if (parts.length < 3) {
+            return '';
+        }
+        return "".concat(parts[2] || '').trim();
+    };
+    ResolveIOMainServer.prototype.resolveDynamicAppGatewayToken = function (req) {
+        var e_1, _a, e_2, _b, e_3, _c;
+        var _d, _e, _f, _g, _h;
+        var authHeader = this.normalizeHeaderValue(((_d = req.headers) === null || _d === void 0 ? void 0 : _d.authorization) || ((_e = req.headers) === null || _e === void 0 ? void 0 : _e.Authorization));
+        if (authHeader) {
+            var bearerMatch = authHeader.match(/^bearer\s+(.+)$/i);
+            if (bearerMatch && bearerMatch[1]) {
+                return bearerMatch[1].trim();
+            }
+        }
+        var headerCandidates = [
+            (_f = req.headers) === null || _f === void 0 ? void 0 : _f['x-rio-token'],
+            (_g = req.headers) === null || _g === void 0 ? void 0 : _g['x-app-token'],
+            (_h = req.headers) === null || _h === void 0 ? void 0 : _h['x-api-key']
+        ];
+        try {
+            for (var headerCandidates_1 = __values(headerCandidates), headerCandidates_1_1 = headerCandidates_1.next(); !headerCandidates_1_1.done; headerCandidates_1_1 = headerCandidates_1.next()) {
+                var candidate = headerCandidates_1_1.value;
+                var value = this.normalizeHeaderValue(candidate);
+                if (value) {
+                    return value;
+                }
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (headerCandidates_1_1 && !headerCandidates_1_1.done && (_a = headerCandidates_1.return)) _a.call(headerCandidates_1);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        var body = req.body || {};
+        var query = req.query || {};
+        var bodyCandidates = [body.rioToken, body.rio_token, body.apiKey, body.token];
+        try {
+            for (var bodyCandidates_1 = __values(bodyCandidates), bodyCandidates_1_1 = bodyCandidates_1.next(); !bodyCandidates_1_1.done; bodyCandidates_1_1 = bodyCandidates_1.next()) {
+                var candidate = bodyCandidates_1_1.value;
+                var value = this.normalizeHeaderValue(candidate);
+                if (value) {
+                    return value;
+                }
+            }
+        }
+        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+        finally {
+            try {
+                if (bodyCandidates_1_1 && !bodyCandidates_1_1.done && (_b = bodyCandidates_1.return)) _b.call(bodyCandidates_1);
+            }
+            finally { if (e_2) throw e_2.error; }
+        }
+        var queryCandidates = [query.rioToken, query.rio_token, query.apiKey, query.token];
+        try {
+            for (var queryCandidates_1 = __values(queryCandidates), queryCandidates_1_1 = queryCandidates_1.next(); !queryCandidates_1_1.done; queryCandidates_1_1 = queryCandidates_1.next()) {
+                var candidate = queryCandidates_1_1.value;
+                var value = this.normalizeHeaderValue(candidate);
+                if (value) {
+                    return value;
+                }
+            }
+        }
+        catch (e_3_1) { e_3 = { error: e_3_1 }; }
+        finally {
+            try {
+                if (queryCandidates_1_1 && !queryCandidates_1_1.done && (_c = queryCandidates_1.return)) _c.call(queryCandidates_1);
+            }
+            finally { if (e_3) throw e_3.error; }
+        }
+        return '';
+    };
+    ResolveIOMainServer.prototype.normalizeHeaderValue = function (value) {
+        if (Array.isArray(value)) {
+            return value.map(function (entry) { return "".concat(entry || '').trim(); }).filter(Boolean).join(',');
+        }
+        return "".concat(value || '').trim();
+    };
+    ResolveIOMainServer.prototype.normalizeHostname = function (value) {
+        var raw = "".concat(value || '').trim();
+        if (!raw) {
+            return '';
+        }
+        var candidate = raw.split(',')[0].trim();
+        if (!candidate) {
+            return '';
+        }
+        try {
+            if (candidate.startsWith('http://') || candidate.startsWith('https://')) {
+                return new url_1.URL(candidate).hostname.toLowerCase();
+            }
+            if (candidate.includes('/')) {
+                return new url_1.URL("http://".concat(candidate)).hostname.toLowerCase();
+            }
+        }
+        catch (_a) { }
+        candidate = candidate.replace(/^\[/, '').replace(/\]$/, '');
+        var lastColon = candidate.lastIndexOf(':');
+        if (lastColon > -1 && candidate.indexOf(':') === lastColon) {
+            candidate = candidate.slice(0, lastColon);
+        }
+        return candidate.toLowerCase();
+    };
+    ResolveIOMainServer.prototype.resolveOriginHostname = function (origin) {
+        var raw = "".concat(origin || '').trim();
+        if (!raw) {
+            return '';
+        }
+        try {
+            return new url_1.URL(raw).hostname.toLowerCase();
+        }
+        catch (_a) {
+            return this.normalizeHostname(raw);
+        }
+    };
+    ResolveIOMainServer.prototype.isLocalHostname = function (hostname) {
+        var normalized = this.normalizeHostname(hostname);
+        return normalized === 'localhost' || normalized === '127.0.0.1' || normalized === '::1';
+    };
+    ResolveIOMainServer.prototype.resolveDynamicAppControlHosts = function () {
+        var e_4, _a;
+        var config = resolveio_server_app_1.ResolveIOServer.getServerConfig() || {};
+        var hosts = new Set();
+        var candidates = [
+            config['ROOT_URL'],
+            config['SEC_ROOT_URL'],
+            config['SERVER_URL'],
+            process.env.ROOT_URL,
+            process.env.SEC_ROOT_URL,
+            process.env.SERVER_URL,
+            process.env.AI_CODER_ROOT_URL,
+            process.env.AI_CODER_SEC_ROOT_URL,
+            process.env.AI_CODER_SERVER_URL
+        ];
+        try {
+            for (var candidates_1 = __values(candidates), candidates_1_1 = candidates_1.next(); !candidates_1_1.done; candidates_1_1 = candidates_1.next()) {
+                var candidate = candidates_1_1.value;
+                var normalized = this.normalizeHostname("".concat(candidate || ''));
+                if (normalized) {
+                    hosts.add(normalized);
+                }
+            }
+        }
+        catch (e_4_1) { e_4 = { error: e_4_1 }; }
+        finally {
+            try {
+                if (candidates_1_1 && !candidates_1_1.done && (_a = candidates_1.return)) _a.call(candidates_1);
+            }
+            finally { if (e_4) throw e_4.error; }
+        }
+        return hosts;
+    };
+    ResolveIOMainServer.prototype.resolveDynamicAppAllowedHosts = function (appDoc) {
+        var e_5, _a;
+        var hosts = new Set();
+        var candidates = [
+            appDoc === null || appDoc === void 0 ? void 0 : appDoc.domain,
+            appDoc === null || appDoc === void 0 ? void 0 : appDoc.backend_domain
+        ];
+        if ((appDoc === null || appDoc === void 0 ? void 0 : appDoc.subdomain) && (appDoc === null || appDoc === void 0 ? void 0 : appDoc.domain_base)) {
+            candidates.push("".concat(appDoc.subdomain, ".").concat(appDoc.domain_base));
+        }
+        try {
+            for (var candidates_2 = __values(candidates), candidates_2_1 = candidates_2.next(); !candidates_2_1.done; candidates_2_1 = candidates_2.next()) {
+                var candidate = candidates_2_1.value;
+                var normalized = this.normalizeHostname("".concat(candidate || ''));
+                if (normalized) {
+                    hosts.add(normalized);
+                }
+            }
+        }
+        catch (e_5_1) { e_5 = { error: e_5_1 }; }
+        finally {
+            try {
+                if (candidates_2_1 && !candidates_2_1.done && (_a = candidates_2.return)) _a.call(candidates_2);
+            }
+            finally { if (e_5) throw e_5.error; }
+        }
+        return hosts;
+    };
+    ResolveIOMainServer.prototype.applyDynamicAppGatewayCorsHeaders = function (res, origin) {
+        res.setHeader('Access-Control-Allow-Origin', origin);
+        res.setHeader('Vary', 'Origin');
+        res.setHeader('Access-Control-Allow-Methods', 'GET, POST, PUT, PATCH, DELETE, OPTIONS');
+        res.setHeader('Access-Control-Allow-Headers', 'Origin, X-Requested-With, Content-Type, Accept, Authorization, X-Rio-Token, X-API-Key');
+        res.setHeader('Access-Control-Allow-Credentials', 'true');
+        res.setHeader('Access-Control-Max-Age', '600');
+    };
+    ResolveIOMainServer.prototype.resolveCachedDynamicAppGatewayApp = function (appId) {
+        return __awaiter(this, void 0, void 0, function () {
+            var now, cached, db, appCollection, appDoc, generated;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        now = Date.now();
+                        cached = this._dynamicAppGatewayCache.get(appId);
+                        if (cached && cached.expiresAt > now) {
+                            return [2 /*return*/, cached.app];
+                        }
+                        db = resolveio_server_app_1.ResolveIOServer.getMainDB();
+                        if (!db) {
+                            return [2 /*return*/, null];
+                        }
+                        appCollection = db.collection('ai-coder-apps');
+                        return [4 /*yield*/, appCollection.findOne({ _id: appId }, {
+                                projection: {
+                                    _id: 1,
+                                    domain: 1,
+                                    backend_domain: 1,
+                                    subdomain: 1,
+                                    domain_base: 1,
+                                    rio_token: 1
+                                }
+                            })];
+                    case 1:
+                        appDoc = _a.sent();
+                        if (!appDoc) {
+                            this._dynamicAppGatewayCache.delete(appId);
+                            return [2 /*return*/, null];
+                        }
+                        if (!!this.normalizeHeaderValue(appDoc.rio_token)) return [3 /*break*/, 3];
+                        generated = crypto.randomBytes(32).toString('hex');
+                        return [4 /*yield*/, appCollection.updateOne({ _id: appId }, {
+                                $set: {
+                                    rio_token: generated,
+                                    updatedAt: new Date()
+                                }
+                            })];
+                    case 2:
+                        _a.sent();
+                        appDoc.rio_token = generated;
+                        _a.label = 3;
+                    case 3:
+                        this._dynamicAppGatewayCache.set(appId, {
+                            expiresAt: now + this._dynamicAppGatewayCacheMs,
+                            app: appDoc
+                        });
+                        return [2 /*return*/, appDoc];
+                }
+            });
+        });
+    };
+    ResolveIOMainServer.prototype.safeShutdown = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a;
+            var _this = this;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (!this._safeShutdown) {
+                            console.log(new Date(), 'Safe Shutdown Command Received');
+                        }
+                        if (!(!this._monitorManagerFunction.getActiveMonitorFunctions().length
+                            && !this._offlineUpdates.length && (!this._workerDispatcherManager || this._workerDispatcherManager.isSafeShutdown()))) return [3 /*break*/, 7];
+                        if (!resolveio_server_app_1.ResolveIOServer.getMongoConnection()) return [3 /*break*/, 5];
+                        _b.label = 1;
+                    case 1:
+                        _b.trys.push([1, 3, , 4]);
+                        return [4 /*yield*/, resolveio_server_app_1.ResolveIOServer.getMongoConnection().close(false)];
+                    case 2:
+                        _b.sent();
+                        console.log(new Date(), 'Safe Exit Complete, Process Exit');
+                        process.exit(0);
+                        return [3 /*break*/, 4];
+                    case 3:
+                        _a = _b.sent();
+                        process.exit(1);
+                        return [3 /*break*/, 4];
+                    case 4:
+                        ;
+                        return [3 /*break*/, 6];
+                    case 5:
+                        process.exit(0);
+                        _b.label = 6;
+                    case 6: return [3 /*break*/, 8];
+                    case 7:
+                        if (!this._safeShutdown) {
+                            this._safeShutdown = true;
+                            setTimeout(function () {
+                                _this._safeShutdown = false;
+                            }, 1000);
+                            console.log(new Date(), 'Safe Exit In Progress', this._monitorManagerFunction.getActiveMonitorFunctions().length, this._offlineUpdates.length);
+                        }
+                        setImmediate(function () { return __awaiter(_this, void 0, void 0, function () {
+                            return __generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0: return [4 /*yield*/, this.safeShutdown()];
+                                    case 1:
+                                        _a.sent();
+                                        return [2 /*return*/];
+                                }
+                            });
+                        }); });
+                        _b.label = 8;
+                    case 8: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    ResolveIOMainServer.prototype.getIsWorkersEnabled = function () {
+        return this._isWorkersEnabled;
+    };
+    ResolveIOMainServer.prototype.getIsWorkerInstance = function () {
+        return this._isWorkerInstance;
+    };
+    ResolveIOMainServer.prototype.getWSList = function () {
+        var res = [];
+        this._serverWSS.clients.forEach(function (ws) {
+            res.push(ws['id_socket']);
+        });
+        return res;
+    };
+    ResolveIOMainServer.prototype.getWSUserList = function () {
+        var res = [];
+        this._serverWSS.clients.forEach(function (ws) {
+            res.push(ws['id_user']);
+        });
+        return res;
+    };
+    ResolveIOMainServer.prototype.getHTTPServer = function () {
+        return this._serverHTTP;
+    };
+    ResolveIOMainServer.prototype.getCronManager = function () {
+        return this._cronManager;
+    };
+    ResolveIOMainServer.prototype.reportServerError = function (subject_1, correlationId_1, context_1, meta_1) {
+        return __awaiter(this, arguments, void 0, function (subject, correlationId, context, meta, severity, stackOverride) {
+            var config, metadata;
+            if (severity === void 0) { severity = 'error'; }
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        config = resolveio_server_app_1.ResolveIOServer.getServerConfig();
+                        metadata = Object.assign({}, meta || {});
+                        if (correlationId && !metadata.correlationId) {
+                            metadata.correlationId = correlationId;
+                        }
+                        return [4 /*yield*/, error_reporter_1.ErrorReporter.report({
+                                sourceApp: 'server-app',
+                                message: subject,
+                                environment: (config === null || config === void 0 ? void 0 : config.ROOT_URL) || process.env.NODE_ENV || 'unknown',
+                                clientSlug: resolveio_server_app_1.ResolveIOServer.getClientName(),
+                                clientName: config === null || config === void 0 ? void 0 : config.CLIENT_NAME,
+                                severity: severity,
+                                stack: stackOverride || (typeof (context === null || context === void 0 ? void 0 : context.stack) === 'string' ? context.stack : undefined),
+                                context: context,
+                                metadata: metadata,
+                                correlationId: correlationId
+                            })];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    ResolveIOMainServer.prototype.getMethodManager = function () {
+        return this._methodManager;
+    };
+    ResolveIOMainServer.prototype.getSubscriptionManager = function () {
+        return this._subscriptionManager;
+    };
+    ResolveIOMainServer.prototype.getMonitorManager = function () {
+        return this._monitorManager;
+    };
+    ResolveIOMainServer.prototype.getRebootFlag = function () {
+        return this._rebootFlag;
+    };
+    ResolveIOMainServer.prototype.getWebSocketManager = function () {
+        return this._websocketManager;
+    };
+    ResolveIOMainServer.prototype.createServer = function () {
+        var _this = this;
+        this._serverHTTP = (0, http_1.createServer)(this._app);
+        this._serverHTTP.keepAliveTimeout = 65000;
+        this._serverHTTP.headersTimeout = 66000;
+        this._serverWSS = new WebSocket.Server({
+            server: this._serverHTTP,
+            verifyClient: this.publicProgram ? null : function (info, cb) {
+                if (_this._rebootFlag) {
+                    cb(false, 409, 'Unable To Process');
+                }
+                else {
+                    if (_this.LOGGER === 'DEBUG') {
+                        console.log('Verify Client', info, cb);
+                    }
+                    // If it's a worker, we might skip token checks or do a simple check:
+                    if (info.req.url && info.req.url.includes('workerToken=')) {
+                        var requestUrl = void 0;
+                        var rootUrl = resolveio_server_app_1.ResolveIOServer.getServerConfig()['ROOT_URL'] || 'http://localhost';
+                        try {
+                            requestUrl = new url_1.URL(info.req.url, rootUrl);
+                        }
+                        catch (_a) {
+                            cb(false, 400, 'Bad Request');
+                            return;
+                        }
+                        var workerToken = requestUrl.searchParams.get('workerToken') || '';
+                        var workerIndex = requestUrl.searchParams.get('workerIndex');
+                        var workerInstance = requestUrl.searchParams.get('workerInstance');
+                        var expectedWorkerToken = String(resolveio_server_app_1.ResolveIOServer.getServerConfig()['WORKER_TOKEN'] || '');
+                        if (workerToken === expectedWorkerToken) {
+                            if (workerIndex) {
+                                info.req['workerIndex'] = workerIndex;
+                            }
+                            if (workerInstance) {
+                                info.req['workerInstance'] = workerInstance;
+                            }
+                            cb(true);
+                        }
+                        else {
+                            cb(false, 401, 'Unauthorized');
+                        }
+                        return;
+                    }
+                    var protocolsHeader = info.req.headers['sec-websocket-protocol'];
+                    if (!protocolsHeader || typeof protocolsHeader !== 'string') {
+                        cb(false, 401, 'Unauthorized');
+                        return;
+                    }
+                    var infoData = protocolsHeader.split(/,/);
+                    if (!(0, common_1.isAllowedOrigin)(info.origin, resolveio_server_app_1.ResolveIOServer.getServerConfig())) {
+                        cb(false, 401, 'Unauthorized');
+                    }
+                    else {
+                        var token = infoData[0];
+                        if (!token) {
+                            cb(false, 401, 'Unauthorized');
+                        }
+                        else {
+                            jwt.verify(token, resolveio_server_app_1.ResolveIOServer.getServerConfig()['JWT_SECRET'], function (err, decoded) { return __awaiter(_this, void 0, void 0, function () {
+                                var user, socketAdmission, _a;
+                                return __generator(this, function (_b) {
+                                    switch (_b.label) {
+                                        case 0:
+                                            if (!err) return [3 /*break*/, 1];
+                                            cb(false, 401, 'Unauthorized');
+                                            return [3 /*break*/, 8];
+                                        case 1:
+                                            info.req['id_user'] = decoded['id_user'];
+                                            _b.label = 2;
+                                        case 2:
+                                            _b.trys.push([2, 7, , 8]);
+                                            return [4 /*yield*/, user_collection_1.Users.findById(decoded['id_user'])];
+                                        case 3:
+                                            user = _b.sent();
+                                            if (!user) return [3 /*break*/, 5];
+                                            return [4 /*yield*/, this.evaluateClientSocketAdmission(decoded['id_user'], info.req)];
+                                        case 4:
+                                            socketAdmission = _b.sent();
+                                            if (!socketAdmission.allowed) {
+                                                cb(false, socketAdmission.statusCode, socketAdmission.message || 'Socket connection rejected.');
+                                                return [2 /*return*/];
+                                            }
+                                            info.req['user'] = user.fullname;
+                                            info.req['user_readonly'] = user.readonly || false;
+                                            info.req['doc_user'] = user;
+                                            info.req['client_ip'] = socketAdmission.clientIp;
+                                            cb(true);
+                                            return [3 /*break*/, 6];
+                                        case 5:
+                                            cb(false);
+                                            _b.label = 6;
+                                        case 6: return [3 /*break*/, 8];
+                                        case 7:
+                                            _a = _b.sent();
+                                            cb(false);
+                                            return [3 /*break*/, 8];
+                                        case 8: return [2 /*return*/];
+                                    }
+                                });
+                            }); });
+                        }
+                    }
+                }
+            }
+        });
+    };
+    /**
+     * Listen for connections from clients or workers.
+     */
+    ResolveIOMainServer.prototype.listen = function () {
+        var _this = this;
+        var host = process.env.RESOLVEIO_BIND_HOST || '127.0.0.1';
+        this._serverHTTP.listen(this._portHTTP, host, function () {
+            console.log('Running HTTP/WS server on port %s', _this._portHTTP);
+        });
+        this._serverWSS.on('connection', function (ws, req) { return __awaiter(_this, void 0, void 0, function () {
+            var workerId_1, workerIndex, workerInstance, rootUrl, requestUrl, workerIndexForLog, workerInstanceForLog, interval_1, lastComm_1, missedPongs_1, heartbeatIntervalMs, maxMissedPongs_1, maxSilenceMs_1, socketAdmission, socketPolicyError_1;
+            var _this = this;
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (!(req.url && req.url.includes('workerToken='))) return [3 /*break*/, 1];
+                        workerId_1 = (0, common_1.objectIdHexString)();
+                        ws['id_worker'] = workerId_1;
+                        workerIndex = null;
+                        workerInstance = null;
+                        ws['supportsBinary'] = true;
+                        if (req.url) {
+                            rootUrl = resolveio_server_app_1.ResolveIOServer.getServerConfig()['ROOT_URL'] || 'http://localhost';
+                            try {
+                                requestUrl = new url_1.URL(req.url, rootUrl);
+                                workerIndex = requestUrl.searchParams.get('workerIndex');
+                                workerInstance = requestUrl.searchParams.get('workerInstance');
+                            }
+                            catch (_c) {
+                                workerIndex = null;
+                                workerInstance = null;
+                            }
+                        }
+                        if (!workerIndex && req['workerIndex']) {
+                            workerIndex = req['workerIndex'];
+                        }
+                        if (!workerInstance && req['workerInstance']) {
+                            workerInstance = req['workerInstance'];
+                        }
+                        if (workerIndex !== null && workerIndex !== undefined) {
+                            ws['workerIndex'] = workerIndex;
+                        }
+                        if (workerInstance !== null && workerInstance !== undefined) {
+                            ws['workerInstance'] = workerInstance;
+                        }
+                        workerIndexForLog = ws['workerIndex'] || 'UNKNOWN';
+                        workerInstanceForLog = ws['workerInstance'] || 'UNKNOWN';
+                        console.log(new Date(), 'Worker Connected', workerIndexForLog, workerInstanceForLog);
+                        this._workerDispatcherManager.addWorker(ws);
+                        interval_1 = null;
+                        lastComm_1 = new Date();
+                        missedPongs_1 = 0;
+                        heartbeatIntervalMs = 30000;
+                        maxMissedPongs_1 = 2;
+                        maxSilenceMs_1 = heartbeatIntervalMs * (maxMissedPongs_1 + 1);
+                        this._workerDispatcherManager.sendWorkerPayload(ws, 'ping');
+                        interval_1 = setInterval(function () {
+                            var now = Date.now();
+                            var last = lastComm_1 ? lastComm_1.getTime() : 0;
+                            var silenceMs = last ? now - last : maxSilenceMs_1 + 1;
+                            if (silenceMs > maxSilenceMs_1 || missedPongs_1 > maxMissedPongs_1) {
+                                _this._workerDispatcherManager.disconnectWorker(ws['id_worker']);
+                                ws.close();
+                                return;
+                            }
+                            missedPongs_1 += 1;
+                            _this._workerDispatcherManager.sendWorkerPayload(ws, 'ping');
+                        }, heartbeatIntervalMs);
+                        ws.on('message', function (message) {
+                            lastComm_1 = new Date();
+                            if (typeof message === 'string') {
+                                if (message === 'ping') {
+                                    _this._workerDispatcherManager.sendWorkerPayload(ws, 'pong');
+                                }
+                                else if (message === 'pong') {
+                                    missedPongs_1 = 0;
+                                }
+                                else {
+                                    _this._workerDispatcherManager.handleWorkerMessage(ws['id_worker'], message);
+                                }
+                                return;
+                            }
+                            var buffer;
+                            if (Buffer.isBuffer(message)) {
+                                buffer = message;
+                            }
+                            else if (Array.isArray(message)) {
+                                var chunks = message;
+                                buffer = Buffer.concat(chunks);
+                            }
+                            else if (message instanceof ArrayBuffer) {
+                                buffer = Buffer.from(message);
+                            }
+                            else if (ArrayBuffer.isView(message)) {
+                                var view = message;
+                                buffer = Buffer.from(view.buffer, view.byteOffset, view.byteLength);
+                            }
+                            else {
+                                buffer = Buffer.from(message);
+                            }
+                            if (buffer.length === 4) {
+                                var heartbeat = buffer.toString('utf8');
+                                if (heartbeat === 'ping') {
+                                    _this._workerDispatcherManager.sendWorkerPayload(ws, 'pong');
+                                    return;
+                                }
+                                else if (heartbeat === 'pong') {
+                                    missedPongs_1 = 0;
+                                    return;
+                                }
+                            }
+                            _this._workerDispatcherManager.handleWorkerMessage(ws['id_worker'], buffer);
+                        });
+                        ws.on('close', function () {
+                            _this._workerDispatcherManager.disconnectWorker(ws['id_worker']);
+                            console.log(new Date(), 'Worker disconnected:', workerId_1);
+                            if (interval_1) {
+                                clearInterval(interval_1);
+                            }
+                        });
+                        ws.on('error', function (error) {
+                            _this._workerDispatcherManager.disconnectWorker(ws['id_worker']);
+                            console.error('Error on WS Worker', error);
+                            ws.close();
+                        });
+                        return [3 /*break*/, 6];
+                    case 1:
+                        // Normal client
+                        ws['id_socket'] = (0, common_1.objectIdHexString)();
+                        ws['supportsBinary'] = true;
+                        ws['id_user'] = req['id_user'];
+                        ws['user'] = req['user'];
+                        ws['user_readonly'] = req['user_readonly'];
+                        ws['doc_user'] = req['doc_user'];
+                        ws['client_ip'] = this.resolveClientIp(req);
+                        socketAdmission = void 0;
+                        _b.label = 2;
+                    case 2:
+                        _b.trys.push([2, 4, , 5]);
+                        return [4 /*yield*/, this.evaluateClientSocketAdmission(ws['id_user'], req)];
+                    case 3:
+                        socketAdmission = _b.sent();
+                        return [3 /*break*/, 5];
+                    case 4:
+                        socketPolicyError_1 = _b.sent();
+                        this.logConnectDebug('WS socket policy evaluation failed', {
+                            id_socket: ws['id_socket'],
+                            id_user: ws['id_user'],
+                            user: ws['user'],
+                            ip: ws['client_ip'],
+                            error: (socketPolicyError_1 === null || socketPolicyError_1 === void 0 ? void 0 : socketPolicyError_1.message) || socketPolicyError_1
+                        });
+                        try {
+                            ws.close(1011, 'Socket policy error');
+                        }
+                        catch (_d) { }
+                        return [2 /*return*/];
+                    case 5:
+                        if (!socketAdmission.allowed) {
+                            this.logConnectDebug('WS client rejected', {
+                                id_socket: ws['id_socket'],
+                                id_user: ws['id_user'],
+                                user: ws['user'],
+                                ip: ws['client_ip'],
+                                reason: socketAdmission.message
+                            });
+                            try {
+                                ws.close(1008, this.buildSocketLimitCloseReason());
+                            }
+                            catch (_e) { }
+                            return [2 /*return*/];
+                        }
+                        ws['client_ip'] = socketAdmission.clientIp || ws['client_ip'];
+                        this._websocketManager.addWebSocket(ws);
+                        this.logConnectDebug('WS client connected', {
+                            id_socket: ws['id_socket'],
+                            id_user: ws['id_user'],
+                            user: ws['user'],
+                            url: req === null || req === void 0 ? void 0 : req.url,
+                            ip: ws['client_ip'],
+                            origin: (_a = req === null || req === void 0 ? void 0 : req.headers) === null || _a === void 0 ? void 0 : _a.origin
+                        });
+                        setTimeout(function () { return __awaiter(_this, void 0, void 0, function () {
+                            return __generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0: return [4 /*yield*/, this.triggerClientHeartbeat(ws)];
+                                    case 1:
+                                        _a.sent();
+                                        return [2 /*return*/];
+                                }
+                            });
+                        }); }, this._clientHeartbeatInitialDelayMs);
+                        if (this.LOGGER === 'DEBUG') {
+                            console.log('Connection from user: ' + req['user']);
+                        }
+                        ws['isAlive'] = true;
+                        ws['retryCnt'] = 0;
+                        ws.on('pong', function () {
+                            ws['isAlive'] = true;
+                            ws['pongTime'] = new Date();
+                            if (ws['pingTime']) {
+                                ws['latency'] = moment.duration(moment(ws['pongTime']).diff(ws['pingTime'])).asMilliseconds();
+                                _this._subscriptionManager.loggedInLatency(ws);
+                            }
+                        });
+                        ws.on('message', function (message) { return __awaiter(_this, void 0, void 0, function () {
+                            var socketData, usedBinary, bufferPayload, decodeResult, decodeResult, decodeResult, view, decodeResult, e_6, correlationId, context;
+                            return __generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0:
+                                        this._debugMsgRecv += 1;
+                                        socketData = [];
+                                        usedBinary = false;
+                                        _a.label = 1;
+                                    case 1:
+                                        _a.trys.push([1, 2, , 4]);
+                                        if (typeof message === 'string') {
+                                            if (message === 'ping' || message === 'pong') {
+                                                socketData = message;
+                                            }
+                                            else {
+                                                socketData = JSON.parse(message, common_1.dateReviver);
+                                            }
+                                        }
+                                        else if (Buffer.isBuffer(message)) {
+                                            bufferPayload = message;
+                                            decodeResult = this.decodeBufferPayload(bufferPayload);
+                                            socketData = decodeResult.data;
+                                            usedBinary = decodeResult.usedBinary;
+                                        }
+                                        else if (Array.isArray(message)) {
+                                            bufferPayload = Buffer.concat(message);
+                                            decodeResult = this.decodeBufferPayload(bufferPayload);
+                                            socketData = decodeResult.data;
+                                            usedBinary = decodeResult.usedBinary;
+                                        }
+                                        else if (message instanceof ArrayBuffer) {
+                                            bufferPayload = Buffer.from(message);
+                                            decodeResult = this.decodeBufferPayload(bufferPayload);
+                                            socketData = decodeResult.data;
+                                            usedBinary = decodeResult.usedBinary;
+                                        }
+                                        else if (ArrayBuffer.isView(message)) {
+                                            view = message;
+                                            bufferPayload = Buffer.from(view.buffer, view.byteOffset, view.byteLength);
+                                            decodeResult = this.decodeBufferPayload(bufferPayload);
+                                            socketData = decodeResult.data;
+                                            usedBinary = decodeResult.usedBinary;
+                                        }
+                                        else {
+                                            throw new Error('Unsupported WebSocket message type: ' + typeof message);
+                                        }
+                                        return [3 /*break*/, 4];
+                                    case 2:
+                                        e_6 = _a.sent();
+                                        console.log('Error - WS message parse', e_6);
+                                        correlationId = (0, common_1.objectIdHexString)();
+                                        context = {
+                                            rawBinary: bufferPayload ? bufferPayload.toString('base64') : undefined,
+                                            rawMessage: typeof message === 'string' ? message : undefined,
+                                            error: e_6 instanceof Error ? { name: e_6.name, message: e_6.message, stack: e_6.stack } : e_6
+                                        };
+                                        return [4 /*yield*/, this.reportServerError('SERVER - JSON Parse Error - ' + resolveio_server_app_1.ResolveIOServer.getServerConfig()['CLIENT_NAME'], correlationId, context, { context: 'websocket-message-parse' }, 'error', e_6 instanceof Error ? e_6.stack : undefined)];
+                                    case 3:
+                                        _a.sent();
+                                        return [2 /*return*/];
+                                    case 4:
+                                        if (usedBinary) {
+                                            ws['supportsBinary'] = true;
+                                        }
+                                        // call our existing processSocketMessage
+                                        return [4 /*yield*/, this.processSocketMessage(ws, socketData)];
+                                    case 5:
+                                        // call our existing processSocketMessage
+                                        _a.sent();
+                                        return [2 /*return*/];
+                                }
+                            });
+                        }); })
+                            .on('end', function () {
+                            ws.close();
+                        })
+                            .on('error', function () {
+                            ws.close();
+                        })
+                            .on('close', function () { return __awaiter(_this, void 0, void 0, function () {
+                            return __generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0:
+                                        this.logConnectDebug('WS client closed', {
+                                            id_socket: ws['id_socket'],
+                                            id_user: ws['id_user'],
+                                            user: ws['user']
+                                        });
+                                        return [4 /*yield*/, this.unsubscribeWS(ws)];
+                                    case 1:
+                                        _a.sent();
+                                        return [2 /*return*/];
+                                }
+                            });
+                        }); });
+                        // Do not block message handler registration on DB write; this avoids losing
+                        // very-early subscription messages sent immediately after websocket open.
+                        setTimeout(function () { return __awaiter(_this, void 0, void 0, function () {
+                            var error_5;
+                            return __generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0:
+                                        _a.trys.push([0, 2, , 3]);
+                                        return [4 /*yield*/, this._subscriptionManager.createLoggedInUser(ws['id_socket'])];
+                                    case 1:
+                                        _a.sent();
+                                        return [3 /*break*/, 3];
+                                    case 2:
+                                        error_5 = _a.sent();
+                                        console.error(new Date(), 'Error creating logged-in user', ws['id_socket'], error_5);
+                                        this.logConnectDebug('Create logged-in user failed', {
+                                            id_socket: ws['id_socket'],
+                                            id_user: ws['id_user'],
+                                            user: ws['user'],
+                                            error: (error_5 === null || error_5 === void 0 ? void 0 : error_5.message) || error_5
+                                        });
+                                        return [3 /*break*/, 3];
+                                    case 3: return [2 /*return*/];
+                                }
+                            });
+                        }); }, 0);
+                        _b.label = 6;
+                    case 6: return [2 /*return*/];
+                }
+            });
+        }); });
+        // Keep alive timer
+        setInterval(function () { return __awaiter(_this, void 0, void 0, function () {
+            var _a, _b, ws, e_7_1;
+            var e_7, _c;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        _d.trys.push([0, 10, 11, 12]);
+                        _a = __values(this._serverWSS.clients), _b = _a.next();
+                        _d.label = 1;
+                    case 1:
+                        if (!!_b.done) return [3 /*break*/, 9];
+                        ws = _b.value;
+                        if (!(ws['pingTime'] && Date.now() - ws['pingTime'].getTime() >= this._clientHeartbeatIntervalMs)) return [3 /*break*/, 8];
+                        if (this.shouldDeferHeartbeat(ws)) {
+                            ws['isAlive'] = true;
+                            ws['retryCnt'] = 0;
+                            ws['pingTime'] = new Date();
+                            return [3 /*break*/, 8];
+                        }
+                        if (!(ws['isAlive'] === false)) return [3 /*break*/, 6];
+                        ws['retryCnt']++;
+                        if (!(ws['retryCnt'] >= 3)) return [3 /*break*/, 3];
+                        return [4 /*yield*/, this.unsubscribeWS(ws)];
+                    case 2:
+                        _d.sent();
+                        return [3 /*break*/, 5];
+                    case 3: return [4 /*yield*/, this.triggerClientHeartbeat(ws)];
+                    case 4:
+                        _d.sent();
+                        _d.label = 5;
+                    case 5: return [3 /*break*/, 8];
+                    case 6:
+                        ws['retryCnt'] = 0;
+                        ws['isAlive'] = false;
+                        return [4 /*yield*/, this.triggerClientHeartbeat(ws)];
+                    case 7:
+                        _d.sent();
+                        _d.label = 8;
+                    case 8:
+                        _b = _a.next();
+                        return [3 /*break*/, 1];
+                    case 9: return [3 /*break*/, 12];
+                    case 10:
+                        e_7_1 = _d.sent();
+                        e_7 = { error: e_7_1 };
+                        return [3 /*break*/, 12];
+                    case 11:
+                        try {
+                            if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
+                        }
+                        finally { if (e_7) throw e_7.error; }
+                        return [7 /*endfinally*/];
+                    case 12: return [2 /*return*/];
+                }
+            });
+        }); }, this._clientHeartbeatIntervalMs);
+    };
+    ResolveIOMainServer.prototype.processSocketMessage = function (ws, socketData) {
+        return __awaiter(this, void 0, void 0, function () {
+            var socketData_1, socketData_1_1, message, e_8_1;
+            var e_8, _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (typeof socketData === 'string' && socketData === 'ping') {
+                            if (ws && ws.readyState === WebSocket.OPEN) {
+                                ws.send('pong');
+                            }
+                            return [2 /*return*/];
+                        }
+                        else if (typeof socketData === 'string' && socketData === 'pong') {
+                            ws['isAlive'] = true;
+                            ws['pongTime'] = new Date();
+                            ws['latency'] = moment.duration(moment(ws['pongTime']).diff(ws['pingTime'])).asMilliseconds();
+                            this._subscriptionManager.loggedInLatency(ws);
+                            return [2 /*return*/];
+                        }
+                        // If the top level is not an array, let's skip
+                        if (!Array.isArray(socketData[0])) {
+                            console.log('Invalid message format (expected array of arrays)', socketData);
+                            this.logConnectDebug('Invalid message format', {
+                                id_socket: ws ? ws['id_socket'] : null,
+                                user: ws ? ws['user'] : null,
+                                preview: Array.isArray(socketData) ? socketData.slice(0, 3) : socketData
+                            });
+                            return [2 /*return*/];
+                        }
+                        _b.label = 1;
+                    case 1:
+                        _b.trys.push([1, 6, 7, 8]);
+                        socketData_1 = __values(socketData), socketData_1_1 = socketData_1.next();
+                        _b.label = 2;
+                    case 2:
+                        if (!!socketData_1_1.done) return [3 /*break*/, 5];
+                        message = socketData_1_1.value;
+                        return [4 /*yield*/, this.handleClientMessage(ws, message)];
+                    case 3:
+                        _b.sent();
+                        _b.label = 4;
+                    case 4:
+                        socketData_1_1 = socketData_1.next();
+                        return [3 /*break*/, 2];
+                    case 5: return [3 /*break*/, 8];
+                    case 6:
+                        e_8_1 = _b.sent();
+                        e_8 = { error: e_8_1 };
+                        return [3 /*break*/, 8];
+                    case 7:
+                        try {
+                            if (socketData_1_1 && !socketData_1_1.done && (_a = socketData_1.return)) _a.call(socketData_1);
+                        }
+                        finally { if (e_8) throw e_8.error; }
+                        return [7 /*endfinally*/];
+                    case 8: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    ResolveIOMainServer.prototype.decodeBufferPayload = function (buffer) {
+        var textPayload = buffer.toString('utf8');
+        if (this.looksLikeTextPayload(textPayload)) {
+            try {
+                return { data: this.parseTextFallback(textPayload), usedBinary: false };
+            }
+            catch (_a) {
+                // fall through to attempt MessagePack decode
+            }
+        }
+        try {
+            return { data: (0, msgpackr_1.unpack)(buffer), usedBinary: true };
+        }
+        catch (binaryErr) {
+            try {
+                return { data: this.parseTextFallback(textPayload), usedBinary: false };
+            }
+            catch (_b) {
+                throw binaryErr;
+            }
+        }
+    };
+    ResolveIOMainServer.prototype.parseTextFallback = function (rawMessage) {
+        if (rawMessage === 'ping' || rawMessage === 'pong') {
+            return rawMessage;
+        }
+        try {
+            return JSON.parse(rawMessage, common_1.dateReviver);
+        }
+        catch (err) {
+            throw err;
+        }
+    };
+    ResolveIOMainServer.prototype.looksLikeTextPayload = function (text) {
+        if (!text) {
+            return false;
+        }
+        var trimmed = text.trim();
+        if (!trimmed) {
+            return false;
+        }
+        var first = trimmed[0];
+        return first === '[' || first === '{' || first === '"' || first === 'p' || first === 'P';
+    };
+    ResolveIOMainServer.prototype.resolveConnectDebug = function () {
+        var _a, _b, _c;
+        var config = resolveio_server_app_1.ResolveIOServer.getServerConfig ? resolveio_server_app_1.ResolveIOServer.getServerConfig() : null;
+        var raw = (_c = (_b = (_a = process.env.WS_CONNECT_DEBUG) !== null && _a !== void 0 ? _a : process.env.CONNECT_DEBUG) !== null && _b !== void 0 ? _b : config === null || config === void 0 ? void 0 : config['WS_CONNECT_DEBUG']) !== null && _c !== void 0 ? _c : config === null || config === void 0 ? void 0 : config['CONNECT_DEBUG'];
+        return this.parseDebugFlag(raw);
+    };
+    ResolveIOMainServer.prototype.resolvePerfDebug = function () {
+        var _a, _b, _c;
+        var config = resolveio_server_app_1.ResolveIOServer.getServerConfig ? resolveio_server_app_1.ResolveIOServer.getServerConfig() : null;
+        var raw = (_c = (_b = (_a = process.env.PERF_DEBUG) !== null && _a !== void 0 ? _a : process.env.CPU_DEBUG) !== null && _b !== void 0 ? _b : config === null || config === void 0 ? void 0 : config['PERF_DEBUG']) !== null && _c !== void 0 ? _c : config === null || config === void 0 ? void 0 : config['CPU_DEBUG'];
+        return this.parseDebugFlag(raw);
+    };
+    ResolveIOMainServer.prototype.resolveCpuProfileOnStart = function () {
+        var _a, _b, _c;
+        var config = resolveio_server_app_1.ResolveIOServer.getServerConfig ? resolveio_server_app_1.ResolveIOServer.getServerConfig() : null;
+        var raw = (_c = (_b = (_a = process.env.CPU_PROFILE_ON_START) !== null && _a !== void 0 ? _a : process.env.CPU_PROFILE_START) !== null && _b !== void 0 ? _b : config === null || config === void 0 ? void 0 : config['CPU_PROFILE_ON_START']) !== null && _c !== void 0 ? _c : config === null || config === void 0 ? void 0 : config['CPU_PROFILE_START'];
+        return this.parseDebugFlag(raw);
+    };
+    ResolveIOMainServer.prototype.resolveCpuProfileAuto = function () {
+        var _a;
+        var config = resolveio_server_app_1.ResolveIOServer.getServerConfig ? resolveio_server_app_1.ResolveIOServer.getServerConfig() : null;
+        var raw = (_a = process.env.CPU_PROFILE_AUTO) !== null && _a !== void 0 ? _a : config === null || config === void 0 ? void 0 : config['CPU_PROFILE_AUTO'];
+        return this.parseDebugFlag(raw);
+    };
+    ResolveIOMainServer.prototype.resolveCpuProfileDurationMs = function () {
+        var _a, _b, _c;
+        var config = resolveio_server_app_1.ResolveIOServer.getServerConfig ? resolveio_server_app_1.ResolveIOServer.getServerConfig() : null;
+        var raw = (_c = (_b = (_a = process.env.CPU_PROFILE_DURATION_MS) !== null && _a !== void 0 ? _a : process.env.PERF_PROFILE_DURATION_MS) !== null && _b !== void 0 ? _b : config === null || config === void 0 ? void 0 : config['CPU_PROFILE_DURATION_MS']) !== null && _c !== void 0 ? _c : config === null || config === void 0 ? void 0 : config['PERF_PROFILE_DURATION_MS'];
+        return this.parsePositiveInt(raw, this._cpuProfileDurationMs);
+    };
+    ResolveIOMainServer.prototype.resolveCpuProfileThresholdPct = function () {
+        var _a, _b, _c;
+        var config = resolveio_server_app_1.ResolveIOServer.getServerConfig ? resolveio_server_app_1.ResolveIOServer.getServerConfig() : null;
+        var raw = (_c = (_b = (_a = process.env.CPU_PROFILE_THRESHOLD_PCT) !== null && _a !== void 0 ? _a : process.env.PERF_PROFILE_THRESHOLD_PCT) !== null && _b !== void 0 ? _b : config === null || config === void 0 ? void 0 : config['CPU_PROFILE_THRESHOLD_PCT']) !== null && _c !== void 0 ? _c : config === null || config === void 0 ? void 0 : config['PERF_PROFILE_THRESHOLD_PCT'];
+        return this.parsePositiveFloat(raw, this._cpuProfileThresholdPct);
+    };
+    ResolveIOMainServer.prototype.resolveCpuProfileTriggerCount = function () {
+        var _a;
+        var config = resolveio_server_app_1.ResolveIOServer.getServerConfig ? resolveio_server_app_1.ResolveIOServer.getServerConfig() : null;
+        var raw = (_a = process.env.CPU_PROFILE_TRIGGER_COUNT) !== null && _a !== void 0 ? _a : config === null || config === void 0 ? void 0 : config['CPU_PROFILE_TRIGGER_COUNT'];
+        return this.parsePositiveInt(raw, this._cpuProfileTriggerCount);
+    };
+    ResolveIOMainServer.prototype.resolveCpuProfileDir = function () {
+        var _a;
+        var config = resolveio_server_app_1.ResolveIOServer.getServerConfig ? resolveio_server_app_1.ResolveIOServer.getServerConfig() : null;
+        var raw = (_a = process.env.CPU_PROFILE_DIR) !== null && _a !== void 0 ? _a : config === null || config === void 0 ? void 0 : config['CPU_PROFILE_DIR'];
+        return typeof raw === 'string' && raw.trim() ? raw.trim() : null;
+    };
+    ResolveIOMainServer.prototype.resolveTimerDebug = function () {
+        var _a;
+        var config = resolveio_server_app_1.ResolveIOServer.getServerConfig ? resolveio_server_app_1.ResolveIOServer.getServerConfig() : null;
+        var raw = (_a = process.env.TIMER_DEBUG) !== null && _a !== void 0 ? _a : config === null || config === void 0 ? void 0 : config['TIMER_DEBUG'];
+        return this.parseDebugFlag(raw);
+    };
+    ResolveIOMainServer.prototype.resolveTimerDebugThresholdMs = function () {
+        var _a;
+        var config = resolveio_server_app_1.ResolveIOServer.getServerConfig ? resolveio_server_app_1.ResolveIOServer.getServerConfig() : null;
+        var raw = (_a = process.env.TIMER_DEBUG_THRESHOLD_MS) !== null && _a !== void 0 ? _a : config === null || config === void 0 ? void 0 : config['TIMER_DEBUG_THRESHOLD_MS'];
+        return this.parsePositiveFloat(raw, this._timerDebugThresholdMs);
+    };
+    ResolveIOMainServer.prototype.resolveTimerDebugMinDelayMs = function () {
+        var _a;
+        var config = resolveio_server_app_1.ResolveIOServer.getServerConfig ? resolveio_server_app_1.ResolveIOServer.getServerConfig() : null;
+        var raw = (_a = process.env.TIMER_DEBUG_MIN_DELAY_MS) !== null && _a !== void 0 ? _a : config === null || config === void 0 ? void 0 : config['TIMER_DEBUG_MIN_DELAY_MS'];
+        return this.parsePositiveFloat(raw, this._timerDebugMinDelayMs);
+    };
+    ResolveIOMainServer.prototype.resolveTimerDebugSampleRate = function () {
+        var _a;
+        var config = resolveio_server_app_1.ResolveIOServer.getServerConfig ? resolveio_server_app_1.ResolveIOServer.getServerConfig() : null;
+        var raw = (_a = process.env.TIMER_DEBUG_SAMPLE_RATE) !== null && _a !== void 0 ? _a : config === null || config === void 0 ? void 0 : config['TIMER_DEBUG_SAMPLE_RATE'];
+        var parsed = parseFloat(raw !== null && raw !== void 0 ? raw : '');
+        if (Number.isFinite(parsed) && parsed > 0 && parsed <= 1) {
+            return parsed;
+        }
+        return this._timerDebugSampleRate;
+    };
+    ResolveIOMainServer.prototype.resolveTimerDebugLogLimit = function () {
+        var _a;
+        var config = resolveio_server_app_1.ResolveIOServer.getServerConfig ? resolveio_server_app_1.ResolveIOServer.getServerConfig() : null;
+        var raw = (_a = process.env.TIMER_DEBUG_LOG_LIMIT) !== null && _a !== void 0 ? _a : config === null || config === void 0 ? void 0 : config['TIMER_DEBUG_LOG_LIMIT'];
+        return this.parsePositiveInt(raw, this._timerDebugLogLimit);
+    };
+    ResolveIOMainServer.prototype.normalizeWorkerSelectorValue = function (value) {
+        if (value === null || value === undefined) {
+            return null;
+        }
+        var normalized = String(value).trim();
+        return normalized.length ? normalized : null;
+    };
+    ResolveIOMainServer.prototype.parseWorkerSelector = function (value) {
+        if (value === null || value === undefined) {
+            return null;
+        }
+        var raw = Array.isArray(value) ? value.join(',') : String(value);
+        var parts = raw.split(',').map(function (part) { return part.trim(); }).filter(Boolean);
+        if (!parts.length) {
+            return null;
+        }
+        return new Set(parts);
+    };
+    ResolveIOMainServer.prototype.workerMatchesSelector = function (workerIndex, workerInstance, indexes, instances) {
+        if (!indexes && !instances) {
+            return false;
+        }
+        var indexMatch = indexes ? (workerIndex ? indexes.has(workerIndex) : false) : true;
+        var instanceMatch = instances ? (workerInstance ? instances.has(workerInstance) : false) : true;
+        return indexMatch && instanceMatch;
+    };
+    ResolveIOMainServer.prototype.resolveWorkerRole = function () {
+        var workerIndex = this.normalizeWorkerSelectorValue(process.env.WORKER_INDEX);
+        var workerInstance = this.normalizeWorkerSelectorValue(process.env.NODE_APP_INSTANCE);
+        var publicationIndexes = this.parseWorkerSelector(process.env.PUBLICATION_WORKER_INDEX
+            || process.env.SUBSCRIPTION_WORKER_INDEX
+            || process.env.WORKER_PUBLICATION_INDEX);
+        var publicationInstances = this.parseWorkerSelector(process.env.PUBLICATION_WORKER_INSTANCE
+            || process.env.SUBSCRIPTION_WORKER_INSTANCE
+            || process.env.WORKER_PUBLICATION_INSTANCE);
+        var codexIndexes = this.parseWorkerSelector(process.env.AI_ASSISTANT_CODEX_WORKER_INDEX
+            || process.env.CODEX_WORKER_INDEX
+            || process.env.WORKER_CODEX_INDEX);
+        var codexInstances = this.parseWorkerSelector(process.env.AI_ASSISTANT_CODEX_WORKER_INSTANCE
+            || process.env.CODEX_WORKER_INSTANCE
+            || process.env.WORKER_CODEX_INSTANCE);
+        if (this.workerMatchesSelector(workerIndex, workerInstance, publicationIndexes, publicationInstances)) {
+            return 'Subscription';
+        }
+        if (this.workerMatchesSelector(workerIndex, workerInstance, codexIndexes, codexInstances)) {
+            return 'Codex';
+        }
+        return 'Other';
+    };
+    ResolveIOMainServer.prototype.parsePositiveInt = function (value, fallback) {
+        var parsed = parseInt(value !== null && value !== void 0 ? value : '', 10);
+        if (Number.isNaN(parsed) || parsed <= 0) {
+            return fallback;
+        }
+        return parsed;
+    };
+    ResolveIOMainServer.prototype.parsePositiveFloat = function (value, fallback) {
+        var parsed = parseFloat(value !== null && value !== void 0 ? value : '');
+        if (Number.isNaN(parsed) || parsed <= 0) {
+            return fallback;
+        }
+        return parsed;
+    };
+    ResolveIOMainServer.prototype.startPerfDebug = function () {
+        var _this = this;
+        var _a;
+        if (!this._perfDebug || this._perfDebugTimer) {
+            return;
+        }
+        this._perfDebugIntervalMs = this.parsePositiveInt((_a = process.env.PERF_DEBUG_INTERVAL_MS) !== null && _a !== void 0 ? _a : process.env.CPU_DEBUG_INTERVAL_MS, this._perfDebugIntervalMs);
+        this._perfDebugLastCpu = process.cpuUsage();
+        this._perfDebugLastTs = Date.now();
+        this._eventLoopHistogram = (0, perf_hooks_1.monitorEventLoopDelay)({ resolution: 20 });
+        this._eventLoopHistogram.enable();
+        this._perfDebugTimer = setInterval(function () {
+            var now = Date.now();
+            var elapsedMs = now - _this._perfDebugLastTs;
+            var cpuDiff = _this._perfDebugLastCpu ? process.cpuUsage(_this._perfDebugLastCpu) : process.cpuUsage();
+            var cpuMs = (cpuDiff.user + cpuDiff.system) / 1000;
+            var cpuPct = elapsedMs > 0 ? (cpuMs / elapsedMs) * 100 : 0;
+            var mem = process.memoryUsage();
+            var heapUsedMb = (0, common_1.round)((mem.heapUsed / 1024 / 1024) * 10) / 10;
+            var rssMb = (0, common_1.round)((mem.rss / 1024 / 1024) * 10) / 10;
+            var handles = typeof process._getActiveHandles === 'function'
+                ? process._getActiveHandles().length
+                : null;
+            var requests = typeof process._getActiveRequests === 'function'
+                ? process._getActiveRequests().length
+                : null;
+            var histogram = _this._eventLoopHistogram;
+            var eventLoop = histogram ? {
+                meanMs: (0, common_1.round)((histogram.mean / 1e6) * 100) / 100,
+                p50Ms: (0, common_1.round)((histogram.percentile(50) / 1e6) * 100) / 100,
+                p95Ms: (0, common_1.round)((histogram.percentile(95) / 1e6) * 100) / 100,
+                p99Ms: (0, common_1.round)((histogram.percentile(99) / 1e6) * 100) / 100,
+                maxMs: (0, common_1.round)((histogram.max / 1e6) * 100) / 100
+            } : null;
+            histogram === null || histogram === void 0 ? void 0 : histogram.reset();
+            console.log(new Date(), '[Perf Debug]', JSON.stringify({
+                cpuPct: (0, common_1.round)(cpuPct * 10) / 10,
+                cpuMs: (0, common_1.round)(cpuMs),
+                elapsedMs: elapsedMs,
+                eventLoop: eventLoop,
+                heapUsedMb: heapUsedMb,
+                rssMb: rssMb,
+                activeHandles: handles,
+                activeRequests: requests,
+                msgRecv: _this._debugMsgRecv,
+                msgQueue: _this._debugMsgQueue
+            }));
+            if (_this._cpuProfileAuto) {
+                if (cpuPct >= _this._cpuProfileThresholdPct) {
+                    _this._cpuProfileHighCount += 1;
+                }
+                else {
+                    _this._cpuProfileHighCount = 0;
+                }
+                if (_this._cpuProfileHighCount >= _this._cpuProfileTriggerCount) {
+                    _this._cpuProfileHighCount = 0;
+                    _this.startCpuProfile('auto-high-cpu');
+                }
+            }
+            _this._perfDebugLastCpu = process.cpuUsage();
+            _this._perfDebugLastTs = now;
+        }, this._perfDebugIntervalMs);
+    };
+    ResolveIOMainServer.prototype.installTimerDebug = function () {
+        var _this = this;
+        if (!this._timerDebug) {
+            return;
+        }
+        var g = global;
+        if (g.__resolveioTimerDebugInstalled) {
+            return;
+        }
+        g.__resolveioTimerDebugInstalled = true;
+        var originalSetTimeout = global.setTimeout;
+        var originalSetInterval = global.setInterval;
+        var thresholdMs = this._timerDebugThresholdMs;
+        var minDelayMs = this._timerDebugMinDelayMs;
+        var sampleRate = this._timerDebugSampleRate;
+        var shouldSample = function () { return sampleRate >= 1 || Math.random() <= sampleRate; };
+        var logTimer = function (type, durationMs, delayMs, createdStack) {
+            if (_this._timerDebugLogLimit > 0 && _this._timerDebugLogCount >= _this._timerDebugLogLimit) {
+                return;
+            }
+            _this._timerDebugLogCount += 1;
+            var stackLines = createdStack
+                ? createdStack.split('\n').slice(1, 6).map(function (line) { return line.trim(); }).join(' | ')
+                : undefined;
+            console.log(new Date(), '[Timer Debug]', JSON.stringify({
+                type: type,
+                durationMs: (0, common_1.round)(durationMs * 10) / 10,
+                delayMs: delayMs !== null && delayMs !== void 0 ? delayMs : null,
+                createdAt: stackLines
+            }));
+        };
+        var wrapTimer = function (handler, type, delayMs) {
+            if (typeof handler !== 'function') {
+                return handler;
+            }
+            var createdStack = new Error().stack;
+            var shouldFlagShortDelay = typeof delayMs === 'number' && delayMs <= minDelayMs;
+            return function wrappedTimer() {
+                var args = [];
+                for (var _i = 0; _i < arguments.length; _i++) {
+                    args[_i] = arguments[_i];
+                }
+                var start = process.hrtime.bigint();
+                try {
+                    return handler.apply(this, args);
+                }
+                finally {
+                    var elapsedMs = Number(process.hrtime.bigint() - start) / 1e6;
+                    if (shouldSample() && (elapsedMs >= thresholdMs || shouldFlagShortDelay)) {
+                        logTimer(type, elapsedMs, delayMs, createdStack);
+                    }
+                }
+            };
+        };
+        global.setTimeout = (function (handler, timeout) {
+            var args = [];
+            for (var _i = 2; _i < arguments.length; _i++) {
+                args[_i - 2] = arguments[_i];
+            }
+            return originalSetTimeout.apply(void 0, __spreadArray([wrapTimer(handler, 'setTimeout', timeout), timeout], __read(args), false));
+        });
+        global.setInterval = (function (handler, timeout) {
+            var args = [];
+            for (var _i = 2; _i < arguments.length; _i++) {
+                args[_i - 2] = arguments[_i];
+            }
+            return originalSetInterval.apply(void 0, __spreadArray([wrapTimer(handler, 'setInterval', timeout), timeout], __read(args), false));
+        });
+    };
+    ResolveIOMainServer.prototype.startCpuProfile = function (trigger) {
+        var _this = this;
+        if (this._cpuProfileSession) {
+            return;
+        }
+        try {
+            var session_1 = new inspector.Session();
+            session_1.connect();
+            session_1.post('Profiler.enable', function () {
+                session_1.post('Profiler.start', function () {
+                    _this._cpuProfileSession = session_1;
+                    console.log(new Date(), '[Perf Debug]', 'CPU profile started', trigger);
+                    setTimeout(function () {
+                        _this.stopCpuProfile(trigger);
+                    }, _this._cpuProfileDurationMs);
+                });
+            });
+        }
+        catch (error) {
+            console.error(new Date(), '[Perf Debug]', 'CPU profile start failed', error);
+        }
+    };
+    ResolveIOMainServer.prototype.stopCpuProfile = function (trigger) {
+        var _this = this;
+        var session = this._cpuProfileSession;
+        if (!session) {
+            return;
+        }
+        session.post('Profiler.stop', function (err, res) {
+            var _a;
+            if (err) {
+                console.error(new Date(), '[Perf Debug]', 'CPU profile stop failed', err);
+            }
+            else {
+                try {
+                    var dir = _this.resolveWritableProfileDir();
+                    var filename = "resolveio-cpuprofile-".concat(process.pid, "-").concat(Date.now(), ".cpuprofile");
+                    var filePath = path.join(dir, filename);
+                    fs.writeFileSync(filePath, JSON.stringify((_a = res === null || res === void 0 ? void 0 : res.profile) !== null && _a !== void 0 ? _a : {}));
+                    console.log(new Date(), '[Perf Debug]', 'CPU profile saved', filePath, trigger);
+                }
+                catch (writeErr) {
+                    console.error(new Date(), '[Perf Debug]', 'CPU profile write failed', writeErr);
+                }
+            }
+            try {
+                session.disconnect();
+            }
+            catch (_b) { }
+            _this._cpuProfileSession = null;
+        });
+    };
+    ResolveIOMainServer.prototype.resolveWritableProfileDir = function () {
+        var preferred = this._cpuProfileDir;
+        if (preferred) {
+            try {
+                fs.mkdirSync(preferred, { recursive: true });
+                return preferred;
+            }
+            catch (_a) { }
+        }
+        return os.tmpdir();
+    };
+    ResolveIOMainServer.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;
+    };
+    ResolveIOMainServer.prototype.parseOptionalBoolean = function (value) {
+        if (value === null || value === undefined) {
+            return null;
+        }
+        var normalized = "".concat(value).trim();
+        if (!normalized) {
+            return null;
+        }
+        return this.parseDebugFlag(normalized);
+    };
+    ResolveIOMainServer.prototype.parseNonNegativeInt = function (value, fallback) {
+        var parsed = parseInt("".concat(value !== null && value !== void 0 ? value : ''), 10);
+        if (Number.isNaN(parsed) || parsed < 0) {
+            return fallback;
+        }
+        return parsed;
+    };
+    ResolveIOMainServer.prototype.resolveSocketTier = function () {
+        var config = resolveio_server_app_1.ResolveIOServer.getServerConfig() || {};
+        return "".concat(process.env.AI_CODER_PLAN_TIER || config['AI_CODER_PLAN_TIER'] || '').trim().toLowerCase();
+    };
+    ResolveIOMainServer.prototype.resolveSocketTierKeySuffix = function (planTier) {
+        return "".concat(planTier || '')
+            .trim()
+            .toUpperCase()
+            .replace(/[^A-Z0-9]+/g, '_');
+    };
+    ResolveIOMainServer.prototype.resolveMaxClientSockets = function (planTier) {
+        var _a, _b, _c;
+        var config = resolveio_server_app_1.ResolveIOServer.getServerConfig() || {};
+        var explicitLimit = this.parseNonNegativeInt((_a = config['AI_CODER_MAX_SOCKETS']) !== null && _a !== void 0 ? _a : process.env.AI_CODER_MAX_SOCKETS, -1);
+        if (explicitLimit >= 0) {
+            return explicitLimit;
+        }
+        var normalizedTier = "".concat(planTier || '').trim().toLowerCase();
+        var tierKeySuffix = this.resolveSocketTierKeySuffix(normalizedTier);
+        if (tierKeySuffix) {
+            var tierLimitKey = "AI_CODER_MAX_SOCKETS_".concat(tierKeySuffix);
+            var tierLimit = this.parseNonNegativeInt((_b = config[tierLimitKey]) !== null && _b !== void 0 ? _b : process.env[tierLimitKey], -1);
+            if (tierLimit >= 0) {
+                return tierLimit;
+            }
+        }
+        var maxUsers = this.parseNonNegativeInt((_c = config['AI_CODER_MAX_USERS']) !== null && _c !== void 0 ? _c : process.env.AI_CODER_MAX_USERS, -1);
+        if (maxUsers > 0) {
+            return maxUsers === 1 ? 1 : maxUsers * 2;
+        }
+        if (normalizedTier === 'tool') {
+            return 1;
+        }
+        if (normalizedTier === 'small') {
+            return 10;
+        }
+        if (normalizedTier === 'medium') {
+            return 50;
+        }
+        if (normalizedTier === 'large') {
+            return 200;
+        }
+        if (normalizedTier === 'enterprise') {
+            return 0;
+        }
+        return 0;
+    };
+    ResolveIOMainServer.prototype.resolveSingleIpPerUserPolicy = function (planTier) {
+        var _a, _b;
+        var config = resolveio_server_app_1.ResolveIOServer.getServerConfig() || {};
+        var normalizedTier = "".concat(planTier || '').trim().toLowerCase();
+        var tierKeySuffix = this.resolveSocketTierKeySuffix(normalizedTier);
+        if (tierKeySuffix) {
+            var tierPolicyKey = "AI_CODER_SINGLE_IP_PER_USER_".concat(tierKeySuffix);
+            var tierPolicy = this.parseOptionalBoolean((_a = config[tierPolicyKey]) !== null && _a !== void 0 ? _a : process.env[tierPolicyKey]);
+            if (tierPolicy !== null) {
+                return tierPolicy;
+            }
+        }
+        var policy = this.parseOptionalBoolean((_b = config['AI_CODER_SINGLE_IP_PER_USER']) !== null && _b !== void 0 ? _b : process.env.AI_CODER_SINGLE_IP_PER_USER);
+        if (policy !== null) {
+            return policy;
+        }
+        return !!normalizedTier;
+    };
+    ResolveIOMainServer.prototype.resolveSocketPolicyUpgradeUrl = function () {
+        var config = resolveio_server_app_1.ResolveIOServer.getServerConfig() || {};
+        var direct = "".concat(config['AI_CODER_SOCKET_UPGRADE_URL'] || process.env.AI_CODER_SOCKET_UPGRADE_URL || '').trim();
+        if (direct) {
+            return direct.replace(/\/$/, '');
+        }
+        var dashboard = "".concat(config['AI_CODER_CLIENT_DASHBOARD_URL'] || process.env.AI_CODER_CLIENT_DASHBOARD_URL || '').trim();
+        if (dashboard) {
+            return dashboard.replace(/\/$/, '');
+        }
+        var root = "".concat(config['AI_CODER_ROOT_URL'] || process.env.AI_CODER_ROOT_URL || config['ROOT_URL'] || process.env.ROOT_URL || '').trim();
+        if (!root) {
+            return '';
+        }
+        return "".concat(root.replace(/\/$/, ''), "/dashboard/client");
+    };
+    ResolveIOMainServer.prototype.resolveSocketUpgradeUrlWithAppId = function () {
+        var base = "".concat(this._socketPolicyUpgradeUrl || '').trim();
+        if (!base) {
+            return '';
+        }
+        var appId = "".concat(process.env.AI_CODER_APP_ID || '').trim();
+        if (!appId) {
+            return base;
+        }
+        var separator = base.includes('?') ? '&' : '?';
+        return "".concat(base).concat(separator, "appId=").concat(encodeURIComponent(appId));
+    };
+    ResolveIOMainServer.prototype.normalizeIpAddress = function (value) {
+        var ip = "".concat(value || '').trim();
+        if (!ip) {
+            return '';
+        }
+        if (ip.includes(',')) {
+            ip = ip.split(',')[0].trim();
+        }
+        if (ip.startsWith('::ffff:')) {
+            ip = ip.slice(7);
+        }
+        if (/^\d+\.\d+\.\d+\.\d+:\d+$/.test(ip)) {
+            ip = ip.split(':')[0].trim();
+        }
+        if (ip === '::1') {
+            return '127.0.0.1';
+        }
+        return ip.toLowerCase();
+    };
+    ResolveIOMainServer.prototype.resolveClientIp = function (req) {
+        var _a, _b, _c, _d;
+        var forwardedFor = this.normalizeHeaderValue((_a = req === null || req === void 0 ? void 0 : req.headers) === null || _a === void 0 ? void 0 : _a['x-forwarded-for']);
+        if (forwardedFor) {
+            return this.normalizeIpAddress(forwardedFor);
+        }
+        var realIp = this.normalizeHeaderValue((_b = req === null || req === void 0 ? void 0 : req.headers) === null || _b === void 0 ? void 0 : _b['x-real-ip']);
+        if (realIp) {
+            return this.normalizeIpAddress(realIp);
+        }
+        var socketIp = ((_c = req === null || req === void 0 ? void 0 : req.socket) === null || _c === void 0 ? void 0 : _c.remoteAddress) || ((_d = req === null || req === void 0 ? void 0 : req.connection) === null || _d === void 0 ? void 0 : _d.remoteAddress) || (req === null || req === void 0 ? void 0 : req.ip) || '';
+        return this.normalizeIpAddress(socketIp);
+    };
+    ResolveIOMainServer.prototype.buildSocketLimitMessage = function (activeSockets) {
+        var tierLabel = this._socketTier ? this._socketTier[0].toUpperCase() + this._socketTier.slice(1) : 'Current';
+        var upgradeUrl = this.resolveSocketUpgradeUrlWithAppId();
+        var base = "Socket connection limit reached (".concat(activeSockets, "/").concat(this._maxClientSockets, ") for the ").concat(tierLabel, " tier.");
+        if (!upgradeUrl) {
+            return "".concat(base, " Upgrade to increase capacity.");
+        }
+        return "".concat(base, " Upgrade at ").concat(upgradeUrl, ".");
+    };
+    ResolveIOMainServer.prototype.buildSocketLimitCloseReason = function () {
+        return "Socket limit reached (".concat(this._maxClientSockets, ")");
+    };
+    ResolveIOMainServer.prototype.disconnectUserSocketsFromDifferentIps = function (idUser, incomingIp) {
+        return __awaiter(this, void 0, void 0, function () {
+            var normalizedUser, normalizedIncomingIp, userSockets, disconnected, userSockets_1, userSockets_1_1, existingSocket, existingIp, e_9_1;
+            var e_9, _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (!this._websocketManager) {
+                            return [2 /*return*/, 0];
+                        }
+                        normalizedUser = "".concat(idUser || '').trim();
+                        normalizedIncomingIp = this.normalizeIpAddress(incomingIp);
+                        if (!normalizedUser || !normalizedIncomingIp) {
+                            return [2 /*return*/, 0];
+                        }
+                        userSockets = this._websocketManager.getUserWebSockets(normalizedUser);
+                        disconnected = 0;
+                        _b.label = 1;
+                    case 1:
+                        _b.trys.push([1, 6, 7, 8]);
+                        userSockets_1 = __values(userSockets), userSockets_1_1 = userSockets_1.next();
+                        _b.label = 2;
+                    case 2:
+                        if (!!userSockets_1_1.done) return [3 /*break*/, 5];
+                        existingSocket = userSockets_1_1.value;
+                        existingIp = this.normalizeIpAddress(existingSocket === null || existingSocket === void 0 ? void 0 : existingSocket['client_ip']);
+                        if (!existingIp || existingIp === normalizedIncomingIp) {
+                            return [3 /*break*/, 4];
+                        }
+                        this.logConnectDebug('WS single-ip enforcement disconnect', {
+                            id_socket: existingSocket === null || existingSocket === void 0 ? void 0 : existingSocket['id_socket'],
+                            id_user: normalizedUser,
+                            existingIp: existingIp,
+                            incomingIp: normalizedIncomingIp
+                        });
+                        return [4 /*yield*/, this.unsubscribeWS(existingSocket)];
+                    case 3:
+                        _b.sent();
+                        if (existingSocket.readyState === WebSocket.OPEN || existingSocket.readyState === WebSocket.CONNECTING) {
+                            try {
+                                existingSocket.close(1008, 'Signed in from another IP');
+                            }
+                            catch (_c) { }
+                        }
+                        disconnected += 1;
+                        _b.label = 4;
+                    case 4:
+                        userSockets_1_1 = userSockets_1.next();
+                        return [3 /*break*/, 2];
+                    case 5: return [3 /*break*/, 8];
+                    case 6:
+                        e_9_1 = _b.sent();
+                        e_9 = { error: e_9_1 };
+                        return [3 /*break*/, 8];
+                    case 7:
+                        try {
+                            if (userSockets_1_1 && !userSockets_1_1.done && (_a = userSockets_1.return)) _a.call(userSockets_1);
+                        }
+                        finally { if (e_9) throw e_9.error; }
+                        return [7 /*endfinally*/];
+                    case 8: return [2 /*return*/, disconnected];
+                }
+            });
+        });
+    };
+    ResolveIOMainServer.prototype.evaluateClientSocketAdmission = function (idUser, req) {
+        return __awaiter(this, void 0, void 0, function () {
+            var normalizedUser, clientIp, activeSockets, message;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        normalizedUser = "".concat(idUser || '').trim();
+                        clientIp = this.resolveClientIp(req);
+                        if (!this._singleIpPerUser) return [3 /*break*/, 2];
+                        return [4 /*yield*/, this.disconnectUserSocketsFromDifferentIps(normalizedUser, clientIp)];
+                    case 1:
+                        _a.sent();
+                        _a.label = 2;
+                    case 2:
+                        if (this._maxClientSockets > 0 && this._websocketManager) {
+                            activeSockets = this._websocketManager.getActiveWebSocketCount();
+                            if (activeSockets >= this._maxClientSockets) {
+                                message = this.buildSocketLimitMessage(activeSockets);
+                                this.logConnectDebug('WS socket limit blocked', {
+                                    id_user: normalizedUser,
+                                    clientIp: clientIp,
+                                    activeSockets: activeSockets,
+                                    maxClientSockets: this._maxClientSockets
+                                });
+                                return [2 /*return*/, {
+                                        allowed: false,
+                                        statusCode: 429,
+                                        message: message,
+                                        clientIp: clientIp
+                                    }];
+                            }
+                        }
+                        return [2 /*return*/, {
+                                allowed: true,
+                                statusCode: 200,
+                                message: '',
+                                clientIp: clientIp
+                            }];
+                }
+            });
+        });
+    };
+    ResolveIOMainServer.prototype.logConnectDebug = function (message, details) {
+        if (!this._wsConnectDebug) {
+            return;
+        }
+        if (details) {
+            console.log(new Date(), '[Connect Debug]', message, JSON.stringify(details));
+        }
+        else {
+            console.log(new Date(), '[Connect Debug]', message);
+        }
+    };
+    ResolveIOMainServer.prototype.triggerClientHeartbeat = function (ws) {
+        return __awaiter(this, void 0, void 0, function () {
+            var err_1;
+            var _this = this;
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (!ws || ws.readyState !== WebSocket.OPEN) {
+                            return [2 /*return*/];
+                        }
+                        ws['pingTime'] = new Date();
+                        _b.label = 1;
+                    case 1:
+                        _b.trys.push([1, 2, , 4]);
+                        if (typeof ws.ping === 'function') {
+                            ws.ping();
+                        }
+                        return [3 /*break*/, 4];
+                    case 2:
+                        err_1 = _b.sent();
+                        if ((_a = this._methodManager) === null || _a === void 0 ? void 0 : _a.getEnableDebug()) {
+                            console.log(new Date(), 'Server App', 'Error WS Ping Frame', err_1);
+                        }
+                        return [4 /*yield*/, this.unsubscribeWS(ws)];
+                    case 3:
+                        _b.sent();
+                        return [2 /*return*/];
+                    case 4:
+                        ws.send('ping', function (error) { return __awaiter(_this, void 0, void 0, function () {
+                            var _a;
+                            return __generator(this, function (_b) {
+                                switch (_b.label) {
+                                    case 0:
+                                        if (!error) return [3 /*break*/, 2];
+                                        if ((_a = this._methodManager) === null || _a === void 0 ? void 0 : _a.getEnableDebug()) {
+                                            console.log(new Date(), 'Server App', 'Error WS Ping');
+                                        }
+                                        return [4 /*yield*/, this.unsubscribeWS(ws)];
+                                    case 1:
+                                        _b.sent();
+                                        _b.label = 2;
+                                    case 2: return [2 /*return*/];
+                                }
+                            });
+                        }); });
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    ResolveIOMainServer.prototype.shouldDeferHeartbeat = function (ws) {
+        if (!ws || ws.readyState !== WebSocket.OPEN) {
+            return false;
+        }
+        var bufferedAmount = typeof ws.bufferedAmount === 'number' ? ws.bufferedAmount : 0;
+        return bufferedAmount >= this._clientHeartbeatBackpressureBytes;
+    };
+    ResolveIOMainServer.prototype.handleClientMessage = function (ws, msg) {
+        return __awaiter(this, void 0, void 0, function () {
+            var messageRoute_1, messageDate, messageId, type, subType, pub, serverRes, offlineUpdates, i, update, data, updateRoute, updateDate, updateMessageId, updateType, method, serverResMethod, err_2, dataCopy_1, date, msgId_1, msgType, methodName_1, ack, method, forceWorker, targetWorkerIndex, targetWorkerInstance, hasWorkerForMethod, isAiCodex, isExcludedFromWorker, shouldDispatchToWorker, queueSnapshot, err_3;
+            var _a;
+            var _this = this;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        _b.trys.push([0, 24, , 25]);
+                        messageRoute_1 = msg[0];
+                        messageDate = msg[1];
+                        messageId = msg[2];
+                        type = msg[3];
+                        if (!this.publicProgram && this._clientRoutes.some(function (a) { return messageRoute_1.includes(a); }) && !ws['doc_user'].roles.groups.some(function (a) { return a.views.some(function (b) { return messageRoute_1.includes(b) || b.includes(messageRoute_1); }); }) && !ws['doc_user'].roles.super_admin) {
+                            return [2 /*return*/];
+                        }
+                        if (!(type === 'subscription')) return [3 /*break*/, 4];
+                        subType = msg[4];
+                        pub = msg[5];
+                        this.logConnectDebug('Subscription message', {
+                            subType: subType,
+                            publication: pub,
+                            messageId: messageId,
+                            messageRoute: messageRoute_1,
+                            args: Math.max(0, msg.length - 6),
+                            id_socket: ws ? ws['id_socket'] : null,
+                            user: ws ? ws['user'] : null
+                        });
+                        if (!(subType === 'sub')) return [3 /*break*/, 2];
+                        return [4 /*yield*/, this._subscriptionManager.subscribe(messageRoute_1, messageDate, ws, messageId, pub, msg.slice(6))];
+                    case 1:
+                        _b.sent();
+                        return [3 /*break*/, 3];
+                    case 2:
+                        this._subscriptionManager.unsubscribe(messageRoute_1, messageDate, ws, messageId, pub, msg.slice(6));
+                        _b.label = 3;
+                    case 3: return [3 /*break*/, 23];
+                    case 4:
+                        if (!(!this.publicProgram && type === 'offline')) return [3 /*break*/, 16];
+                        serverRes = {
+                            messageId: messageId,
+                            hasError: false,
+                            data: 'ACK'
+                        };
+                        if (ws && ws.readyState === WebSocket.OPEN) {
+                            this._websocketManager.send(ws, serverRes);
+                        }
+                        this._offlineUpdates.push(ws);
+                        offlineUpdates = msg[4];
+                        i = 0;
+                        _b.label = 5;
+                    case 5:
+                        if (!(i < offlineUpdates.length)) return [3 /*break*/, 15];
+                        update = offlineUpdates[i];
+                        data = update.data;
+                        updateRoute = data.shift();
+                        updateDate = data.shift();
+                        updateMessageId = data.shift();
+                        updateType = data.shift();
+                        method = data.shift();
+                        serverResMethod = {
+                            messageId: updateMessageId,
+                            hasError: false,
+                            data: 'ACK'
+                        };
+                        if (ws && ws.readyState === WebSocket.OPEN) {
+                            this._websocketManager.send(ws, serverResMethod);
+                        }
+                        if (method === 'insertDocument' && data[0] === 'driver-gps') {
+                            return [3 /*break*/, 14];
+                        }
+                        if (!(method !== 'reportBuilderGetResults' && method !== 'reportBuilderGetDistinctValue' && method !== 'reportBuilderBuildTree' && method !== 'generatePDF' && method !== 'getWOOfflineData' && method !== 'countQuery' && method !== 'countWithQuery' && method !== 'countCollectionWithQuery' && method !== 'find' && method !== 'findOne' && method !== 'findWithOptions' && method !== 'getDrivers' && method !== 'processAirdropDistribution' && method !== 'qbHandleResponse')) return [3 /*break*/, 8];
+                        if (!resolveio_server_app_1.ResolveIOServer.shouldWriteLogsOffline()) return [3 /*break*/, 6];
+                        resolveio_server_app_1.ResolveIOServer.getLocalLogManager().writeLog({
+                            type: 'log',
+                            data: {
+                                _id: (0, common_1.objectIdHexString)(),
+                                createdAt: new Date(),
+                                type: 'client-request',
+                                collection: '',
+                                id_document: '',
+                                payload: (0, common_1.getBinarySize)(JSON.stringify([data])) < 1000000 ? JSON.stringify([data], null, 2) : 'Too Big',
+                                method: method,
+                                id_user: ws['id_user'] || '',
+                                user: ws['user'] || '',
+                                messageId: messageId,
+                                route: messageRoute_1,
+                                instance_index: process.env.NODE_APP_INSTANCE || '0'
+                            }
+                        });
+                        return [3 /*break*/, 8];
+                    case 6: return [4 /*yield*/, log_collection_1.Logs.insertOne({
+                            _id: (0, common_1.objectIdHexString)(),
+                            type: 'client-request',
+                            collection: '',
+                            id_document: '',
+                            payload: (0, common_1.getBinarySize)(JSON.stringify([data])) < 1000000 ? JSON.stringify([data], null, 2) : 'Too Big',
+                            method: method,
+                            id_user: ws['id_user'] || '',
+                            user: ws['user'] || '',
+                            messageId: messageId,
+                            route: messageRoute_1,
+                            client: 'ResolveIO',
+                            instance: resolveio_server_app_1.ResolveIOServer.getInstanceHost(),
+                            instance_index: process.env.NODE_APP_INSTANCE || '0'
+                        })];
+                    case 7:
+                        _b.sent();
+                        _b.label = 8;
+                    case 8:
+                        if (!this._methodManager._methods[method]) return [3 /*break*/, 13];
+                        _b.label = 9;
+                    case 9:
+                        _b.trys.push([9, 11, , 12]);
+                        return [4 /*yield*/, (_a = this._methodManager.callMethod).call.apply(_a, __spreadArray([Object.assign({}, this._methodManager, method_manager_1.MethodManager.prototype, { id_user: ws['id_user'], user: ws['user'], id_ws: ws['id_socket'] }), method], __read(data), false))];
+                    case 10:
+                        _b.sent();
+                        return [3 /*break*/, 12];
+                    case 11:
+                        err_2 = _b.sent();
+                        console.log(new Date(), 'Offline Error', JSON.stringify(err_2, null, 2));
+                        return [3 /*break*/, 12];
+                    case 12:
+                        if (method === 'updateDocumentOffline' || method === 'updateDocumentPropsOffline') {
+                            resolveio_server_app_1.ResolveIOServer.getMongoManager().invalidateQueryCache(data[0]);
+                        }
+                        return [3 /*break*/, 14];
+                    case 13:
+                        console.log('Offline - Could not find method: ' + method);
+                        _b.label = 14;
+                    case 14:
+                        i++;
+                        return [3 /*break*/, 5];
+                    case 15:
+                        this._offlineUpdates.splice(this._offlineUpdates.map(function (a) { return a['id_socket']; }).indexOf(ws['id_socket']), 1);
+                        return [3 /*break*/, 23];
+                    case 16:
+                        dataCopy_1 = __spreadArray([], __read(msg), false);
+                        dataCopy_1.shift();
+                        date = dataCopy_1.shift();
+                        msgId_1 = dataCopy_1.shift();
+                        msgType = dataCopy_1.shift();
+                        if (!(msgType === 'method')) return [3 /*break*/, 23];
+                        methodName_1 = dataCopy_1.shift();
+                        if (ws['user_readonly']) {
+                            return [2 /*return*/];
+                        }
+                        if (!(methodName_1 !== 'reportBuilderGetResults' && methodName_1 !== 'reportBuilderGetDistinctValue' && methodName_1 !== 'reportBuilderBuildTree' && methodName_1 !== 'generatePDF' && methodName_1 !== 'getWOOfflineData' && methodName_1 !== 'countQuery' && methodName_1 !== 'countWithQuery' && methodName_1 !== 'countCollectionWithQuery' && methodName_1 !== 'find' && methodName_1 !== 'findOne' && methodName_1 !== 'findWithOptions' && methodName_1 !== 'getDrivers' && methodName_1 !== 'processAirdropDistribution')) return [3 /*break*/, 19];
+                        if (!resolveio_server_app_1.ResolveIOServer.shouldWriteLogsOffline()) return [3 /*break*/, 17];
+                        resolveio_server_app_1.ResolveIOServer.getLocalLogManager().writeLog({
+                            type: 'log',
+                            data: {
+                                _id: (0, common_1.objectIdHexString)(),
+                                createdAt: new Date(),
+                                type: 'client-request',
+                                collection: '',
+                                id_document: '',
+                                payload: (0, common_1.getBinarySize)(JSON.stringify([dataCopy_1])) < 1000000 ? JSON.stringify([dataCopy_1], null, 2) : 'Too Big',
+                                method: methodName_1,
+                                id_user: ws['id_user'] || '',
+                                user: ws['user'] || '',
+                                messageId: messageId,
+                                route: messageRoute_1,
+                                instance_index: process.env.NODE_APP_INSTANCE || '0'
+                            }
+                        });
+                        return [3 /*break*/, 19];
+                    case 17: return [4 /*yield*/, log_collection_1.Logs.insertOne({
+                            _id: (0, common_1.objectIdHexString)(),
+                            type: 'client-request',
+                            collection: '',
+                            id_document: '',
+                            payload: (0, common_1.getBinarySize)(JSON.stringify([dataCopy_1])) < 1000000 ? JSON.stringify([dataCopy_1], null, 2) : 'Too Big',
+                            method: methodName_1,
+                            id_user: ws['id_user'] || '',
+                            user: ws['user'] || '',
+                            messageId: messageId,
+                            route: messageRoute_1,
+                            client: 'ResolveIO',
+                            instance: resolveio_server_app_1.ResolveIOServer.getInstanceHost(),
+                            instance_index: process.env.NODE_APP_INSTANCE || '0'
+                        })];
+                    case 18:
+                        _b.sent();
+                        _b.label = 19;
+                    case 19:
+                        ack = {
+                            messageId: msgId_1,
+                            hasError: false,
+                            data: 'ACK'
+                        };
+                        if (ws && ws.readyState === WebSocket.OPEN) {
+                            this._websocketManager.send(ws, ack);
+                        }
+                        method = this._methodManager.getMethod(methodName_1);
+                        forceWorker = this._isWorkersEnabled && !!(method === null || method === void 0 ? void 0 : method.forceWorker);
+                        targetWorkerIndex = this._isWorkersEnabled && method ? method.targetWorkerIndex : null;
+                        targetWorkerInstance = this._isWorkersEnabled && method ? method.targetWorkerInstance : null;
+                        hasWorkerForMethod = this._workerDispatcherManager ? this._workerDispatcherManager.hasWorkersForMethod(methodName_1) : false;
+                        isAiCodex = methodName_1 === 'aiCoderTerminalRunCodex' || methodName_1 === 'aiCoderAppRunCodex';
+                        isExcludedFromWorker = (methodName_1 === 'find' ||
+                            methodName_1 === 'insertDocument' ||
+                            methodName_1 === 'countWithQuery' ||
+                            methodName_1 === 'findOne' ||
+                            methodName_1 === 'updateDocumentProps' ||
+                            methodName_1 === 'findWithOptions' ||
+                            methodName_1 === 'updateDocument' ||
+                            methodName_1 === 'insertErrorLog' ||
+                            methodName_1 === 'removeDocument' ||
+                            methodName_1 === 'supportCreateBillingUser' ||
+                            methodName_1 === 'getSignedUrl' ||
+                            methodName_1 === 'getSignedUrls' ||
+                            methodName_1 === 'getSignedUrlWithId' ||
+                            methodName_1 === 'incorrectUser' ||
+                            methodName_1 === 'reloadWS' ||
+                            methodName_1 === 'reconnectWS' ||
+                            methodName_1 === 'disconnectWS');
+                        if ((targetWorkerIndex || targetWorkerInstance || forceWorker) && this._isWorkersEnabled && !hasWorkerForMethod && this._methodManager.getEnableDebug()) {
+                            console.warn(new Date(), '[WorkerDispatcher] Worker unavailable, running method locally', {
+                                method: methodName_1,
+                                targetWorkerIndex: targetWorkerIndex || null,
+                                targetWorkerInstance: targetWorkerInstance || null,
+                                forceWorker: forceWorker
+                            });
+                        }
+                        shouldDispatchToWorker = (method &&
+                            !method.skipWorker &&
+                            this._isWorkersEnabled &&
+                            this._workerDispatcherManager &&
+                            hasWorkerForMethod &&
+                            (forceWorker || !isExcludedFromWorker));
+                        if (isAiCodex && this._aiWorkerDebug) {
+                            queueSnapshot = this._workerDispatcherManager ? this._workerDispatcherManager.getQueueSnapshot() : null;
+                            console.log(new Date(), '[AI Worker Debug] dispatch check', {
+                                isWorkersEnabled: this._isWorkersEnabled,
+                                isWorkerInstance: this._isWorkerInstance,
+                                forceWorker: forceWorker,
+                                hasWorkerForMethod: hasWorkerForMethod,
+                                targetWorkerIndex: targetWorkerIndex || null,
+                                targetWorkerInstance: targetWorkerInstance || null,
+                                shouldDispatchToWorker: shouldDispatchToWorker,
+                                queueSnapshot: queueSnapshot
+                            });
+                        }
+                        if (!shouldDispatchToWorker) return [3 /*break*/, 20];
+                        this._workerDispatcherManager.sendClientTask(msgId_1, methodName_1, dataCopy_1, {
+                            id_user: ws['id_user'],
+                            user: ws['user'],
+                            id_ws: ws['id_socket']
+                        });
+                        return [3 /*break*/, 23];
+                    case 20:
+                        if (!(methodName_1 === 'aiCoderTerminalRunCodex' || methodName_1 === 'aiCoderAppRunCodex')) return [3 /*break*/, 21];
+                        if (this._aiWorkerDebug) {
+                            console.warn(new Date(), '[AI Worker Debug] AI execution running locally', {
+                                isWorkersEnabled: this._isWorkersEnabled,
+                                isWorkerInstance: this._isWorkerInstance,
+                                targetWorkerIndex: targetWorkerIndex || null,
+                                targetWorkerInstance: targetWorkerInstance || null,
+                                hasWorkerForMethod: hasWorkerForMethod
+                            });
+                        }
+                        setTimeout(function () { return __awaiter(_this, void 0, void 0, function () {
+                            var error_6;
+                            return __generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0:
+                                        _a.trys.push([0, 2, , 3]);
+                                        return [4 /*yield*/, this.callMethodLocally(ws, msgId_1, methodName_1, dataCopy_1)];
+                                    case 1:
+                                        _a.sent();
+                                        return [3 /*break*/, 3];
+                                    case 2:
+                                        error_6 = _a.sent();
+                                        console.error(new Date(), 'AI execution run failed:', error_6);
+                                        return [3 /*break*/, 3];
+                                    case 3: return [2 /*return*/];
+                                }
+                            });
+                        }); }, 0);
+                        return [3 /*break*/, 23];
+                    case 21: return [4 /*yield*/, this.callMethodLocally(ws, msgId_1, methodName_1, dataCopy_1)];
+                    case 22:
+                        _b.sent();
+                        _b.label = 23;
+                    case 23: return [3 /*break*/, 25];
+                    case 24:
+                        err_3 = _b.sent();
+                        throw err_3;
+                    case 25: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * callMethodLocally is your old approach for invoking the method in-process.
+     */
+    ResolveIOMainServer.prototype.callMethodLocally = function (ws, messageId, method, params) {
+        return __awaiter(this, void 0, void 0, function () {
+            var serverRes, result, resultBytes, err_4;
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        serverRes = {
+                            messageId: messageId,
+                            hasError: false,
+                            data: null
+                        };
+                        _b.label = 1;
+                    case 1:
+                        _b.trys.push([1, 3, , 4]);
+                        return [4 /*yield*/, (_a = this._methodManager.callMethod).call.apply(_a, __spreadArray([Object.assign({}, this._methodManager, method_manager_1.MethodManager.prototype, {
+                                    id_user: ws['id_user'],
+                                    user: ws['user'],
+                                    id_ws: ws['id_socket']
+                                }),
+                                method], __read(params), false))];
+                    case 2:
+                        result = _b.sent();
+                        serverRes.data = result;
+                        if (this._aiWorkerDebug && typeof method === 'string' && method.startsWith('ai')) {
+                            resultBytes = null;
+                            try {
+                                resultBytes = Buffer.byteLength(JSON.stringify(result));
+                            }
+                            catch (_c) {
+                                resultBytes = null;
+                            }
+                            console.log(new Date(), '[AI Worker Debug] local method result', {
+                                method: method,
+                                messageId: messageId,
+                                id_socket: ws ? ws['id_socket'] : null,
+                                id_user: ws ? ws['id_user'] : null,
+                                resultBytes: resultBytes
+                            });
+                        }
+                        return [3 /*break*/, 4];
+                    case 3:
+                        err_4 = _b.sent();
+                        serverRes.hasError = true;
+                        serverRes.data = err_4 || 'Unknown error';
+                        return [3 /*break*/, 4];
+                    case 4:
+                        if (ws && ws.readyState === WebSocket.OPEN) {
+                            this._websocketManager.send(ws, serverRes);
+                        }
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Cleanly remove a client from the subscription manager, etc.
+     */
+    ResolveIOMainServer.prototype.unsubscribeWS = function (ws) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (this._subscriptionManager && this._methodManager.getEnableDebug()) {
+                            console.log(new Date(), 'Server App', 'Unsub WS', ws['user'], ws['id_socket']);
+                        }
+                        this.logConnectDebug('WS unsubscribe', {
+                            id_socket: ws ? ws['id_socket'] : null,
+                            id_user: ws ? ws['id_user'] : null,
+                            user: ws ? ws['user'] : null
+                        });
+                        return [4 /*yield*/, this._subscriptionManager.unsubscribeAll(ws)];
+                    case 1:
+                        _a.sent();
+                        ws.removeAllListeners();
+                        ws = null;
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    ResolveIOMainServer.prototype.getApp = function () {
+        return this._app;
+    };
+    ResolveIOMainServer.prototype.getServerConfig = function () {
+        return resolveio_server_app_1.ResolveIOServer.getServerConfig();
+    };
+    ResolveIOMainServer.prototype.getWorkerDispatcherManager = function () {
+        return this._workerDispatcherManager;
+    };
+    ResolveIOMainServer.prototype.getWorkerServerManager = function () {
+        return this._workerServerManager;
+    };
+    return ResolveIOMainServer;
+}());
+exports.ResolveIOMainServer = ResolveIOMainServer;
+
+//# sourceMappingURL=server-app.js.map