@resolveio/server-lib 22.3.221 → 22.3.222

package/src/server-app.ts

@@ -1,3354 +0,0 @@
-import * as express from 'express';
-import * as xmlParser from 'express-xml-bodyparser';
-import { createServer, Server } from 'http';
-import * as crypto from 'crypto';
-import * as fs from 'fs';
-import * as jwt from 'jsonwebtoken';
-import * as moment from 'moment-timezone';
-import { unpack } from 'msgpackr';
-import * as os from 'os';
-import * as path from 'path';
-import { monitorEventLoopDelay } from 'perf_hooks';
-import * as inspector from 'inspector';
-import { execFile } from 'child_process';
-import { URL } from 'url';
-import * as WebSocket from 'ws';
-
-import { Logs } from './collections/log.collection';
-import { Users } from './collections/user.collection';
-import { CronManager } from './managers/cron.manager';
-import { MethodManager } from './managers/method.manager';
-import { MonitorManager, MonitorManagerFunction } from './managers/monitor.manager';
-import { SubscriptionManager } from './managers/subscription.manager';
-import { ServerResponseModel } from './models/server-message.model';
-import { dateReviver, getBinarySize, isAllowedOrigin, objectIdHexString, round } from './util/common';
-import { ErrorReporter } from './util/error-reporter';
-import { ensureErrorWithCorrelation } from './util/error-tracking';
-
-import { MongoNetworkTimeoutError } from 'mongodb';
-import { setupAuthRoutes } from './http/auth';
-import { setupHealthRoutes } from './http/health';
-import { setupHomeRoutes } from './http/home';
-import { setupSlowQueryPublicationRoutes } from './http/slow-query-publication';
-
-import { WebSocketManager } from './managers/websocket.manager';
-import { WorkerDispatcherManager } from './managers/worker-dispatcher.manager';
-import { WorkerServerManager } from './managers/worker-server.manager';
-import { AiAssistantCodexManager } from './managers/ai-assistant-codex-manager.manager';
-import { ResolveIOServer } from './resolveio-server-app';
-
-const CLIENT_REQUEST_LOG_SKIP_LIST = new Set([
-	'reportBuilderGetResults',
-	'reportBuilderGetDistinctValue',
-	'reportBuilderBuildTree',
-	'generatePDF',
-	'getWOOfflineData',
-	'countQuery',
-	'countWithQuery',
-	'countCollectionWithQuery',
-	'find',
-	'findOne',
-	'findWithOptions',
-	'getDrivers',
-	'processAirdropDistribution',
-	'qbHandleResponse',
-	'getSignedUrls',
-	'getSignedUrl',
-	'getSignedUrlWithId',
-	'getSignedUrlsAndFilesWithId',
-	'updateDocumentProps',
-	'insertDocument',
-	'updateDocument',
-	'uploadFileAndSave'
-]);
-
-function isCorsPreflightRequest(req: express.Request): boolean {
-	return req.method === 'OPTIONS' && !!req.headers.origin && !!req.headers['access-control-request-method'];
-}
-
-function shouldWriteClientRequestLog(methodName: string): boolean {
-	return !CLIENT_REQUEST_LOG_SKIP_LIST.has(methodName);
-}
-
-interface ProcessSnapshot {
-	pid: number;
-	ppid: number;
-	ageSeconds: number;
-	cpuPct: number;
-	rssKb: number;
-	command: string;
-	args: string;
-}
-
-export class ResolveIOMainServer {
-	private _app: express.Application;
-	private _serverHTTP: Server;
-	private _portHTTP: number;
-	private _serverWSS: WebSocket.Server;
-	private _offlineUpdates = [];
-	public sesMail = false;
-	private publicProgram = false;
-	private _rebootFlag = false;
-
-	private LOGGER = 'ERROR'; //ERROR / DEBUG
-
-	private _websocketManager: WebSocketManager;
-	private _monitorManager: MonitorManager;
-	private _monitorManagerFunction: MonitorManagerFunction;
-	private _subscriptionManager: SubscriptionManager;
-	private _methodManager: MethodManager;
-	private _cronManager: CronManager;
-	private _clientRoutes: string[] = [];
-	private _workerDispatcherManager: WorkerDispatcherManager;
-	private _workerServerManager: WorkerServerManager;
-	private _aiAssistantCodexManager: AiAssistantCodexManager | null = null;
-	private _httpServerClosePromise: Promise<void> | null = null;
-	private _websocketServerClosePromise: Promise<void> | null = null;
-	private _wsConnectDebug = false;
-	private _perfDebug = false;
-	private _perfDebugIntervalMs = 2000;
-	private _perfDebugTimer: NodeJS.Timeout | null = null;
-	private _perfDebugLastCpu: NodeJS.CpuUsage | null = null;
-	private _perfDebugLastTs = 0;
-	private _eventLoopHistogram: ReturnType<typeof monitorEventLoopDelay> | null = null;
-	private _cpuProfileOnStart = false;
-	private _cpuProfileAuto = false;
-	private _cpuProfileDurationMs = 15000;
-	private _cpuProfileThresholdPct = 90;
-	private _cpuProfileTriggerCount = 3;
-	private _cpuProfileHighCount = 0;
-	private _cpuProfileDir: string | null = null;
-	private _cpuProfileSession: inspector.Session | null = null;
-	private _timerDebug = false;
-	private _timerDebugThresholdMs = 50;
-	private _timerDebugMinDelayMs = 5;
-	private _timerDebugSampleRate = 1;
-	private _timerDebugLogLimit = 100;
-	private _timerDebugLogCount = 0;
-	private _aiWorkerDebug = false;
-	private _standaloneNodeReaperEnabled = false;
-	private _standaloneNodeReaperIntervalMs = 60000;
-	private _standaloneNodeReaperMinAgeSeconds = 300;
-	private _standaloneNodeReaperMaxKillsPerSignature = 1;
-	private _standaloneNodeReaperKillWindowMs = 60 * 60 * 1000;
-	private _standaloneNodeReaperIncludeSystemdServices = false;
-	private _standaloneNodeReaperHighCpuPct = 85;
-	private _standaloneNodeReaperHighRssMb = 4096;
-	private _standaloneNodeReaperHighMinAgeSeconds = 60;
-	private _standaloneNodeReaperHighConsecutiveScans = 2;
-	private _standaloneNodeReaperDryRun = false;
-	private _standaloneNodeReaperAlertWindowMs = 60 * 60 * 1000;
-	private _standaloneNodeReaperTimer: NodeJS.Timeout | null = null;
-	private _standaloneNodeReaperRunning = false;
-	private _standaloneNodeReaperKillCounts = new Map<string, { count: number; windowStartMs: number }>();
-	private _standaloneNodeReaperSuppressedSignatures = new Set<string>();
-	private _standaloneNodeReaperResourceHits = new Map<string, { count: number; lastSeenMs: number }>();
-	private _standaloneNodeReaperAlertTimes = new Map<string, number>();
-
-	private _serverStartTime: Date;
-	private _lastErrorMsg: Date = null;
-
-	private _debugMsgRecv = 0;
-	private _debugMsgQueue = 0;
-
-	private _isWorkersEnabled = false;
-	private _isWorkerInstance = false;
-
-	private _safeShutdown = false;
-	private _dynamicAppGatewayEnabled = false;
-	private _dynamicAppGatewayCache = new Map<string, { expiresAt: number; app: any }>();
-	private _socketTier = '';
-	private _maxClientSockets = 0;
-	private _singleIpPerUser = false;
-	private _socketPolicyUpgradeUrl = '';
-
-	private readonly _clientHeartbeatIntervalMs = 20000;
-	private readonly _clientHeartbeatInitialDelayMs = 5000;
-	private readonly _clientHeartbeatBackpressureBytes = 5 * 1024 * 1024;
-	private readonly _dynamicAppGatewayCacheMs = 30 * 1000;
-
-	constructor() {}
-
-	static async create() {
-		const resolveioMainServer = new ResolveIOMainServer();
-		await resolveioMainServer.initialize();
-		return resolveioMainServer;
-	}
-
-	private async initialize() {
-		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._standaloneNodeReaperEnabled = this.resolveStandaloneNodeReaperEnabled();
-			this._standaloneNodeReaperIntervalMs = this.resolveStandaloneNodeReaperIntervalMs();
-			this._standaloneNodeReaperMinAgeSeconds = this.resolveStandaloneNodeReaperMinAgeSeconds();
-			this._standaloneNodeReaperMaxKillsPerSignature = this.resolveStandaloneNodeReaperMaxKillsPerSignature();
-			this._standaloneNodeReaperKillWindowMs = this.resolveStandaloneNodeReaperKillWindowMs();
-			this._standaloneNodeReaperIncludeSystemdServices = this.resolveStandaloneNodeReaperIncludeSystemdServices();
-			this._standaloneNodeReaperHighCpuPct = this.resolveStandaloneNodeReaperHighCpuPct();
-			this._standaloneNodeReaperHighRssMb = this.resolveStandaloneNodeReaperHighRssMb();
-			this._standaloneNodeReaperHighMinAgeSeconds = this.resolveStandaloneNodeReaperHighMinAgeSeconds();
-			this._standaloneNodeReaperHighConsecutiveScans = this.resolveStandaloneNodeReaperHighConsecutiveScans();
-			this._standaloneNodeReaperDryRun = this.resolveStandaloneNodeReaperDryRun();
-			this._standaloneNodeReaperAlertWindowMs = this.resolveStandaloneNodeReaperAlertWindowMs();
-			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
-				});
-			}
-			this._monitorManager = await MonitorManager.create();
-		this._monitorManagerFunction = new 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';
-		this.startStandaloneNodeReaper();
-
-		setInterval(() => {
-			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', async (error, rej) => {
-			const { error: normalizedError, correlationId } = ensureErrorWithCorrelation(error);
-
-			if (this._methodManager.getEnableDebug()) {
-				console.error(new Date(), 'ERROR DETECTED w/ Debug Flag Active: unhandledRejection', [normalizedError, rej, { 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; // 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; // Simply return without doing anything further
-			}
-
-			const errorDetails = {
-				id: correlationId,
-				name: normalizedError?.name,
-				message: normalizedError?.message,
-				stack: normalizedError?.stack,
-				code: normalizedError?.code,
-				codeName: normalizedError?.codeName
-			};
-
-			console.error(new Date(), 'Unhandled Rejection at Promise', [errorDetails]);
-			
-			let diffTimeSec = moment().diff(this._serverStartTime, 'seconds');
-
-			// If this is a MongoNetworkTimeoutError, handle it specifically
-			if (normalizedError && (normalizedError['name'] === 'MongoNetworkTimeoutError' || normalizedError instanceof MongoNetworkTimeoutError)) {
-				if (diffTimeSec > 60 && !this._lastErrorMsg) {
-					this._lastErrorMsg = new Date();
-					setTimeout(() => {
-						this._lastErrorMsg = null;
-					}, 60000);
-
-					// Exiting the process
-					process.exit(1);
-				}
-			}
-			else if (normalizedError && normalizedError['name'] === 'MongoError' && normalizedError['message'] === 'not master') {
-				if (diffTimeSec > 60 && !this._lastErrorMsg) {
-					this._lastErrorMsg = new Date();
-
-					setTimeout(() => {
-						this._lastErrorMsg = null;
-					}, 60000);
-				}
-
-				process.exit(1);
-			}
-			else if (normalizedError && normalizedError['name'] === 'MongoError' && normalizedError['message'] === 'not master and slaveOk=false') {
-				if (diffTimeSec > 60 && !this._lastErrorMsg) {
-					this._lastErrorMsg = new Date();
-
-					setTimeout(() => {
-						this._lastErrorMsg = null;
-					}, 60000);
-				}
-
-				process.exit(1);
-			}
-			else if (normalizedError && normalizedError['name'] !== 'StatusError' && normalizedError['message'] !== '') {
-				if (diffTimeSec > 60 && !this._lastErrorMsg) {
-					this._lastErrorMsg = new Date();
-
-					setTimeout(() => {
-						this._lastErrorMsg = null;
-					}, 60000);
-
-					await this.reportServerError(
-						'SERVER - Unhandled Rejection - ' + ResolveIOServer.getServerConfig()['CLIENT_NAME'],
-						correlationId,
-						errorDetails,
-						{
-							context: 'unhandledRejection',
-							scenario: 'General'
-						}
-					);
-				}
-			}
-		});
-
-		process.on('uncaughtException', async error => {
-			const { error: normalizedError, correlationId } = ensureErrorWithCorrelation(error);
-			console.error(normalizedError, 'Uncaught Exception thrown', { correlationId });
-
-			let diffTimeSec = moment().diff(this._serverStartTime, 'seconds');
-
-			if (diffTimeSec > 60 && !this._lastErrorMsg) {
-				this._lastErrorMsg = new Date();
-
-				setTimeout(() => {
-					this._lastErrorMsg = null;
-				}, 60000);
-				
-				const errorDetails = {
-					id: correlationId,
-					name: normalizedError?.name,
-					message: normalizedError?.message,
-					stack: normalizedError?.stack,
-					code: normalizedError?.code,
-					codeName: normalizedError?.codeName
-				};
-
-				await this.reportServerError(
-					'SERVER - Unhandled Exception - ' + ResolveIOServer.getServerConfig()['CLIENT_NAME'],
-					correlationId,
-					errorDetails,
-					{
-						context: 'uncaughtException'
-					}
-				);
-			}
-		});
-
-		//PM2 wants to reboot/restart
-		process.on('SIGINT', async () => {
-			this._rebootFlag = true;
-			try {
-				await this.shutdownNetworkServers();
-			}
-			catch (error) {
-				console.error(new Date(), 'Error closing network servers (SIGINT)', error);
-			}
-			await this.safeShutdown();
-		});
-
-		process.on('SIGTERM', async () => {
-			this._rebootFlag = true;
-			try {
-				await this.shutdownNetworkServers();
-			}
-			catch (error) {
-				console.error(new Date(), 'Error closing network servers (SIGTERM)', error);
-			}
-			await this.safeShutdown();
-		});
-
-		process.on('SIGQUIT', async () => {
-			this._rebootFlag = true;
-			try {
-				await this.shutdownNetworkServers();
-			}
-			catch (error) {
-				console.error(new Date(), 'Error closing network servers (SIGQUIT)', error);
-			}
-			await this.safeShutdown();
-		});
-
-		if (this.LOGGER === 'DEBUG') {
-			console.log('Starting ResolveIO Server');
-		}
-
-		if (this._isWorkersEnabled) {
-			if (this._isWorkerInstance) {
-				const workerRole = this.resolveWorkerRole();
-				const workerIndex = this.normalizeWorkerSelectorValue(process.env.WORKER_INDEX) || 'UNKNOWN';
-				const workerInstance = this.normalizeWorkerSelectorValue(process.env.NODE_APP_INSTANCE) || 'UNKNOWN';
-				console.log(`Running as Worker: ${workerRole}`, workerIndex, workerInstance);
-				this._methodManager = MethodManager.create(null, this._monitorManagerFunction, this._isWorkersEnabled, this._isWorkerInstance);
-				this._subscriptionManager = SubscriptionManager.createPublicationRegistry(ResolveIOServer.getServerConfig());
-				const skipWorkerServerConnection = this.parseDebugFlag(process.env.DISABLE_WORKER_SERVER_CONNECTION)
-					|| this.parseDebugFlag(process.env.SUPPORT_CODEX_MANAGER_PROCESS_ONLY)
-					|| this.parseDebugFlag(process.env.SUPPORT_AUTO_MANAGER_PROCESS_ONLY)
-					|| this.parseDebugFlag(process.env.AI_ASSISTANT_CODEX_MANAGER_PROCESS_ONLY);
-				if (skipWorkerServerConnection) {
-					console.log(new Date(), 'Worker server connection disabled for process-only runtime', {
-						workerIndex: process.env.WORKER_INDEX || null,
-						workerInstance: process.env.NODE_APP_INSTANCE || null
-					});
-					this._workerServerManager = null;
-				}
-				else {
-					this._workerServerManager = WorkerServerManager.create(this._methodManager, this.getServerConfig());
-				}
-
-				const skipCronForProcessOnly = this.parseDebugFlag(process.env.SUPPORT_CODEX_MANAGER_PROCESS_ONLY)
-					|| this.parseDebugFlag(process.env.SUPPORT_AUTO_MANAGER_PROCESS_ONLY)
-					|| this.parseDebugFlag(process.env.AI_ASSISTANT_CODEX_MANAGER_PROCESS_ONLY);
-				if (this.shouldStartCronManagerForWorker() && !skipCronForProcessOnly) {
-					this._cronManager = CronManager.create();
-				}
-			}
-			else {
-				console.log('Running as a Server instance', process.env.NODE_APP_INSTANCE);
-				this._websocketManager = WebSocketManager.create(this);
-				this._methodManager = MethodManager.create(this._websocketManager, this._monitorManagerFunction, this._isWorkersEnabled, this._isWorkerInstance);
-				this._workerDispatcherManager = WorkerDispatcherManager.create(this._websocketManager, this._methodManager);
-				this._subscriptionManager = SubscriptionManager.create(this._serverWSS, ResolveIOServer.getServerConfig(), this._monitorManagerFunction);
-				this.startServerInstance();
-				this.listen();
-			}
-		}
-		else {
-			console.log('Running with Workers Disabled', process.env.NODE_APP_INSTANCE);
-			this._websocketManager = WebSocketManager.create(this);
-			this._methodManager = MethodManager.create(this._websocketManager, this._monitorManagerFunction, this._isWorkersEnabled, this._isWorkerInstance);
-			this._subscriptionManager = SubscriptionManager.create(this._serverWSS, ResolveIOServer.getServerConfig(), this._monitorManagerFunction);
-			this._cronManager = CronManager.create();
-			this.startServerInstance();
-			this.listen();
-		}
-
-		this.startAiAssistantCodexManagerIfEnabled();
-	}
-
-	private startAiAssistantCodexManagerIfEnabled(): void {
-		try {
-			this._aiAssistantCodexManager = AiAssistantCodexManager.createIfEnabled({
-				isWorkersEnabled: this._isWorkersEnabled,
-				isWorkerInstance: this._isWorkerInstance,
-				workerIndex: process.env.WORKER_INDEX || null,
-				workerInstance: process.env.NODE_APP_INSTANCE || null
-			});
-			ResolveIOServer['AiAssistantCodexManager'] = this._aiAssistantCodexManager;
-		}
-		catch (error) {
-			console.error(new Date(), 'Failed to start AI Assistant Codex Manager', error);
-			ResolveIOServer['AiAssistantCodexManager'] = null;
-		}
-	}
-
-	private startStandaloneNodeReaper(): void {
-		if (!this._standaloneNodeReaperEnabled || this._standaloneNodeReaperTimer) {
-			return;
-		}
-
-		if (process.platform !== 'linux' || !this.isPm2ManagedRuntime() || !this.isPrimaryPm2Instance()) {
-			return;
-		}
-
-		const initialDelayMs = Math.min(30000, this._standaloneNodeReaperIntervalMs);
-		const firstRunTimer = setTimeout(async () => {
-			try {
-				await this.reapStandaloneNodeProcesses();
-			}
-			catch (error) {
-				console.error(new Date(), '[Standalone Node Reaper] failed', error);
-			}
-		}, initialDelayMs);
-		firstRunTimer.unref?.();
-
-		this._standaloneNodeReaperTimer = setInterval(async () => {
-			try {
-				await this.reapStandaloneNodeProcesses();
-			}
-			catch (error) {
-				console.error(new Date(), '[Standalone Node Reaper] failed', error);
-			}
-		}, this._standaloneNodeReaperIntervalMs);
-		this._standaloneNodeReaperTimer.unref?.();
-
-		console.log(new Date(), '[Standalone Node Reaper] enabled', {
-			intervalMs: this._standaloneNodeReaperIntervalMs,
-			minAgeSeconds: this._standaloneNodeReaperMinAgeSeconds,
-			maxKillsPerSignature: this._standaloneNodeReaperMaxKillsPerSignature,
-			killWindowMs: this._standaloneNodeReaperKillWindowMs,
-			highCpuPct: this._standaloneNodeReaperHighCpuPct,
-			highRssMb: this._standaloneNodeReaperHighRssMb,
-			highMinAgeSeconds: this._standaloneNodeReaperHighMinAgeSeconds,
-			highConsecutiveScans: this._standaloneNodeReaperHighConsecutiveScans,
-			alertWindowMs: this._standaloneNodeReaperAlertWindowMs,
-			dryRun: this._standaloneNodeReaperDryRun
-		});
-	}
-
-	private async reapStandaloneNodeProcesses(): Promise<void> {
-		if (this._standaloneNodeReaperRunning) {
-			return;
-		}
-
-		this._standaloneNodeReaperRunning = true;
-		try {
-			const processes = await this.listSystemProcesses();
-			const protectedPids = this.resolvePm2ProtectedPids(processes);
-			for (const proc of processes) {
-				if (!this.shouldReapStandaloneNodeProcess(proc, protectedPids)) {
-					continue;
-				}
-
-				const signature = this.resolveStandaloneNodeProcessSignature(proc);
-				if (!this.canReapStandaloneNodeSignature(signature)) {
-					this.logStandaloneNodeReaperSuppressed(proc, signature);
-					continue;
-				}
-
-				const reason = this.resolveStandaloneNodeReaperReason(proc);
-				if (this._standaloneNodeReaperDryRun) {
-					this.recordStandaloneNodeReaperKill(signature);
-					const details = this.createStandaloneNodeReaperDetails(proc, reason, 'dry-run');
-					console.warn(new Date(), '[Standalone Node Reaper] dry-run would terminate stale node process', details);
-					await this.reportStandaloneNodeReaperAction(proc, reason, 'dry-run');
-					continue;
-				}
-
-				try {
-					process.kill(proc.pid, 'SIGTERM');
-					this.recordStandaloneNodeReaperKill(signature);
-					const details = this.createStandaloneNodeReaperDetails(proc, reason, 'terminated');
-					console.warn(new Date(), '[Standalone Node Reaper] terminated stale node process', details);
-					await this.reportStandaloneNodeReaperAction(proc, reason, 'terminated');
-
-					const killTimer = setTimeout(async () => {
-						try {
-							process.kill(proc.pid, 0);
-							process.kill(proc.pid, 'SIGKILL');
-							console.warn(new Date(), '[Standalone Node Reaper] force killed stale node process', {
-								pid: proc.pid,
-								reason,
-								command: proc.args
-							});
-							await this.reportStandaloneNodeReaperAction(proc, reason, 'force-killed');
-						}
-						catch {}
-					}, 10000);
-					killTimer.unref?.();
-				}
-				catch (error) {
-					if (error?.['code'] !== 'ESRCH') {
-						console.error(new Date(), '[Standalone Node Reaper] kill failed', {
-							pid: proc.pid,
-							command: proc.args,
-							error: error?.['message'] || error
-						});
-					}
-				}
-			}
-		}
-		finally {
-			this._standaloneNodeReaperRunning = false;
-		}
-	}
-
-	private createStandaloneNodeReaperDetails(proc: ProcessSnapshot, reason: string, action: string): Record<string, any> {
-		return {
-			action,
-			pid: proc.pid,
-			ppid: proc.ppid,
-			ageSeconds: proc.ageSeconds,
-			cpuPct: proc.cpuPct,
-			rssMb: round(proc.rssKb / 1024),
-			reason,
-			command: proc.args
-		};
-	}
-
-	private async reportStandaloneNodeReaperAction(proc: ProcessSnapshot, reason: string, action: string): Promise<void> {
-		const signature = this.resolveStandaloneNodeProcessSignature(proc);
-		const alertKey = `${action}|${signature}`;
-		const now = Date.now();
-		const lastReportedAt = this._standaloneNodeReaperAlertTimes.get(alertKey);
-		if (lastReportedAt && (now - lastReportedAt) < this._standaloneNodeReaperAlertWindowMs) {
-			return;
-		}
-
-		try {
-			await this.reportServerError(
-				`SERVER - Standalone Node Reaper ${action} process - ${ResolveIOServer.getServerConfig()?.['CLIENT_NAME'] || ResolveIOServer.getClientName()}`,
-				crypto.randomUUID(),
-				{
-					...this.createStandaloneNodeReaperDetails(proc, reason, action),
-					host: os.hostname(),
-					workerIndex: process.env.WORKER_INDEX || null,
-					workerInstance: process.env.NODE_APP_INSTANCE || null,
-					dryRun: this._standaloneNodeReaperDryRun,
-					alertWindowMs: this._standaloneNodeReaperAlertWindowMs
-				},
-				{
-					context: 'standaloneNodeReaper',
-					action,
-					reason,
-					signature
-				},
-				'warning'
-			);
-			this._standaloneNodeReaperAlertTimes.set(alertKey, now);
-		}
-		catch (error) {
-			console.error(new Date(), '[Standalone Node Reaper] alert failed', {
-				action,
-				pid: proc.pid,
-				error: error?.['message'] || error
-			});
-		}
-	}
-
-	private async listSystemProcesses(): Promise<ProcessSnapshot[]> {
-		const output = await this.execFileText('ps', ['-eo', 'pid=,ppid=,etimes=,pcpu=,rss=,comm=,args='], 5000);
-		return output
-			.split('\n')
-			.map(line => line.trim())
-			.filter(Boolean)
-			.map(line => this.parseProcessSnapshot(line))
-			.filter((proc): proc is ProcessSnapshot => proc !== null);
-	}
-
-	private parseProcessSnapshot(line: string): ProcessSnapshot | null {
-		const match = line.match(/^(\d+)\s+(\d+)\s+(\d+)\s+([\d.]+)\s+(\d+)\s+(\S+)\s+(.*)$/);
-		if (!match) {
-			return null;
-		}
-
-		return {
-			pid: parseInt(match[1], 10),
-			ppid: parseInt(match[2], 10),
-			ageSeconds: parseInt(match[3], 10),
-			cpuPct: parseFloat(match[4]),
-			rssKb: parseInt(match[5], 10),
-			command: match[6],
-			args: match[7] || ''
-		};
-	}
-
-	private execFileText(command: string, args: string[], timeoutMs: number): Promise<string> {
-		// eslint-disable-next-line no-restricted-syntax
-		return new Promise((resolve, reject) => {
-			execFile(command, args, { timeout: timeoutMs, maxBuffer: 1024 * 1024 }, (error, stdout) => {
-				if (error) {
-					reject(error);
-					return;
-				}
-				resolve(stdout || '');
-			});
-		});
-	}
-
-	private resolvePm2ProtectedPids(processes: ProcessSnapshot[]): Set<number> {
-		const byPid = new Map<number, ProcessSnapshot>();
-		const children = new Map<number, number[]>();
-		for (const proc of processes) {
-			byPid.set(proc.pid, proc);
-			if (!children.has(proc.ppid)) {
-				children.set(proc.ppid, []);
-			}
-			children.get(proc.ppid).push(proc.pid);
-		}
-
-		const protectedPids = new Set<number>();
-		const addWithDescendants = (pid: number) => {
-			if (protectedPids.has(pid)) {
-				return;
-			}
-			protectedPids.add(pid);
-			for (const childPid of children.get(pid) || []) {
-				addWithDescendants(childPid);
-			}
-		};
-
-		for (const proc of processes) {
-			if (proc.args.includes('pm2-runtime') || proc.args.includes('/pm2/')) {
-				addWithDescendants(proc.pid);
-			}
-		}
-
-		let currentPid = process.pid;
-		while (currentPid && byPid.has(currentPid)) {
-			protectedPids.add(currentPid);
-			currentPid = byPid.get(currentPid).ppid;
-		}
-
-		return protectedPids;
-	}
-
-	private shouldReapStandaloneNodeProcess(proc: ProcessSnapshot, protectedPids: Set<number>): boolean {
-		if (proc.pid === process.pid || proc.ppid !== 1 || protectedPids.has(proc.pid)) {
-			return false;
-		}
-
-		if (!this.isNodeProcess(proc) || !this.isSameUidProcess(proc.pid)) {
-			return false;
-		}
-
-		if (!this._standaloneNodeReaperIncludeSystemdServices && this.isProtectedSystemdServiceProcess(proc)) {
-			return false;
-		}
-
-		if (!this.isResolveIOAppProcess(proc)) {
-			return false;
-		}
-
-		if (proc.ageSeconds >= this._standaloneNodeReaperMinAgeSeconds) {
-			return true;
-		}
-
-		if (proc.ageSeconds < this._standaloneNodeReaperHighMinAgeSeconds || !this.hasHighStandaloneNodeResourceUsage(proc)) {
-			this.clearStandaloneNodeResourceHit(proc);
-			return false;
-		}
-
-		return this.recordStandaloneNodeResourceHit(proc) >= this._standaloneNodeReaperHighConsecutiveScans;
-	}
-
-	private resolveStandaloneNodeReaperReason(proc: ProcessSnapshot): string {
-		if (proc.ageSeconds >= this._standaloneNodeReaperMinAgeSeconds) {
-			return `orphan_age_seconds_gte_${this._standaloneNodeReaperMinAgeSeconds}`;
-		}
-
-		const rssMb = proc.rssKb / 1024;
-		if (proc.cpuPct >= this._standaloneNodeReaperHighCpuPct && rssMb >= this._standaloneNodeReaperHighRssMb) {
-			return `orphan_high_cpu_and_rss_for_${this._standaloneNodeReaperHighConsecutiveScans}_scans`;
-		}
-		if (proc.cpuPct >= this._standaloneNodeReaperHighCpuPct) {
-			return `orphan_high_cpu_for_${this._standaloneNodeReaperHighConsecutiveScans}_scans`;
-		}
-		if (rssMb >= this._standaloneNodeReaperHighRssMb) {
-			return `orphan_high_rss_for_${this._standaloneNodeReaperHighConsecutiveScans}_scans`;
-		}
-		return 'orphan_stale_node_process';
-	}
-
-	private isNodeProcess(proc: ProcessSnapshot): boolean {
-		return proc.command === 'node' || proc.command.startsWith('node ') || proc.args === 'node' || proc.args.startsWith('node ');
-	}
-
-	private isResolveIOAppProcess(proc: ProcessSnapshot): boolean {
-		const normalizedArgs = proc.args || '';
-		const appDirs = this.resolveCurrentAppDirs();
-		for (const appDir of appDirs) {
-			if (normalizedArgs.includes(appDir)) {
-				return true;
-			}
-		}
-
-		if (normalizedArgs.includes('server-app.js') && normalizedArgs.includes('require(')) {
-			return true;
-		}
-
-		const cwd = this.resolveProcessCwd(proc.pid);
-		return cwd !== null && appDirs.has(cwd) && /\b(index|server-app)\.js\b/.test(normalizedArgs);
-	}
-
-	private hasHighStandaloneNodeResourceUsage(proc: ProcessSnapshot): boolean {
-		const rssMb = proc.rssKb / 1024;
-		return proc.cpuPct >= this._standaloneNodeReaperHighCpuPct || rssMb >= this._standaloneNodeReaperHighRssMb;
-	}
-
-	private recordStandaloneNodeResourceHit(proc: ProcessSnapshot): number {
-		const signature = this.resolveStandaloneNodeProcessSignature(proc);
-		const now = Date.now();
-		const current = this._standaloneNodeReaperResourceHits.get(signature);
-		if (!current || (now - current.lastSeenMs) > (this._standaloneNodeReaperIntervalMs * 3)) {
-			this._standaloneNodeReaperResourceHits.set(signature, { count: 1, lastSeenMs: now });
-			return 1;
-		}
-
-		current.count += 1;
-		current.lastSeenMs = now;
-		return current.count;
-	}
-
-	private clearStandaloneNodeResourceHit(proc: ProcessSnapshot): void {
-		this._standaloneNodeReaperResourceHits.delete(this.resolveStandaloneNodeProcessSignature(proc));
-	}
-
-	private resolveStandaloneNodeProcessSignature(proc: ProcessSnapshot): string {
-		const cwd = this.resolveProcessCwd(proc.pid) || '';
-		return `${cwd}|${proc.args}`;
-	}
-
-	private canReapStandaloneNodeSignature(signature: string): boolean {
-		const now = Date.now();
-		const current = this._standaloneNodeReaperKillCounts.get(signature);
-		if (!current || (now - current.windowStartMs) > this._standaloneNodeReaperKillWindowMs) {
-			this._standaloneNodeReaperKillCounts.set(signature, { count: 0, windowStartMs: now });
-			this._standaloneNodeReaperSuppressedSignatures.delete(signature);
-			return true;
-		}
-
-		return current.count < this._standaloneNodeReaperMaxKillsPerSignature;
-	}
-
-	private recordStandaloneNodeReaperKill(signature: string): void {
-		const now = Date.now();
-		const current = this._standaloneNodeReaperKillCounts.get(signature);
-		if (!current || (now - current.windowStartMs) > this._standaloneNodeReaperKillWindowMs) {
-			this._standaloneNodeReaperKillCounts.set(signature, { count: 1, windowStartMs: now });
-			this._standaloneNodeReaperSuppressedSignatures.delete(signature);
-			return;
-		}
-
-		current.count += 1;
-	}
-
-	private logStandaloneNodeReaperSuppressed(proc: ProcessSnapshot, signature: string): void {
-		if (this._standaloneNodeReaperSuppressedSignatures.has(signature)) {
-			return;
-		}
-
-		this._standaloneNodeReaperSuppressedSignatures.add(signature);
-		console.warn(new Date(), '[Standalone Node Reaper] suppressing recurring stale node process', {
-			pid: proc.pid,
-			ppid: proc.ppid,
-			ageSeconds: proc.ageSeconds,
-			cpuPct: proc.cpuPct,
-			rssMb: round(proc.rssKb / 1024),
-			maxKillsPerSignature: this._standaloneNodeReaperMaxKillsPerSignature,
-			killWindowMs: this._standaloneNodeReaperKillWindowMs,
-			command: proc.args
-		});
-	}
-
-	private resolveCurrentAppDirs(): Set<string> {
-		const dirs = new Set<string>();
-		for (const value of [process.cwd(), ResolveIOServer.getClientDir?.()]) {
-			if (!value) {
-				continue;
-			}
-
-			const resolved = this.safeRealpath(value);
-			if (resolved) {
-				dirs.add(resolved);
-			}
-		}
-		return dirs;
-	}
-
-	private resolveProcessCwd(pid: number): string | null {
-		return this.safeRealpath(`/proc/${pid}/cwd`);
-	}
-
-	private safeRealpath(value: string): string | null {
-		try {
-			return fs.realpathSync(value);
-		}
-		catch {
-			return null;
-		}
-	}
-
-	private isSameUidProcess(pid: number): boolean {
-		if (typeof process.getuid !== 'function') {
-			return true;
-		}
-
-		try {
-			const status = fs.readFileSync(`/proc/${pid}/status`, 'utf8');
-			const uidLine = status.split('\n').find(line => line.startsWith('Uid:'));
-			if (!uidLine) {
-				return false;
-			}
-			const uid = parseInt(uidLine.split(/\s+/)[1], 10);
-			return uid === process.getuid();
-		}
-		catch {
-			return false;
-		}
-	}
-
-	private isProtectedSystemdServiceProcess(proc: ProcessSnapshot): boolean {
-		const serviceName = this.resolveSystemdServiceName(proc.pid);
-		if (!serviceName) {
-			return false;
-		}
-
-		return /\bindex\.js\b/.test(proc.args);
-	}
-
-	private resolveSystemdServiceName(pid: number): string | null {
-		try {
-			const cgroup = fs.readFileSync(`/proc/${pid}/cgroup`, 'utf8');
-			const serviceLine = cgroup.split('\n').find(line => line.includes('/system.slice/') && line.includes('.service'));
-			if (!serviceLine) {
-				return null;
-			}
-
-			const match = serviceLine.match(/\/system\.slice\/([^/]+\.service)/);
-			return match ? match[1] : null;
-		}
-		catch {
-			return null;
-		}
-	}
-
-	private async shutdownNetworkServers() {
-		await this.closeWebSocketServerGracefully();
-		await this.closeHttpServerGracefully();
-	}
-
-	private async closeHttpServerGracefully() {
-		if (!this._serverHTTP) {
-			return;
-		}
-
-		if (this._httpServerClosePromise !== null) {
-			await this._httpServerClosePromise;
-			return;
-		}
-
-		// eslint-disable-next-line no-restricted-syntax
-		this._httpServerClosePromise = new Promise(resolve => {
-			try {
-				this._serverHTTP.close(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();
-			}
-		});
-
-		await this._httpServerClosePromise;
-	}
-
-	private async closeWebSocketServerGracefully() {
-		if (!this._serverWSS) {
-			return;
-		}
-
-		if (this._websocketServerClosePromise !== null) {
-			await this._websocketServerClosePromise;
-			return;
-		}
-
-		this._serverWSS.clients.forEach(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(resolve => {
-			try {
-				this._serverWSS.close(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();
-			}
-		});
-
-		await this._websocketServerClosePromise;
-	}
-
-	private startServerInstance() {
-		// Start express app
-		this._app = express();
-
-		// Use built-in express JSON parser
-		this._app.use(express.json({
-			limit: '50mb',
-			reviver: 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((req, res, next) => {
-			const requestOrigin = String(req.headers.origin || '').trim();
-			if (requestOrigin && isAllowedOrigin(requestOrigin, ResolveIOServer.getServerConfig())) {
-				res.setHeader('Access-Control-Allow-Origin', requestOrigin);
-				res.setHeader('Vary', 'Origin');
-				res.setHeader('Access-Control-Allow-Credentials', 'true');
-			}
-			else {
-				res.setHeader('Access-Control-Allow-Origin', '*');
-				res.setHeader('Access-Control-Allow-Credentials', 'false');
-			}
-			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, X-AI-Coder-App-Token, X-AI-Coder-Session');
-			res.setHeader('Access-Control-Allow-Private-Network', 'true');
-			if (isCorsPreflightRequest(req)) {
-				res.status(204).end();
-				return;
-			}
-			next();
-		});
-
-		if (this.LOGGER === 'DEBUG') {
-			console.log('Setup cors');
-		}
-
-		this.installDynamicAppGatewayMiddleware();
-
-		// Set up http login route
-		setupAuthRoutes(this, this._app, ResolveIOServer.getServerConfig());
-		setupHealthRoutes(this._app);
-		setupSlowQueryPublicationRoutes(this._app);
-
-		if (ResolveIOServer.getServerConfig()['CLIENT_NAME'] === 'ResolveIO' || this.publicProgram) {
-			setupHomeRoutes(this, this._app, ResolveIOServer.getServerConfig());
-		}
-
-		if (this.LOGGER === 'DEBUG') {
-			console.log('Setup express routes');
-		}
-	}
-
-	private installDynamicAppGatewayMiddleware(): void {
-		if (!this._dynamicAppGatewayEnabled) {
-			return;
-		}
-
-		this._app.use(async (req, res, next) => {
-			const appId = this.extractDynamicAppGatewayId(req);
-			if (!appId) {
-				next();
-				return;
-			}
-
-			try {
-				const appDoc = await this.resolveCachedDynamicAppGatewayApp(appId);
-				if (!appDoc) {
-					res.status(404).send(JSON.stringify({
-						error: true,
-						result: 'App not found.'
-					}));
-					return;
-				}
-
-				const allowedHosts = this.resolveDynamicAppAllowedHosts(appDoc);
-				const controlHosts = this.resolveDynamicAppControlHosts();
-				const requestHost = this.normalizeHostname(
-					this.normalizeHeaderValue(req.headers?.['x-forwarded-host'])
-					|| this.normalizeHeaderValue(req.headers?.host)
-				);
-				const originHeader = this.normalizeHeaderValue(req.headers?.origin);
-				const 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;
-				}
-
-				if (requestHost && !allowedHosts.has(requestHost) && !this.isLocalHostname(requestHost)) {
-					res.status(403).send(JSON.stringify({
-						error: true,
-						result: 'Host not allowed for app API.'
-					}));
-					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;
-				}
-
-				if (originHost && !allowedHosts.has(originHost)) {
-					res.status(403).send(JSON.stringify({
-						error: true,
-						result: 'Origin not allowed for app API.'
-					}));
-					return;
-				}
-
-				if (originHeader) {
-					this.applyDynamicAppGatewayCorsHeaders(res, originHeader);
-				}
-
-				if (isCorsPreflightRequest(req)) {
-					res.status(204).end();
-					return;
-				}
-
-				const expectedToken = this.normalizeHeaderValue(appDoc?.rio_token);
-				if (!expectedToken) {
-					res.status(500).send(JSON.stringify({
-						error: true,
-						result: 'App token is not configured.'
-					}));
-					return;
-				}
-
-				const providedToken = this.resolveDynamicAppGatewayToken(req);
-				if (!providedToken || providedToken !== expectedToken) {
-					res.status(401).send(JSON.stringify({
-						error: true,
-						result: 'Invalid or missing RIO token.'
-					}));
-					return;
-				}
-
-				next();
-			}
-			catch (error) {
-				console.error(new Date(), '[DynamicAppGateway] middleware failure', error);
-				res.status(500).send(JSON.stringify({
-					error: true,
-					result: (error as Error)?.message || 'Dynamic app gateway error.'
-				}));
-			}
-		});
-	}
-
-	private resolveDynamicAppGatewayEnabled(): boolean {
-		const config = ResolveIOServer.getServerConfig() || {};
-		const raw = config['AI_CODER_DYNAMIC_APP_GATEWAY'] ?? process.env.AI_CODER_DYNAMIC_APP_GATEWAY;
-		if (raw !== undefined && raw !== null && `${raw}`.trim() !== '') {
-			return this.parseDebugFlag(raw);
-		}
-
-		const 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(value => `${value || ''}`.trim().toLowerCase())
-			.filter(Boolean);
-
-		return urls.some(value => value.includes('aicoder'));
-	}
-
-	private extractDynamicAppGatewayId(req: express.Request): string {
-		const rawPath = `${req.originalUrl || req.url || req.path || ''}`;
-		const normalizedPath = rawPath.split('?')[0];
-		if (!normalizedPath.startsWith('/api/apps/')) {
-			return '';
-		}
-
-		const parts = normalizedPath.split('/').filter(Boolean);
-		if (parts.length < 3) {
-			return '';
-		}
-
-		return `${parts[2] || ''}`.trim();
-	}
-
-	private resolveDynamicAppGatewayToken(req: express.Request): string {
-		const authHeader = this.normalizeHeaderValue(req.headers?.authorization || req.headers?.Authorization);
-		if (authHeader) {
-			const bearerMatch = authHeader.match(/^bearer\s+(.+)$/i);
-			if (bearerMatch && bearerMatch[1]) {
-				return bearerMatch[1].trim();
-			}
-		}
-
-		const headerCandidates = [
-			req.headers?.['x-rio-token'],
-			req.headers?.['x-app-token'],
-			req.headers?.['x-api-key']
-		];
-		for (const candidate of headerCandidates) {
-			const value = this.normalizeHeaderValue(candidate);
-			if (value) {
-				return value;
-			}
-		}
-
-		const body: any = req.body || {};
-		const query: any = req.query || {};
-		const bodyCandidates = [body.rioToken, body.rio_token, body.apiKey, body.token];
-		for (const candidate of bodyCandidates) {
-			const value = this.normalizeHeaderValue(candidate);
-			if (value) {
-				return value;
-			}
-		}
-		const queryCandidates = [query.rioToken, query.rio_token, query.apiKey, query.token];
-		for (const candidate of queryCandidates) {
-			const value = this.normalizeHeaderValue(candidate);
-			if (value) {
-				return value;
-			}
-		}
-
-		return '';
-	}
-
-	private normalizeHeaderValue(value: any): string {
-		if (Array.isArray(value)) {
-			return value.map(entry => `${entry || ''}`.trim()).filter(Boolean).join(',');
-		}
-		return `${value || ''}`.trim();
-	}
-
-	private normalizeHostname(value: string): string {
-		const raw = `${value || ''}`.trim();
-		if (!raw) {
-			return '';
-		}
-
-		let candidate = raw.split(',')[0].trim();
-		if (!candidate) {
-			return '';
-		}
-
-		try {
-			if (candidate.startsWith('http://') || candidate.startsWith('https://')) {
-				return new URL(candidate).hostname.toLowerCase();
-			}
-			if (candidate.includes('/')) {
-				return new URL(`http://${candidate}`).hostname.toLowerCase();
-			}
-		}
-		catch {}
-
-		candidate = candidate.replace(/^\[/, '').replace(/\]$/, '');
-		const lastColon = candidate.lastIndexOf(':');
-		if (lastColon > -1 && candidate.indexOf(':') === lastColon) {
-			candidate = candidate.slice(0, lastColon);
-		}
-		return candidate.toLowerCase();
-	}
-
-	private resolveOriginHostname(origin: string): string {
-		const raw = `${origin || ''}`.trim();
-		if (!raw) {
-			return '';
-		}
-		try {
-			return new URL(raw).hostname.toLowerCase();
-		}
-		catch {
-			return this.normalizeHostname(raw);
-		}
-	}
-
-	private isLocalHostname(hostname: string): boolean {
-		const normalized = this.normalizeHostname(hostname);
-		return normalized === 'localhost' || normalized === '127.0.0.1' || normalized === '::1';
-	}
-
-	private resolveDynamicAppControlHosts(): Set<string> {
-		const config = ResolveIOServer.getServerConfig() || {};
-		const hosts = new Set<string>();
-		const 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
-		];
-		for (const candidate of candidates) {
-			const normalized = this.normalizeHostname(`${candidate || ''}`);
-			if (normalized) {
-				hosts.add(normalized);
-			}
-		}
-		return hosts;
-	}
-
-	private resolveDynamicAppAllowedHosts(appDoc: any): Set<string> {
-		const hosts = new Set<string>();
-		const candidates = [
-			appDoc?.domain,
-			appDoc?.backend_domain
-		];
-		if (appDoc?.subdomain && appDoc?.domain_base) {
-			candidates.push(`${appDoc.subdomain}.${appDoc.domain_base}`);
-		}
-
-		for (const candidate of candidates) {
-			const normalized = this.normalizeHostname(`${candidate || ''}`);
-			if (normalized) {
-				hosts.add(normalized);
-			}
-		}
-		return hosts;
-	}
-
-	private applyDynamicAppGatewayCorsHeaders(res: express.Response, origin: string): void {
-		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, X-AI-Coder-App-Token, X-AI-Coder-Session');
-		res.setHeader('Access-Control-Allow-Credentials', 'true');
-		res.setHeader('Access-Control-Allow-Private-Network', 'true');
-		res.setHeader('Access-Control-Max-Age', '600');
-	}
-
-	private async resolveCachedDynamicAppGatewayApp(appId: string): Promise<any | null> {
-		const now = Date.now();
-		const cached = this._dynamicAppGatewayCache.get(appId);
-		if (cached && cached.expiresAt > now) {
-			return cached.app;
-		}
-
-		const db = ResolveIOServer.getMainDB();
-		if (!db) {
-			return null;
-		}
-
-		const appCollection: any = db.collection('ai-coder-apps');
-		const appDoc = await appCollection.findOne(
-			{ _id: appId },
-			{
-				projection: {
-					_id: 1,
-					domain: 1,
-					backend_domain: 1,
-					subdomain: 1,
-					domain_base: 1,
-					rio_token: 1
-				}
-			}
-		);
-		if (!appDoc) {
-			this._dynamicAppGatewayCache.delete(appId);
-			return null;
-		}
-
-		if (!this.normalizeHeaderValue(appDoc.rio_token)) {
-			const generated = crypto.randomBytes(32).toString('hex');
-			await appCollection.updateOne(
-				{ _id: appId },
-				{
-					$set: {
-						rio_token: generated,
-						updatedAt: new Date()
-					}
-				}
-			);
-			appDoc.rio_token = generated;
-		}
-
-		this._dynamicAppGatewayCache.set(appId, {
-			expiresAt: now + this._dynamicAppGatewayCacheMs,
-			app: appDoc
-		});
-		return appDoc;
-	}
-
-	private async safeShutdown() {
-		if (!this._safeShutdown) {
-			console.log(new Date(), 'Safe Shutdown Command Received');
-		}
-
-		if (
-			!this._monitorManagerFunction.getActiveMonitorFunctions().length
-			&& !this._offlineUpdates.length && (!this._workerDispatcherManager || this._workerDispatcherManager.isSafeShutdown())
-		) {
-			if (ResolveIOServer.getMongoConnection()) {
-				try {
-					await ResolveIOServer.getMongoConnection().close(false);
-					console.log(new Date(), 'Safe Exit Complete, Process Exit');
-					process.exit(0);
-				}
-				catch { 
-					process.exit(1); 
-				};
-			}
-			else {
-				process.exit(0);
-			}
-		}
-		else {
-			if (!this._safeShutdown) {
-				this._safeShutdown = true;
-
-				setTimeout(() => {
-					this._safeShutdown = false;
-				}, 1000);
-
-				console.log(new Date(), 'Safe Exit In Progress', 
-					this._monitorManagerFunction.getActiveMonitorFunctions().length,
-					this._offlineUpdates.length
-				);
-			}
-
-			setImmediate(async () => {
-				await this.safeShutdown();
-			});
-		}
-	}
-
-	getIsWorkersEnabled() {
-		return this._isWorkersEnabled;
-	}
-
-	getIsWorkerInstance() {
-		return this._isWorkerInstance;
-	}
-
-	public getWSList() {
-		let res = [];
-		this._serverWSS.clients.forEach((ws: WebSocket) => {
-			res.push(ws['id_socket']);
-		});
-		return res;
-	}
-
-	public getWSUserList() {
-		let res = [];
-		this._serverWSS.clients.forEach((ws: WebSocket) => {
-			res.push(ws['id_user']);
-		});
-		return res;
-	}
-
-	public getHTTPServer() {
-		return this._serverHTTP;
-	}
-
-	public getCronManager() {
-		return this._cronManager;
-	}
-
-	private async reportServerError(
-		subject: string,
-		correlationId: string,
-		context: Record<string, any>,
-		meta?: Record<string, any>,
-		severity = 'error',
-		stackOverride?: string
-	) {
-		const config = ResolveIOServer.getServerConfig();
-		const metadata = Object.assign({}, meta || {});
-		if (correlationId && !metadata.correlationId) {
-			metadata.correlationId = correlationId;
-		}
-
-		await ErrorReporter.report({
-			sourceApp: 'server-app',
-			message: subject,
-			environment: config?.ROOT_URL || process.env.NODE_ENV || 'unknown',
-			clientSlug: ResolveIOServer.getClientName(),
-			clientName: config?.CLIENT_NAME,
-			severity,
-			stack: stackOverride || (typeof context?.stack === 'string' ? context.stack : undefined),
-			context,
-			metadata,
-			correlationId
-		});
-	}
-
-	public getMethodManager() {
-		return this._methodManager;
-	}
-
-	public getSubscriptionManager() {
-		return this._subscriptionManager;
-	}
-
-	public getMonitorManager() {
-		return this._monitorManager;
-	}
-
-	public getRebootFlag() {
-		return this._rebootFlag;
-	}
-
-	public getWebSocketManager(): WebSocketManager {
-		return this._websocketManager;
-	}
-
-	private createServer(): void {
-		this._serverHTTP = createServer(this._app);
-		this._serverHTTP.keepAliveTimeout = 65000;
-		this._serverHTTP.headersTimeout = 66000;
-
-		this._serverWSS = new WebSocket.Server({
-			server: this._serverHTTP,
-			verifyClient: this.publicProgram ? null : (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=')) {
-						let requestUrl: URL;
-						let rootUrl = ResolveIOServer.getServerConfig()['ROOT_URL'] || 'http://localhost';
-						try {
-							requestUrl = new URL(info.req.url, rootUrl);
-						}
-						catch {
-							cb(false, 400, 'Bad Request');
-							return;
-						}
-
-						let workerToken = requestUrl.searchParams.get('workerToken') || '';
-						let workerIndex = this.normalizeWorkerSelectorValue(requestUrl.searchParams.get('workerIndex'));
-						let workerInstance = this.normalizeWorkerSelectorValue(requestUrl.searchParams.get('workerInstance'));
-						let expectedWorkerToken = String(ResolveIOServer.getServerConfig()['WORKER_TOKEN'] || '');
-
-						if (!workerIndex || !workerInstance) {
-							cb(false, 400, 'Missing worker identity');
-							return;
-						}
-
-						if (workerToken === expectedWorkerToken) {
-							info.req['workerIndex'] = workerIndex;
-							info.req['workerInstance'] = workerInstance;
-							cb(true);
-						}
-						else {
-							cb(false, 401, 'Unauthorized');
-						}
-
-						return;
-					}
-
-					const protocolsHeader = info.req.headers['sec-websocket-protocol'];
-					if (!protocolsHeader || typeof protocolsHeader !== 'string') {
-						cb(false, 401, 'Unauthorized');
-						return;
-					}
-
-					let infoData = protocolsHeader.split(/,/);
-
-					if (!isAllowedOrigin(info.origin, ResolveIOServer.getServerConfig())) {
-						cb(false, 401, 'Unauthorized');
-					}
-					else {
-						let token = infoData[0];
-						if (!token) {
-							cb(false, 401, 'Unauthorized');
-						}
-						else {
-							jwt.verify(token, ResolveIOServer.getServerConfig()['JWT_SECRET'], async (err, decoded) => {
-								if (err) {
-									cb(false, 401, 'Unauthorized');
-								}
-									else {
-										info.req['id_user'] = decoded['id_user'];
-										try {
-											let user = await Users.findById(decoded['id_user']);
-											if (user) {
-												const socketAdmission = await this.evaluateClientSocketAdmission(decoded['id_user'], info.req);
-												if (!socketAdmission.allowed) {
-													cb(false, socketAdmission.statusCode, socketAdmission.message || 'Socket connection rejected.');
-													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);
-											}
-											else {
-											cb(false);
-										}
-									}
-									catch {
-										cb(false);
-									}
-								}
-							});
-						}
-					}
-				}
-			}
-		});
-	}
-
-	/**
-	 * Listen for connections from clients or workers.
-	 */
-	private listen(): void {
-		const host = process.env.RESOLVEIO_BIND_HOST || '127.0.0.1';
-		this._serverHTTP.listen(this._portHTTP, host, () => {
-			console.log('Running HTTP/WS server on port %s', this._portHTTP);
-		});
-
-			this._serverWSS.on('connection', async (ws, req) => {
-				if (req.url && req.url.includes('workerToken=')) {
-					// It's a WORKER
-					let workerId = objectIdHexString();
-					ws['id_worker'] = workerId;
-					let workerIndex = null;
-					let workerInstance = null;
-					ws['supportsBinary'] = true;
-
-					if (req.url) {
-						let rootUrl = ResolveIOServer.getServerConfig()['ROOT_URL'] || 'http://localhost';
-						try {
-							let requestUrl = new URL(req.url, rootUrl);
-							workerIndex = requestUrl.searchParams.get('workerIndex');
-							workerInstance = requestUrl.searchParams.get('workerInstance');
-						}
-						catch {
-							workerIndex = null;
-							workerInstance = null;
-						}
-					}
-
-					if (!workerIndex && req['workerIndex']) {
-						workerIndex = req['workerIndex'];
-					}
-					if (!workerInstance && req['workerInstance']) {
-						workerInstance = req['workerInstance'];
-					}
-
-					workerIndex = this.normalizeWorkerSelectorValue(workerIndex);
-					workerInstance = this.normalizeWorkerSelectorValue(workerInstance);
-
-					if (!workerIndex || !workerInstance) {
-						console.warn(new Date(), 'Rejected worker connection with missing identity', {
-							workerId,
-							workerIndex: workerIndex || null,
-							workerInstance: workerInstance || null
-						});
-						ws.close(1008, 'Missing worker identity');
-						return;
-					}
-
-					ws['workerIndex'] = workerIndex;
-					ws['workerInstance'] = workerInstance;
-
-					let workerIndexForLog = ws['workerIndex'] || 'UNKNOWN';
-					let workerInstanceForLog = ws['workerInstance'] || 'UNKNOWN';
-					console.log(new Date(), 'Worker Connected', workerIndexForLog, workerInstanceForLog);
-
-					this._workerDispatcherManager.addWorker(ws);
-
-				let interval = null;
-				let lastComm = new Date();
-				let missedPongs = 0;
-				const heartbeatIntervalMs = 30000;
-				const maxMissedPongs = 2;
-				const maxSilenceMs = heartbeatIntervalMs * (maxMissedPongs + 1);
-
-				this._workerDispatcherManager.sendWorkerPayload(ws, 'ping');
-	
-				interval = setInterval(() => {
-					const now = Date.now();
-					const last = lastComm ? lastComm.getTime() : 0;
-					const silenceMs = last ? now - last : maxSilenceMs + 1;
-					if (silenceMs > maxSilenceMs || missedPongs > maxMissedPongs) {
-						this._workerDispatcherManager.disconnectWorker(ws['id_worker']);
-						ws.close();
-						return;
-					}
-					missedPongs += 1;
-					this._workerDispatcherManager.sendWorkerPayload(ws, 'ping');
-				}, heartbeatIntervalMs);
-
-					ws.on('message', (message: WebSocket.RawData) => {
-						lastComm = new Date();
-						if (typeof message === 'string') {
-							if (message === 'ping') {
-								this._workerDispatcherManager.sendWorkerPayload(ws, 'pong');
-							}
-							else if (message === 'pong') {
-								missedPongs = 0;
-							}
-							else {
-								this._workerDispatcherManager.handleWorkerMessage(ws['id_worker'], message);
-							}
-
-							return;
-						}
-
-						let buffer: Buffer;
-
-						if (Buffer.isBuffer(message)) {
-							buffer = message;
-						}
-						else if (Array.isArray(message)) {
-							const chunks = message as unknown as ReadonlyArray<Uint8Array>;
-							buffer = Buffer.concat(chunks);
-						}
-						else if (message instanceof ArrayBuffer) {
-							buffer = Buffer.from(message);
-						}
-						else if (ArrayBuffer.isView(message)) {
-							const view = message as NodeJS.ArrayBufferView;
-							buffer = Buffer.from(view.buffer, view.byteOffset, view.byteLength);
-						}
-						else {
-							buffer = Buffer.from(message as any);
-						}
-
-						if (buffer.length === 4) {
-							let heartbeat = buffer.toString('utf8');
-
-							if (heartbeat === 'ping') {
-								this._workerDispatcherManager.sendWorkerPayload(ws, 'pong');
-								return;
-							}
-							else if (heartbeat === 'pong') {
-								missedPongs = 0;
-								return;
-							}
-						}
-
-						this._workerDispatcherManager.handleWorkerMessage(ws['id_worker'], buffer);
-					});
-
-				ws.on('close', () => {
-					this._workerDispatcherManager.disconnectWorker(ws['id_worker']);
-
-					console.log(new Date(), 'Worker disconnected:', workerId);
-					
-					if (interval) {
-						clearInterval(interval);
-					}
-				});
-
-				ws.on('error', (error) => {
-					this._workerDispatcherManager.disconnectWorker(ws['id_worker']);
-
-					console.error('Error on WS Worker', error);
-					ws.close();
-				});
-			}
-				else {
-					// Normal client
-					ws['id_socket'] = 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);
-
-					let socketAdmission: { allowed: boolean, statusCode: number, message: string, clientIp: string };
-					try {
-						socketAdmission = await this.evaluateClientSocketAdmission(ws['id_user'], req);
-					}
-					catch (socketPolicyError) {
-						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 as Error)?.message || socketPolicyError
-						});
-						try {
-							ws.close(1011, 'Socket policy error');
-						}
-						catch {}
-						return;
-					}
-
-					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 {}
-						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?.url,
-						ip: ws['client_ip'],
-						origin: req?.headers?.origin
-					});
-
-				setTimeout(async () => {
-					await this.triggerClientHeartbeat(ws);
-				}, this._clientHeartbeatInitialDelayMs);
-
-				if (this.LOGGER === 'DEBUG') {
-					console.log('Connection from user: ' + req['user']);
-				}
-			
-				ws['isAlive'] = true;
-				ws['retryCnt'] = 0;
-				ws.on('pong', () => {
-					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', async (message: WebSocket.RawData) => {
-					this._debugMsgRecv += 1;
-					let socketData = [];
-					let usedBinary = false;
-					let bufferPayload: Buffer;
-				
-					try {
-						if (typeof message === 'string') {
-							if (message === 'ping' || message === 'pong') {
-								socketData = message;
-							}
-							else {
-								socketData = JSON.parse(message, dateReviver);
-							}
-						}
-						else if (Buffer.isBuffer(message)) {
-							bufferPayload = message;
-							let decodeResult = this.decodeBufferPayload(bufferPayload);
-							socketData = decodeResult.data;
-							usedBinary = decodeResult.usedBinary;
-						}
-						else if (Array.isArray(message)) {
-							bufferPayload = Buffer.concat(message as unknown as ReadonlyArray<Uint8Array>);
-							let decodeResult = this.decodeBufferPayload(bufferPayload);
-							socketData = decodeResult.data;
-							usedBinary = decodeResult.usedBinary;
-						}
-						else if (message instanceof ArrayBuffer) {
-							bufferPayload = Buffer.from(message);
-							let decodeResult = this.decodeBufferPayload(bufferPayload);
-							socketData = decodeResult.data;
-							usedBinary = decodeResult.usedBinary;
-						}
-					else if (ArrayBuffer.isView(message)) {
-						const view = message as NodeJS.ArrayBufferView;
-						bufferPayload = Buffer.from(view.buffer, view.byteOffset, view.byteLength);
-						let decodeResult = this.decodeBufferPayload(bufferPayload);
-						socketData = decodeResult.data;
-						usedBinary = decodeResult.usedBinary;
-					}
-					else {
-						throw new Error('Unsupported WebSocket message type: ' + typeof message);
-					}
-				}
-				catch (e) {
-					console.log('Error - WS message parse', e);
-					const correlationId = objectIdHexString();
-					const context = {
-						rawBinary: bufferPayload ? bufferPayload.toString('base64') : undefined,
-						rawMessage: typeof message === 'string' ? message : undefined,
-						error: e instanceof Error ? { name: e.name, message: e.message, stack: e.stack } : e
-					};
-					await this.reportServerError(
-						'SERVER - JSON Parse Error - ' + ResolveIOServer.getServerConfig()['CLIENT_NAME'],
-						correlationId,
-						context,
-						{ context: 'websocket-message-parse' },
-						'error',
-						e instanceof Error ? e.stack : undefined
-					);
-					return;
-				}
-
-					if (usedBinary) {
-						ws['supportsBinary'] = true;
-					}
-	
-					// call our existing processSocketMessage
-					await this.processSocketMessage(ws, socketData);
-				})
-				.on('end', () => {
-					ws.close();
-				})
-				.on('error', () => {
-					ws.close()
-				})
-				.on('close', async () => {
-					this.logConnectDebug('WS client closed', {
-						id_socket: ws['id_socket'],
-						id_user: ws['id_user'],
-						user: ws['user']
-					});
-					await this.unsubscribeWS(ws);
-				});
-
-				// Do not block message handler registration on DB write; this avoids losing
-				// very-early subscription messages sent immediately after websocket open.
-				setTimeout(async () => {
-					try {
-						await this._subscriptionManager.createLoggedInUser(ws['id_socket']);
-					}
-					catch (error) {
-						console.error(new Date(), 'Error creating logged-in user', ws['id_socket'], error);
-						this.logConnectDebug('Create logged-in user failed', {
-							id_socket: ws['id_socket'],
-							id_user: ws['id_user'],
-							user: ws['user'],
-							error: error?.message || error
-						});
-					}
-				}, 0);
-					}
-				});
-
-		// Keep alive timer
-		setInterval(async () => {
-			for (let ws of this._serverWSS.clients) {
-				if (ws['pingTime'] && Date.now() - ws['pingTime'].getTime() >= this._clientHeartbeatIntervalMs) {
-					if (this.shouldDeferHeartbeat(ws)) {
-						ws['isAlive'] = true;
-						ws['retryCnt'] = 0;
-						ws['pingTime'] = new Date();
-						continue;
-					}
-
-					if (ws['isAlive'] === false) {
-						ws['retryCnt']++;
-						if (ws['retryCnt'] >= 3) {
-							await this.unsubscribeWS(ws);
-						}
-						else {
-							await this.triggerClientHeartbeat(ws);
-						}
-					}
-					else {
-						ws['retryCnt'] = 0;
-						ws['isAlive'] = false;
-						await this.triggerClientHeartbeat(ws);
-					}
-				}
-			}
-		}, this._clientHeartbeatIntervalMs);
-	}
-
-	private async processSocketMessage(ws: WebSocket, socketData: any) {
-		if (typeof socketData === 'string' && socketData === 'ping') {
-			if (ws && ws.readyState === WebSocket.OPEN) {
-				ws.send('pong');
-			}
-			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;
-		}
-
-		// 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;
-		}
-
-		// Handle each sub-message
-		for (let message of socketData) {
-			await this.handleClientMessage(ws, message);
-		}
-	}
-
-	private decodeBufferPayload(buffer: Buffer): { data: any; usedBinary: boolean } {
-		const textPayload = buffer.toString('utf8');
-
-		if (this.looksLikeTextPayload(textPayload)) {
-			try {
-				return { data: this.parseTextFallback(textPayload), usedBinary: false };
-			}
-			catch {
-				// fall through to attempt MessagePack decode
-			}
-		}
-
-		try {
-			return { data: unpack(buffer), usedBinary: true };
-		}
-		catch (binaryErr) {
-			try {
-				return { data: this.parseTextFallback(textPayload), usedBinary: false };
-			}
-			catch {
-				throw binaryErr;
-			}
-		}
-	}
-
-	private parseTextFallback(rawMessage: string): any {
-		if (rawMessage === 'ping' || rawMessage === 'pong') {
-			return rawMessage;
-		}
-
-		try {
-			return JSON.parse(rawMessage, dateReviver);
-		}
-		catch (err) {
-			throw err;
-		}
-	}
-
-	private looksLikeTextPayload(text: string): boolean {
-		if (!text) {
-			return false;
-		}
-
-		const trimmed = text.trim();
-		if (!trimmed) {
-			return false;
-		}
-
-		const first = trimmed[0];
-		return first === '[' || first === '{' || first === '"' || first === 'p' || first === 'P';
-	}
-
-	private resolveConnectDebug(): boolean {
-		const config = ResolveIOServer.getServerConfig ? ResolveIOServer.getServerConfig() : null;
-		const raw = process.env.WS_CONNECT_DEBUG
-			?? process.env.CONNECT_DEBUG
-			?? config?.['WS_CONNECT_DEBUG']
-			?? config?.['CONNECT_DEBUG'];
-		return this.parseDebugFlag(raw);
-	}
-
-	private resolvePerfDebug(): boolean {
-		const config = ResolveIOServer.getServerConfig ? ResolveIOServer.getServerConfig() : null;
-		const raw = process.env.PERF_DEBUG
-			?? process.env.CPU_DEBUG
-			?? config?.['PERF_DEBUG']
-			?? config?.['CPU_DEBUG'];
-		return this.parseDebugFlag(raw);
-	}
-
-	private resolveCpuProfileOnStart(): boolean {
-		const config = ResolveIOServer.getServerConfig ? ResolveIOServer.getServerConfig() : null;
-		const raw = process.env.CPU_PROFILE_ON_START
-			?? process.env.CPU_PROFILE_START
-			?? config?.['CPU_PROFILE_ON_START']
-			?? config?.['CPU_PROFILE_START'];
-		return this.parseDebugFlag(raw);
-	}
-
-	private resolveCpuProfileAuto(): boolean {
-		const config = ResolveIOServer.getServerConfig ? ResolveIOServer.getServerConfig() : null;
-		const raw = process.env.CPU_PROFILE_AUTO
-			?? config?.['CPU_PROFILE_AUTO'];
-		return this.parseDebugFlag(raw);
-	}
-
-	private resolveCpuProfileDurationMs(): number {
-		const config = ResolveIOServer.getServerConfig ? ResolveIOServer.getServerConfig() : null;
-		const raw = process.env.CPU_PROFILE_DURATION_MS
-			?? process.env.PERF_PROFILE_DURATION_MS
-			?? config?.['CPU_PROFILE_DURATION_MS']
-			?? config?.['PERF_PROFILE_DURATION_MS'];
-		return this.parsePositiveInt(raw, this._cpuProfileDurationMs);
-	}
-
-	private resolveCpuProfileThresholdPct(): number {
-		const config = ResolveIOServer.getServerConfig ? ResolveIOServer.getServerConfig() : null;
-		const raw = process.env.CPU_PROFILE_THRESHOLD_PCT
-			?? process.env.PERF_PROFILE_THRESHOLD_PCT
-			?? config?.['CPU_PROFILE_THRESHOLD_PCT']
-			?? config?.['PERF_PROFILE_THRESHOLD_PCT'];
-		return this.parsePositiveFloat(raw, this._cpuProfileThresholdPct);
-	}
-
-	private resolveCpuProfileTriggerCount(): number {
-		const config = ResolveIOServer.getServerConfig ? ResolveIOServer.getServerConfig() : null;
-		const raw = process.env.CPU_PROFILE_TRIGGER_COUNT
-			?? config?.['CPU_PROFILE_TRIGGER_COUNT'];
-		return this.parsePositiveInt(raw, this._cpuProfileTriggerCount);
-	}
-
-	private resolveCpuProfileDir(): string | null {
-		const config = ResolveIOServer.getServerConfig ? ResolveIOServer.getServerConfig() : null;
-		const raw = process.env.CPU_PROFILE_DIR
-			?? config?.['CPU_PROFILE_DIR'];
-		return typeof raw === 'string' && raw.trim() ? raw.trim() : null;
-	}
-
-	private resolveTimerDebug(): boolean {
-		const config = ResolveIOServer.getServerConfig ? ResolveIOServer.getServerConfig() : null;
-		const raw = process.env.TIMER_DEBUG
-			?? config?.['TIMER_DEBUG'];
-		return this.parseDebugFlag(raw);
-	}
-
-	private resolveTimerDebugThresholdMs(): number {
-		const config = ResolveIOServer.getServerConfig ? ResolveIOServer.getServerConfig() : null;
-		const raw = process.env.TIMER_DEBUG_THRESHOLD_MS
-			?? config?.['TIMER_DEBUG_THRESHOLD_MS'];
-		return this.parsePositiveFloat(raw, this._timerDebugThresholdMs);
-	}
-
-	private resolveTimerDebugMinDelayMs(): number {
-		const config = ResolveIOServer.getServerConfig ? ResolveIOServer.getServerConfig() : null;
-		const raw = process.env.TIMER_DEBUG_MIN_DELAY_MS
-			?? config?.['TIMER_DEBUG_MIN_DELAY_MS'];
-		return this.parsePositiveFloat(raw, this._timerDebugMinDelayMs);
-	}
-
-	private resolveTimerDebugSampleRate(): number {
-		const config = ResolveIOServer.getServerConfig ? ResolveIOServer.getServerConfig() : null;
-		const raw = process.env.TIMER_DEBUG_SAMPLE_RATE
-			?? config?.['TIMER_DEBUG_SAMPLE_RATE'];
-		const parsed = parseFloat(raw ?? '');
-		if (Number.isFinite(parsed) && parsed > 0 && parsed <= 1) {
-			return parsed;
-		}
-		return this._timerDebugSampleRate;
-	}
-
-	private resolveTimerDebugLogLimit(): number {
-		const config = ResolveIOServer.getServerConfig ? ResolveIOServer.getServerConfig() : null;
-		const raw = process.env.TIMER_DEBUG_LOG_LIMIT
-			?? config?.['TIMER_DEBUG_LOG_LIMIT'];
-		return this.parsePositiveInt(raw, this._timerDebugLogLimit);
-	}
-
-	private resolveStandaloneNodeReaperEnabled(): boolean {
-		const config = ResolveIOServer.getServerConfig ? ResolveIOServer.getServerConfig() : null;
-		const raw = process.env.RESOLVEIO_STANDALONE_NODE_REAPER_ENABLED
-			?? process.env.STANDALONE_NODE_REAPER_ENABLED
-			?? config?.['RESOLVEIO_STANDALONE_NODE_REAPER_ENABLED']
-			?? config?.['STANDALONE_NODE_REAPER_ENABLED'];
-		const configured = this.parseOptionalBoolean(raw);
-		if (configured !== null) {
-			return configured;
-		}
-
-		return this.isPm2ManagedRuntime() && !this.isLocalRuntime();
-	}
-
-	private resolveStandaloneNodeReaperIntervalMs(): number {
-		const config = ResolveIOServer.getServerConfig ? ResolveIOServer.getServerConfig() : null;
-		const raw = process.env.RESOLVEIO_STANDALONE_NODE_REAPER_INTERVAL_MS
-			?? process.env.STANDALONE_NODE_REAPER_INTERVAL_MS
-			?? config?.['RESOLVEIO_STANDALONE_NODE_REAPER_INTERVAL_MS']
-			?? config?.['STANDALONE_NODE_REAPER_INTERVAL_MS'];
-		return this.parsePositiveInt(raw, this._standaloneNodeReaperIntervalMs);
-	}
-
-	private resolveStandaloneNodeReaperMinAgeSeconds(): number {
-		const config = ResolveIOServer.getServerConfig ? ResolveIOServer.getServerConfig() : null;
-		const raw = process.env.RESOLVEIO_STANDALONE_NODE_REAPER_MIN_AGE_SECONDS
-			?? process.env.STANDALONE_NODE_REAPER_MIN_AGE_SECONDS
-			?? config?.['RESOLVEIO_STANDALONE_NODE_REAPER_MIN_AGE_SECONDS']
-			?? config?.['STANDALONE_NODE_REAPER_MIN_AGE_SECONDS'];
-		return this.parsePositiveInt(raw, this._standaloneNodeReaperMinAgeSeconds);
-	}
-
-	private resolveStandaloneNodeReaperMaxKillsPerSignature(): number {
-		const config = ResolveIOServer.getServerConfig ? ResolveIOServer.getServerConfig() : null;
-		const raw = process.env.RESOLVEIO_STANDALONE_NODE_REAPER_MAX_KILLS_PER_SIGNATURE
-			?? process.env.STANDALONE_NODE_REAPER_MAX_KILLS_PER_SIGNATURE
-			?? config?.['RESOLVEIO_STANDALONE_NODE_REAPER_MAX_KILLS_PER_SIGNATURE']
-			?? config?.['STANDALONE_NODE_REAPER_MAX_KILLS_PER_SIGNATURE'];
-		return this.parsePositiveInt(raw, this._standaloneNodeReaperMaxKillsPerSignature);
-	}
-
-	private resolveStandaloneNodeReaperKillWindowMs(): number {
-		const config = ResolveIOServer.getServerConfig ? ResolveIOServer.getServerConfig() : null;
-		const raw = process.env.RESOLVEIO_STANDALONE_NODE_REAPER_KILL_WINDOW_MS
-			?? process.env.STANDALONE_NODE_REAPER_KILL_WINDOW_MS
-			?? config?.['RESOLVEIO_STANDALONE_NODE_REAPER_KILL_WINDOW_MS']
-			?? config?.['STANDALONE_NODE_REAPER_KILL_WINDOW_MS'];
-		return this.parsePositiveInt(raw, this._standaloneNodeReaperKillWindowMs);
-	}
-
-	private resolveStandaloneNodeReaperIncludeSystemdServices(): boolean {
-		const config = ResolveIOServer.getServerConfig ? ResolveIOServer.getServerConfig() : null;
-		const raw = process.env.RESOLVEIO_STANDALONE_NODE_REAPER_INCLUDE_SYSTEMD_SERVICES
-			?? process.env.STANDALONE_NODE_REAPER_INCLUDE_SYSTEMD_SERVICES
-			?? config?.['RESOLVEIO_STANDALONE_NODE_REAPER_INCLUDE_SYSTEMD_SERVICES']
-			?? config?.['STANDALONE_NODE_REAPER_INCLUDE_SYSTEMD_SERVICES'];
-		return this.parseDebugFlag(raw);
-	}
-
-	private resolveStandaloneNodeReaperHighCpuPct(): number {
-		const config = ResolveIOServer.getServerConfig ? ResolveIOServer.getServerConfig() : null;
-		const raw = process.env.RESOLVEIO_STANDALONE_NODE_REAPER_HIGH_CPU_PCT
-			?? process.env.STANDALONE_NODE_REAPER_HIGH_CPU_PCT
-			?? config?.['RESOLVEIO_STANDALONE_NODE_REAPER_HIGH_CPU_PCT']
-			?? config?.['STANDALONE_NODE_REAPER_HIGH_CPU_PCT'];
-		return this.parsePositiveFloat(raw, this._standaloneNodeReaperHighCpuPct);
-	}
-
-	private resolveStandaloneNodeReaperHighRssMb(): number {
-		const config = ResolveIOServer.getServerConfig ? ResolveIOServer.getServerConfig() : null;
-		const raw = process.env.RESOLVEIO_STANDALONE_NODE_REAPER_HIGH_RSS_MB
-			?? process.env.STANDALONE_NODE_REAPER_HIGH_RSS_MB
-			?? config?.['RESOLVEIO_STANDALONE_NODE_REAPER_HIGH_RSS_MB']
-			?? config?.['STANDALONE_NODE_REAPER_HIGH_RSS_MB'];
-		return this.parsePositiveFloat(raw, this._standaloneNodeReaperHighRssMb);
-	}
-
-	private resolveStandaloneNodeReaperHighMinAgeSeconds(): number {
-		const config = ResolveIOServer.getServerConfig ? ResolveIOServer.getServerConfig() : null;
-		const raw = process.env.RESOLVEIO_STANDALONE_NODE_REAPER_HIGH_MIN_AGE_SECONDS
-			?? process.env.STANDALONE_NODE_REAPER_HIGH_MIN_AGE_SECONDS
-			?? config?.['RESOLVEIO_STANDALONE_NODE_REAPER_HIGH_MIN_AGE_SECONDS']
-			?? config?.['STANDALONE_NODE_REAPER_HIGH_MIN_AGE_SECONDS'];
-		return this.parsePositiveInt(raw, this._standaloneNodeReaperHighMinAgeSeconds);
-	}
-
-	private resolveStandaloneNodeReaperHighConsecutiveScans(): number {
-		const config = ResolveIOServer.getServerConfig ? ResolveIOServer.getServerConfig() : null;
-		const raw = process.env.RESOLVEIO_STANDALONE_NODE_REAPER_HIGH_CONSECUTIVE_SCANS
-			?? process.env.STANDALONE_NODE_REAPER_HIGH_CONSECUTIVE_SCANS
-			?? config?.['RESOLVEIO_STANDALONE_NODE_REAPER_HIGH_CONSECUTIVE_SCANS']
-			?? config?.['STANDALONE_NODE_REAPER_HIGH_CONSECUTIVE_SCANS'];
-		return this.parsePositiveInt(raw, this._standaloneNodeReaperHighConsecutiveScans);
-	}
-
-	private resolveStandaloneNodeReaperDryRun(): boolean {
-		const config = ResolveIOServer.getServerConfig ? ResolveIOServer.getServerConfig() : null;
-		const raw = process.env.RESOLVEIO_STANDALONE_NODE_REAPER_DRY_RUN
-			?? process.env.STANDALONE_NODE_REAPER_DRY_RUN
-			?? config?.['RESOLVEIO_STANDALONE_NODE_REAPER_DRY_RUN']
-			?? config?.['STANDALONE_NODE_REAPER_DRY_RUN'];
-		return this.parseDebugFlag(raw);
-	}
-
-	private resolveStandaloneNodeReaperAlertWindowMs(): number {
-		const config = ResolveIOServer.getServerConfig ? ResolveIOServer.getServerConfig() : null;
-		const raw = process.env.RESOLVEIO_STANDALONE_NODE_REAPER_ALERT_WINDOW_MS
-			?? process.env.STANDALONE_NODE_REAPER_ALERT_WINDOW_MS
-			?? config?.['RESOLVEIO_STANDALONE_NODE_REAPER_ALERT_WINDOW_MS']
-			?? config?.['STANDALONE_NODE_REAPER_ALERT_WINDOW_MS'];
-		return this.parsePositiveInt(raw, this._standaloneNodeReaperAlertWindowMs);
-	}
-
-	private isPm2ManagedRuntime(): boolean {
-		return Boolean(
-			process.env.pm_id
-			|| process.env.PM2_HOME
-			|| process.env.NODE_APP_INSTANCE
-			|| `${process.env._ || ''}`.includes('pm2')
-		);
-	}
-
-	private isPrimaryPm2Instance(): boolean {
-		const appInstance = this.normalizeWorkerSelectorValue(process.env.NODE_APP_INSTANCE);
-		return !appInstance || appInstance === '0';
-	}
-
-	private isLocalRuntime(): boolean {
-		const config = ResolveIOServer.getServerConfig ? ResolveIOServer.getServerConfig() : null;
-		const rootUrl = `${process.env.ROOT_URL || config?.['ROOT_URL'] || ''}`.trim().toLowerCase();
-		const serverUrl = `${process.env.SERVER_URL || config?.['SERVER_URL'] || ''}`.trim().toLowerCase();
-		return rootUrl.includes('localhost') || rootUrl.includes('127.0.0.1') || serverUrl.includes('localhost') || serverUrl.includes('127.0.0.1');
-	}
-
-	private normalizeWorkerSelectorValue(value?: string | number | null): string | null {
-		if (value === null || value === undefined) {
-			return null;
-		}
-
-		const normalized = String(value).trim();
-		return normalized.length ? normalized : null;
-	}
-
-	private shouldStartCronManagerForWorker(): boolean {
-		const workerIndex = this.normalizeWorkerSelectorValue(process.env.WORKER_INDEX);
-		const workerInstance = this.normalizeWorkerSelectorValue(process.env.NODE_APP_INSTANCE) || '0';
-		const hasExplicitServerManagerOwner = process.env.SERVER_MANAGER_WORKER_INDEX !== undefined
-			|| process.env.SERVER_MANAGER_WORKER_INSTANCE !== undefined
-			|| process.env.SERVER_MANAGER_NODE_APP_INSTANCE !== undefined;
-
-		if (!hasExplicitServerManagerOwner) {
-			return workerIndex === '0';
-		}
-
-		const serverManagerWorkerIndex = this.normalizeWorkerSelectorValue(process.env.SERVER_MANAGER_WORKER_INDEX) || '0';
-		const serverManagerWorkerInstance = this.normalizeWorkerSelectorValue(
-			process.env.SERVER_MANAGER_WORKER_INSTANCE || process.env.SERVER_MANAGER_NODE_APP_INSTANCE
-		) || '0';
-
-		return workerIndex === serverManagerWorkerIndex && workerInstance === serverManagerWorkerInstance;
-	}
-
-	private parseWorkerSelector(value: any): Set<string> | null {
-		if (value === null || value === undefined) {
-			return null;
-		}
-
-		const raw = Array.isArray(value) ? value.join(',') : String(value);
-		const parts = raw.split(',').map(part => part.trim()).filter(Boolean);
-		if (!parts.length) {
-			return null;
-		}
-
-		return new Set(parts);
-	}
-
-	private workerMatchesSelector(
-		workerIndex: string | null,
-		workerInstance: string | null,
-		indexes: Set<string> | null,
-		instances: Set<string> | null
-	): boolean {
-		if (!indexes && !instances) {
-			return false;
-		}
-
-		const indexMatch = indexes ? (workerIndex ? indexes.has(workerIndex) : false) : true;
-		const instanceMatch = instances ? (workerInstance ? instances.has(workerInstance) : false) : true;
-		return indexMatch && instanceMatch;
-	}
-
-	private resolveWorkerRole(): 'Codex' | 'Subscription' | 'Other' {
-		const workerIndex = this.normalizeWorkerSelectorValue(process.env.WORKER_INDEX);
-		const workerInstance = this.normalizeWorkerSelectorValue(process.env.NODE_APP_INSTANCE);
-		const publicationIndexes = this.parseWorkerSelector(
-			process.env.PUBLICATION_WORKER_INDEX
-			|| process.env.SUBSCRIPTION_WORKER_INDEX
-			|| process.env.WORKER_PUBLICATION_INDEX
-		);
-		const publicationInstances = this.parseWorkerSelector(
-			process.env.PUBLICATION_WORKER_INSTANCE
-			|| process.env.SUBSCRIPTION_WORKER_INSTANCE
-			|| process.env.WORKER_PUBLICATION_INSTANCE
-		);
-		const codexIndexes = this.parseWorkerSelector(
-			process.env.AI_ASSISTANT_CODEX_WORKER_INDEX
-			|| process.env.CODEX_WORKER_INDEX
-			|| process.env.WORKER_CODEX_INDEX
-		);
-		const 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';
-	}
-
-	private parsePositiveInt(value: any, fallback: number): number {
-		const parsed = parseInt(value ?? '', 10);
-		if (Number.isNaN(parsed) || parsed <= 0) {
-			return fallback;
-		}
-		return parsed;
-	}
-
-	private parsePositiveFloat(value: any, fallback: number): number {
-		const parsed = parseFloat(value ?? '');
-		if (Number.isNaN(parsed) || parsed <= 0) {
-			return fallback;
-		}
-		return parsed;
-	}
-
-	private startPerfDebug(): void {
-		if (!this._perfDebug || this._perfDebugTimer) {
-			return;
-		}
-
-		this._perfDebugIntervalMs = this.parsePositiveInt(
-			process.env.PERF_DEBUG_INTERVAL_MS ?? process.env.CPU_DEBUG_INTERVAL_MS,
-			this._perfDebugIntervalMs
-		);
-
-		this._perfDebugLastCpu = process.cpuUsage();
-		this._perfDebugLastTs = Date.now();
-		this._eventLoopHistogram = monitorEventLoopDelay({ resolution: 20 });
-		this._eventLoopHistogram.enable();
-
-		this._perfDebugTimer = setInterval(() => {
-			const now = Date.now();
-			const elapsedMs = now - this._perfDebugLastTs;
-			const cpuDiff = this._perfDebugLastCpu ? process.cpuUsage(this._perfDebugLastCpu) : process.cpuUsage();
-			const cpuMs = (cpuDiff.user + cpuDiff.system) / 1000;
-			const cpuPct = elapsedMs > 0 ? (cpuMs / elapsedMs) * 100 : 0;
-
-			const mem = process.memoryUsage();
-			const heapUsedMb = round((mem.heapUsed / 1024 / 1024) * 10) / 10;
-			const rssMb = round((mem.rss / 1024 / 1024) * 10) / 10;
-
-			const handles = typeof (process as any)._getActiveHandles === 'function'
-				? (process as any)._getActiveHandles().length
-				: null;
-			const requests = typeof (process as any)._getActiveRequests === 'function'
-				? (process as any)._getActiveRequests().length
-				: null;
-
-			const histogram = this._eventLoopHistogram;
-			const eventLoop = histogram ? {
-				meanMs: round((histogram.mean / 1e6) * 100) / 100,
-				p50Ms: round((histogram.percentile(50) / 1e6) * 100) / 100,
-				p95Ms: round((histogram.percentile(95) / 1e6) * 100) / 100,
-				p99Ms: round((histogram.percentile(99) / 1e6) * 100) / 100,
-				maxMs: round((histogram.max / 1e6) * 100) / 100
-			} : null;
-			histogram?.reset();
-
-			console.log(new Date(), '[Perf Debug]', JSON.stringify({
-				cpuPct: round(cpuPct * 10) / 10,
-				cpuMs: round(cpuMs),
-				elapsedMs,
-				eventLoop,
-				heapUsedMb,
-				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);
-	}
-
-	private installTimerDebug(): void {
-		if (!this._timerDebug) {
-			return;
-		}
-
-		const g = global as unknown as { __resolveioTimerDebugInstalled?: boolean };
-		if (g.__resolveioTimerDebugInstalled) {
-			return;
-		}
-		g.__resolveioTimerDebugInstalled = true;
-
-		const originalSetTimeout = global.setTimeout;
-		const originalSetInterval = global.setInterval;
-		const thresholdMs = this._timerDebugThresholdMs;
-		const minDelayMs = this._timerDebugMinDelayMs;
-		const sampleRate = this._timerDebugSampleRate;
-
-		const shouldSample = () => sampleRate >= 1 || Math.random() <= sampleRate;
-
-		const logTimer = (type: string, durationMs: number, delayMs: number | undefined, createdStack: string | undefined) => {
-			if (this._timerDebugLogLimit > 0 && this._timerDebugLogCount >= this._timerDebugLogLimit) {
-				return;
-			}
-			this._timerDebugLogCount += 1;
-			const stackLines = createdStack
-				? createdStack.split('\n').slice(1, 6).map(line => line.trim()).join(' | ')
-				: undefined;
-			console.log(new Date(), '[Timer Debug]', JSON.stringify({
-				type,
-				durationMs: round(durationMs * 10) / 10,
-				delayMs: delayMs ?? null,
-				createdAt: stackLines
-			}));
-		};
-
-		const wrapTimer = (handler: any, type: string, delayMs?: number) => {
-			if (typeof handler !== 'function') {
-				return handler;
-			}
-
-			const createdStack = new Error().stack;
-			const shouldFlagShortDelay = typeof delayMs === 'number' && delayMs <= minDelayMs;
-
-			return function wrappedTimer(this: any, ...args: any[]) {
-				const start = process.hrtime.bigint();
-				try {
-					return handler.apply(this, args);
-				}
-				finally {
-					const elapsedMs = Number(process.hrtime.bigint() - start) / 1e6;
-					if (shouldSample() && (elapsedMs >= thresholdMs || shouldFlagShortDelay)) {
-						logTimer(type, elapsedMs, delayMs, createdStack);
-					}
-				}
-			};
-		};
-
-		global.setTimeout = ((handler: any, timeout?: number, ...args: any[]) => {
-			return originalSetTimeout(wrapTimer(handler, 'setTimeout', timeout), timeout as any, ...args);
-		}) as typeof setTimeout;
-
-		global.setInterval = ((handler: any, timeout?: number, ...args: any[]) => {
-			return originalSetInterval(wrapTimer(handler, 'setInterval', timeout), timeout as any, ...args);
-		}) as typeof setInterval;
-	}
-
-	private startCpuProfile(trigger: string): void {
-		if (this._cpuProfileSession) {
-			return;
-		}
-
-		try {
-			const session = new inspector.Session();
-			session.connect();
-			session.post('Profiler.enable', () => {
-				session.post('Profiler.start', () => {
-					this._cpuProfileSession = session;
-					console.log(new Date(), '[Perf Debug]', 'CPU profile started', trigger);
-					setTimeout(() => {
-						this.stopCpuProfile(trigger);
-					}, this._cpuProfileDurationMs);
-				});
-			});
-		}
-		catch (error) {
-			console.error(new Date(), '[Perf Debug]', 'CPU profile start failed', error);
-		}
-	}
-
-	private stopCpuProfile(trigger: string): void {
-		const session = this._cpuProfileSession;
-		if (!session) {
-			return;
-		}
-
-		session.post('Profiler.stop', (err, res: { profile?: unknown }) => {
-			if (err) {
-				console.error(new Date(), '[Perf Debug]', 'CPU profile stop failed', err);
-			}
-			else {
-				try {
-					const dir = this.resolveWritableProfileDir();
-					const filename = `resolveio-cpuprofile-${process.pid}-${Date.now()}.cpuprofile`;
-					const filePath = path.join(dir, filename);
-					fs.writeFileSync(filePath, JSON.stringify(res?.profile ?? {}));
-					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 {}
-
-			this._cpuProfileSession = null;
-		});
-	}
-
-	private resolveWritableProfileDir(): string {
-		const preferred = this._cpuProfileDir;
-		if (preferred) {
-			try {
-				fs.mkdirSync(preferred, { recursive: true });
-				return preferred;
-			}
-			catch {}
-		}
-
-		return os.tmpdir();
-	}
-
-	private parseDebugFlag(value: any): boolean {
-		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') {
-			const normalized = value.trim().toLowerCase();
-			return ['1', 'true', 'yes', 'y', 'on'].includes(normalized);
-		}
-
-		return false;
-	}
-
-	private parseOptionalBoolean(value: any): boolean | null {
-		if (value === null || value === undefined) {
-			return null;
-		}
-		const normalized = `${value}`.trim();
-		if (!normalized) {
-			return null;
-		}
-		return this.parseDebugFlag(normalized);
-	}
-
-	private parseNonNegativeInt(value: any, fallback: number): number {
-		const parsed = parseInt(`${value ?? ''}`, 10);
-		if (Number.isNaN(parsed) || parsed < 0) {
-			return fallback;
-		}
-		return parsed;
-	}
-
-	private resolveSocketTier(): string {
-		const config = ResolveIOServer.getServerConfig() || {};
-		return `${process.env.AI_CODER_PLAN_TIER || config['AI_CODER_PLAN_TIER'] || ''}`.trim().toLowerCase();
-	}
-
-	private resolveSocketTierKeySuffix(planTier: string): string {
-		return `${planTier || ''}`
-			.trim()
-			.toUpperCase()
-			.replace(/[^A-Z0-9]+/g, '_');
-	}
-
-	private resolveMaxClientSockets(planTier: string): number {
-		const config = ResolveIOServer.getServerConfig() || {};
-		const explicitLimit = this.parseNonNegativeInt(
-			config['AI_CODER_MAX_SOCKETS'] ?? process.env.AI_CODER_MAX_SOCKETS,
-			-1
-		);
-		if (explicitLimit >= 0) {
-			return explicitLimit;
-		}
-
-		const normalizedTier = `${planTier || ''}`.trim().toLowerCase();
-		const tierKeySuffix = this.resolveSocketTierKeySuffix(normalizedTier);
-		if (tierKeySuffix) {
-			const tierLimitKey = `AI_CODER_MAX_SOCKETS_${tierKeySuffix}`;
-			const tierLimit = this.parseNonNegativeInt(
-				config[tierLimitKey] ?? process.env[tierLimitKey],
-				-1
-			);
-			if (tierLimit >= 0) {
-				return tierLimit;
-			}
-		}
-
-		const maxUsers = this.parseNonNegativeInt(
-			config['AI_CODER_MAX_USERS'] ?? 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;
-	}
-
-	private resolveSingleIpPerUserPolicy(planTier: string): boolean {
-		const config = ResolveIOServer.getServerConfig() || {};
-		const normalizedTier = `${planTier || ''}`.trim().toLowerCase();
-		const tierKeySuffix = this.resolveSocketTierKeySuffix(normalizedTier);
-		if (tierKeySuffix) {
-			const tierPolicyKey = `AI_CODER_SINGLE_IP_PER_USER_${tierKeySuffix}`;
-			const tierPolicy = this.parseOptionalBoolean(
-				config[tierPolicyKey] ?? process.env[tierPolicyKey]
-			);
-			if (tierPolicy !== null) {
-				return tierPolicy;
-			}
-		}
-
-		const policy = this.parseOptionalBoolean(
-			config['AI_CODER_SINGLE_IP_PER_USER'] ?? process.env.AI_CODER_SINGLE_IP_PER_USER
-		);
-		if (policy !== null) {
-			return policy;
-		}
-
-		return !!normalizedTier;
-	}
-
-	private resolveSocketPolicyUpgradeUrl(): string {
-		const config = ResolveIOServer.getServerConfig() || {};
-		const direct = `${config['AI_CODER_SOCKET_UPGRADE_URL'] || process.env.AI_CODER_SOCKET_UPGRADE_URL || ''}`.trim();
-		if (direct) {
-			return direct.replace(/\/$/, '');
-		}
-
-		const dashboard = `${config['AI_CODER_CLIENT_DASHBOARD_URL'] || process.env.AI_CODER_CLIENT_DASHBOARD_URL || ''}`.trim();
-		if (dashboard) {
-			return dashboard.replace(/\/$/, '');
-		}
-
-		const root = `${config['AI_CODER_ROOT_URL'] || process.env.AI_CODER_ROOT_URL || config['ROOT_URL'] || process.env.ROOT_URL || ''}`.trim();
-		if (!root) {
-			return '';
-		}
-
-		return `${root.replace(/\/$/, '')}/dashboard/client`;
-	}
-
-	private resolveSocketUpgradeUrlWithAppId(): string {
-		const base = `${this._socketPolicyUpgradeUrl || ''}`.trim();
-		if (!base) {
-			return '';
-		}
-		const appId = `${process.env.AI_CODER_APP_ID || ''}`.trim();
-		if (!appId) {
-			return base;
-		}
-		const separator = base.includes('?') ? '&' : '?';
-		return `${base}${separator}appId=${encodeURIComponent(appId)}`;
-	}
-
-	private normalizeIpAddress(value: any): string {
-		let ip = `${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();
-	}
-
-	private resolveClientIp(req: any): string {
-		const forwardedFor = this.normalizeHeaderValue(req?.headers?.['x-forwarded-for']);
-		if (forwardedFor) {
-			return this.normalizeIpAddress(forwardedFor);
-		}
-		const realIp = this.normalizeHeaderValue(req?.headers?.['x-real-ip']);
-		if (realIp) {
-			return this.normalizeIpAddress(realIp);
-		}
-		const socketIp = req?.socket?.remoteAddress || req?.connection?.remoteAddress || req?.ip || '';
-		return this.normalizeIpAddress(socketIp);
-	}
-
-	private buildSocketLimitMessage(activeSockets: number): string {
-		const tierLabel = this._socketTier ? this._socketTier[0].toUpperCase() + this._socketTier.slice(1) : 'Current';
-		const upgradeUrl = this.resolveSocketUpgradeUrlWithAppId();
-		const base = `Socket connection limit reached (${activeSockets}/${this._maxClientSockets}) for the ${tierLabel} tier.`;
-		if (!upgradeUrl) {
-			return `${base} Upgrade to increase capacity.`;
-		}
-		return `${base} Upgrade at ${upgradeUrl}.`;
-	}
-
-	private buildSocketLimitCloseReason(): string {
-		return `Socket limit reached (${this._maxClientSockets})`;
-	}
-
-	private async disconnectUserSocketsFromDifferentIps(idUser: string, incomingIp: string): Promise<number> {
-		if (!this._websocketManager) {
-			return 0;
-		}
-
-		const normalizedUser = `${idUser || ''}`.trim();
-		const normalizedIncomingIp = this.normalizeIpAddress(incomingIp);
-		if (!normalizedUser || !normalizedIncomingIp) {
-			return 0;
-		}
-
-		const userSockets = this._websocketManager.getUserWebSockets(normalizedUser);
-		let disconnected = 0;
-		for (const existingSocket of userSockets) {
-			const existingIp = this.normalizeIpAddress(existingSocket?.['client_ip']);
-			if (!existingIp || existingIp === normalizedIncomingIp) {
-				continue;
-			}
-
-			this.logConnectDebug('WS single-ip enforcement disconnect', {
-				id_socket: existingSocket?.['id_socket'],
-				id_user: normalizedUser,
-				existingIp,
-				incomingIp: normalizedIncomingIp
-			});
-
-			await this.unsubscribeWS(existingSocket);
-			if (existingSocket.readyState === WebSocket.OPEN || existingSocket.readyState === WebSocket.CONNECTING) {
-				try {
-					existingSocket.close(1008, 'Signed in from another IP');
-				}
-				catch {}
-			}
-			disconnected += 1;
-		}
-
-		return disconnected;
-	}
-
-	private async evaluateClientSocketAdmission(idUser: string, req: any): Promise<{ allowed: boolean, statusCode: number, message: string, clientIp: string }> {
-		const normalizedUser = `${idUser || ''}`.trim();
-		const clientIp = this.resolveClientIp(req);
-
-		if (this._singleIpPerUser) {
-			await this.disconnectUserSocketsFromDifferentIps(normalizedUser, clientIp);
-		}
-
-		if (this._maxClientSockets > 0 && this._websocketManager) {
-			const activeSockets = this._websocketManager.getActiveWebSocketCount();
-			if (activeSockets >= this._maxClientSockets) {
-				const message = this.buildSocketLimitMessage(activeSockets);
-				this.logConnectDebug('WS socket limit blocked', {
-					id_user: normalizedUser,
-					clientIp,
-					activeSockets,
-					maxClientSockets: this._maxClientSockets
-				});
-				return {
-					allowed: false,
-					statusCode: 429,
-					message,
-					clientIp
-				};
-			}
-		}
-
-		return {
-			allowed: true,
-			statusCode: 200,
-			message: '',
-			clientIp
-		};
-	}
-
-	private logConnectDebug(message: string, details?: Record<string, unknown>): void {
-		if (!this._wsConnectDebug) {
-			return;
-		}
-
-		if (details) {
-			console.log(new Date(), '[Connect Debug]', message, JSON.stringify(details));
-		}
-		else {
-			console.log(new Date(), '[Connect Debug]', message);
-		}
-	}
-
-	private async triggerClientHeartbeat(ws: WebSocket): Promise<void> {
-		if (!ws || ws.readyState !== WebSocket.OPEN) {
-			return;
-		}
-
-		ws['pingTime'] = new Date();
-
-		try {
-			if (typeof ws.ping === 'function') {
-				ws.ping();
-			}
-		}
-		catch (err) {
-			if (this._methodManager?.getEnableDebug()) {
-				console.log(new Date(), 'Server App', 'Error WS Ping Frame', err);
-			}
-			await this.unsubscribeWS(ws);
-			return;
-		}
-
-		ws.send('ping', async (error) => {
-			if (error) {
-				if (this._methodManager?.getEnableDebug()) {
-					console.log(new Date(), 'Server App', 'Error WS Ping');
-				}
-				await this.unsubscribeWS(ws);
-			}
-		});
-	}
-
-	private shouldDeferHeartbeat(ws: WebSocket): boolean {
-		if (!ws || ws.readyState !== WebSocket.OPEN) {
-			return false;
-		}
-
-		const bufferedAmount = typeof ws.bufferedAmount === 'number' ? ws.bufferedAmount : 0;
-		return bufferedAmount >= this._clientHeartbeatBackpressureBytes;
-	}
-
-	private async handleClientMessage(ws: WebSocket, msg: any[]): Promise<void> {
-		// This is basically your old logic from processSocketMessage,
-		// but we'll insert our worker-queue logic for "method" calls.
-		try {
-			let messageRoute = msg[0];
-			let messageDate = msg[1];
-			let messageId = msg[2];
-			let type = msg[3];
-
-			if (!this.publicProgram && this._clientRoutes.some(a => messageRoute.includes(a)) && !ws['doc_user'].roles.groups.some(a => a.views.some(b => messageRoute.includes(b) || b.includes(messageRoute))) && !ws['doc_user'].roles.super_admin) {
-				return;
-			}
-
-			if (type === 'subscription') {
-				let subType = msg[4];
-				let pub = msg[5];
-				this.logConnectDebug('Subscription message', {
-					subType,
-					publication: pub,
-					messageId,
-					messageRoute,
-					args: Math.max(0, msg.length - 6),
-					id_socket: ws ? ws['id_socket'] : null,
-					user: ws ? ws['user'] : null
-				});
-
-				if (subType === 'sub') {
-					await this._subscriptionManager.subscribe(messageRoute, messageDate, ws, messageId, pub, msg.slice(6));
-				}
-				else {
-					this._subscriptionManager.unsubscribe(messageRoute, messageDate, ws, messageId, pub, msg.slice(6));
-				}
-			}
-			else if (!this.publicProgram && type === 'offline') {
-				let serverRes: ServerResponseModel = {
-					messageId: messageId,
-					hasError: false,
-					data: 'ACK'
-				};
-
-				if (ws && ws.readyState === WebSocket.OPEN) {
-					this._websocketManager.send(ws, serverRes);
-				}
-
-				this._offlineUpdates.push(ws);
-				let offlineUpdates = msg[4];
-
-				for (let i = 0; i < offlineUpdates.length; i++) {
-					let update = offlineUpdates[i];
-
-					let data = update.data;
-
-					// eslint-disable-next-line no-unused-vars
-					let updateRoute = data.shift();
-					// eslint-disable-next-line no-unused-vars
-					let updateDate = data.shift();
-					let updateMessageId = data.shift();
-					// eslint-disable-next-line no-unused-vars
-					let updateType = data.shift();
-					let method = data.shift();
-
-					let serverResMethod: ServerResponseModel = {
-						messageId: updateMessageId,
-						hasError: false,
-						data: 'ACK'
-					};
-
-					if (ws && ws.readyState === WebSocket.OPEN) {
-						this._websocketManager.send(ws, serverResMethod);
-					}
-
-					if (method === 'insertDocument' && data[0] === 'driver-gps') {
-						continue;
-					}
-					
-					if (shouldWriteClientRequestLog(method)) {
-						if (
-							ResolveIOServer.shouldWriteLogsOffline()
-						) {
-							ResolveIOServer.getLocalLogManager().writeLog({
-								type: 'log',
-								data: {
-									_id: objectIdHexString(),
-									createdAt: new Date(),
-									type: 'client-request',
-									collection: '',
-									id_document: '',
-									payload: 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,
-									instance_index: process.env.NODE_APP_INSTANCE || '0'
-								}
-							});
-						}
-						else {
-							await Logs.insertOne({
-								_id: objectIdHexString(),
-								type: 'client-request',
-								collection: '',
-								id_document: '',
-								payload: 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,
-								client: 'ResolveIO',
-								instance: ResolveIOServer.getInstanceHost(),
-								instance_index: process.env.NODE_APP_INSTANCE || '0'
-							});
-						}
-					}
-
-					if (this._methodManager._methods[method]) {
-						try {
-							await this._methodManager.callMethod.call(Object.assign({}, this._methodManager, MethodManager.prototype, {id_user: ws['id_user'], user: ws['user'], id_ws: ws['id_socket']}), method, ...data);
-						}
-						catch (err) {
-							console.log(new Date(), 'Offline Error', JSON.stringify(err, null, 2));
-						}
-
-						if (method === 'updateDocumentOffline' || method === 'updateDocumentPropsOffline') {
-							ResolveIOServer.getMongoManager().invalidateQueryCache(data[0]);
-						}
-					}
-					else {
-						console.log('Offline - Could not find method: ' + method);
-					}
-				}
-
-				this._offlineUpdates.splice(this._offlineUpdates.map(a => a['id_socket']).indexOf(ws['id_socket']), 1);
-			}
-			else {
-				// It's presumably a 'method' or something else
-				let dataCopy = [...msg];
-
-				dataCopy.shift();
-				// eslint-disable-next-line no-unused-vars
-				let date = dataCopy.shift();
-				let msgId = dataCopy.shift();
-				let msgType = dataCopy.shift();
-				
-				if (msgType === 'method') {
-					let methodName = dataCopy.shift();
-
-					if (ws['user_readonly']) {
-						return;
-					}
-
-					if (shouldWriteClientRequestLog(methodName)) {
-						if (
-							ResolveIOServer.shouldWriteLogsOffline()
-						) {
-							ResolveIOServer.getLocalLogManager().writeLog({
-								type: 'log',
-								data: {
-									_id: objectIdHexString(),
-									createdAt: new Date(),
-									type: 'client-request',
-									collection: '',
-									id_document: '',
-									payload: getBinarySize(JSON.stringify([dataCopy])) < 1000000 ? JSON.stringify([dataCopy], null, 2) : 'Too Big',
-									method: methodName,
-									id_user: ws['id_user'] || '',
-									user: ws['user'] || '',
-									messageId: messageId,
-									route: messageRoute,
-									instance_index: process.env.NODE_APP_INSTANCE || '0'
-								}
-							});
-						}
-						else {
-							await Logs.insertOne({
-								_id: objectIdHexString(),
-								type: 'client-request',
-								collection: '',
-								id_document: '',
-								payload: getBinarySize(JSON.stringify([dataCopy])) < 1000000 ? JSON.stringify([dataCopy], null, 2) : 'Too Big',
-								method: methodName,
-								id_user: ws['id_user'] || '',
-								user: ws['user'] || '',
-								messageId: messageId,
-								route: messageRoute,
-								client: 'ResolveIO',
-								instance: ResolveIOServer.getInstanceHost(),
-								instance_index: process.env.NODE_APP_INSTANCE || '0'
-							});
-						}
-					}
-
-					// Immediately ACK
-					let ack: ServerResponseModel = {
-						messageId: msgId,
-						hasError: false,
-						data: 'ACK'
-					};
-
-					if (ws && ws.readyState === WebSocket.OPEN) {
-						this._websocketManager.send(ws, ack);
-					}
-
-					let method = this._methodManager.getMethod(methodName);
-					const forceWorker = this._isWorkersEnabled && !!method?.forceWorker;
-					const targetWorkerIndex = this._isWorkersEnabled && method ? method.targetWorkerIndex : null;
-					const targetWorkerInstance = this._isWorkersEnabled && method ? method.targetWorkerInstance : null;
-					const hasWorkerForMethod = this._workerDispatcherManager ? this._workerDispatcherManager.hasWorkersForMethod(methodName) : false;
-					const isAiCodex = methodName === 'aiCoderTerminalRunCodex' || methodName === 'aiCoderAppRunCodex';
-					const isExcludedFromWorker = (
-						methodName === 'find' ||
-						methodName === 'insertDocument' ||
-						methodName === 'countWithQuery' ||
-						methodName === 'findOne' ||
-						methodName === 'updateDocumentProps' ||
-						methodName === 'findWithOptions' ||
-						methodName === 'updateDocument' ||
-						methodName === 'insertErrorLog' ||
-						methodName === 'removeDocument' ||
-						methodName === 'supportCreateBillingUser' ||
-						methodName === 'getSignedUrl' ||
-						methodName === 'getSignedUrls' ||
-						methodName === 'getSignedUrlWithId' ||
-						methodName === 'incorrectUser' ||
-						methodName === 'reloadWS' ||
-						methodName === 'reconnectWS' ||
-						methodName === 'disconnectWS'
-					);
-
-					if ((targetWorkerIndex || targetWorkerInstance || forceWorker) && this._isWorkersEnabled && !hasWorkerForMethod && this._methodManager.getEnableDebug()) {
-						console.warn(new Date(), '[WorkerDispatcher] Worker unavailable, running method locally', {
-							method: methodName,
-							targetWorkerIndex: targetWorkerIndex || null,
-							targetWorkerInstance: targetWorkerInstance || null,
-							forceWorker
-						});
-					}
-
-					const shouldDispatchToWorker = (
-						method &&
-						!method.skipWorker &&
-						this._isWorkersEnabled &&
-						this._workerDispatcherManager &&
-						hasWorkerForMethod &&
-						(forceWorker || !isExcludedFromWorker)
-					);
-
-					if (isAiCodex && this._aiWorkerDebug) {
-						const queueSnapshot = this._workerDispatcherManager ? this._workerDispatcherManager.getQueueSnapshot() : null;
-						console.log(new Date(), '[AI Worker Debug] dispatch check', {
-							isWorkersEnabled: this._isWorkersEnabled,
-							isWorkerInstance: this._isWorkerInstance,
-							forceWorker,
-							hasWorkerForMethod,
-							targetWorkerIndex: targetWorkerIndex || null,
-							targetWorkerInstance: targetWorkerInstance || null,
-							shouldDispatchToWorker,
-							queueSnapshot
-						});
-					}
-
-					if (shouldDispatchToWorker) {
-						this._workerDispatcherManager.sendClientTask(msgId, methodName, dataCopy, {
-							id_user: ws['id_user'],
-							user: ws['user'],
-							id_ws: ws['id_socket']
-						});
-					}
-					else {
-						// No worker available: do method locally
-						if (methodName === 'aiCoderTerminalRunCodex' || methodName === 'aiCoderAppRunCodex') {
-							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
-								});
-							}
-							setTimeout(async () => {
-								try {
-									await this.callMethodLocally(ws, msgId, methodName, dataCopy);
-								}
-								catch (error) {
-									console.error(new Date(), 'AI execution run failed:', error);
-								}
-							}, 0);
-						}
-						else {
-							await this.callMethodLocally(ws, msgId, methodName, dataCopy);
-						}
-					}
-				}
-			}
-		}
-		catch (err) {
-			throw err;
-		}
-	}
-
-	/**
-	 * callMethodLocally is your old approach for invoking the method in-process.
-	 */
-	private async callMethodLocally(ws: WebSocket, messageId: number, method: string, params: any[]) {
-		let serverRes: ServerResponseModel = {
-			messageId: messageId,
-			hasError: false,
-			data: null
-		};
-		try {
-			// You can keep your logging code (LogMethodLatencies, Logs.insertOne, etc.)
-			let result = await this._methodManager.callMethod.call(
-				Object.assign({}, this._methodManager, MethodManager.prototype, {
-					id_user: ws['id_user'],
-					user: ws['user'],
-					id_ws: ws['id_socket']
-				}),
-				method,
-				...params
-			);
-
-			serverRes.data = result;
-			if (this._aiWorkerDebug && typeof method === 'string' && method.startsWith('ai')) {
-				let resultBytes: number | null = null;
-				try {
-					resultBytes = Buffer.byteLength(JSON.stringify(result));
-				}
-				catch {
-					resultBytes = null;
-				}
-				console.log(new Date(), '[AI Worker Debug] local method result', {
-					method,
-					messageId,
-					id_socket: ws ? ws['id_socket'] : null,
-					id_user: ws ? ws['id_user'] : null,
-					resultBytes
-				});
-			}
-		}
-		catch (err) {
-			serverRes.hasError = true;
-			serverRes.data = err || 'Unknown error';
-		}
-
-		if (ws && ws.readyState === WebSocket.OPEN) {
-			this._websocketManager.send(ws, serverRes);
-		}
-	}
-
-	
-
-	/**
-	 * Cleanly remove a client from the subscription manager, etc.
-	 */
-	public async unsubscribeWS(ws: WebSocket) {
-		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
-		});
-		await this._subscriptionManager.unsubscribeAll(ws);
-		ws.removeAllListeners();
-		ws = null;
-	}
-
-	public getApp() {
-		return this._app;
-	}
-
-	public getServerConfig() {
-		return ResolveIOServer.getServerConfig();
-	}
-
-	public getWorkerDispatcherManager() {
-		return this._workerDispatcherManager;
-	}
-
-	public getWorkerServerManager() {
-		return this._workerServerManager;
-	}
-}