@resolveio/server-lib 22.3.221 → 22.3.223

package/src/managers/subscription.manager.ts

@@ -1,3128 +0,0 @@
-import { ChangeStream, ChangeStreamDeleteDocument, ChangeStreamInsertDocument, ChangeStreamReplaceDocument, ChangeStreamUpdateDocument, ResumeToken } from 'mongodb';
-import * as NodeCache from 'node-cache';
-import { pack, unpack } from 'msgpackr';
-import * as WebSocket from 'ws';
-import { Flags } from '../collections/flag.collection';
-import { LoggedInUsers } from '../collections/logged-in-users.collection';
-import { LoggedInUserModel } from '../models/logged-in-users.model';
-import { ServerResponseModel } from '../models/server-message.model';
-import { ActiveSubscriptionClientModel, ActiveSubscriptionModel, SubscriptionModel, SubscriptionPubModel } from '../models/subscription.model';
-import { loadAppStatusPublications } from '../publications/app-status';
-import { loadAppSettingsPublications } from '../publications/app-settings';
-import { loadAiTerminalPublications } from '../publications/ai-terminal';
-import { loadCronJobPublications } from '../publications/cron-jobs';
-import { loadCustomerNotificationPublications } from '../publications/customer-notifications';
-import { loadFilePublications } from '../publications/files';
-import { loadFlagsPublications } from '../publications/flags';
-import { loadFlagsUpdatePublications } from '../publications/flags-update';
-import { loadLogPublications } from '../publications/logs';
-import { loadNotificationPublications } from '../publications/notifications';
-import { loadReportBuilderDashboardBuilderPublications } from '../publications/report-builder-dashboard-builders';
-import { loadReportBuilderLibraryPublications } from '../publications/report-builder-libraries';
-import { loadReportBuilderReportPublications } from '../publications/report-builder-reports';
-import { loadSuperAdminPublications } from '../publications/super-admin';
-import { loadUserGroupPublications } from '../publications/user-groups';
-import { loadUserGuidePublications } from '../publications/user-guides';
-import { ResolveIOServer } from '../resolveio-server-app';
-import { deepCopy, objectIdHexString, round } from '../util/common';
-import { ErrorReporter } from '../util/error-reporter';
-import { ensureErrorWithCorrelation } from '../util/error-tracking';
-import { DependencyContextSnapshot, PublicationContext, QueryMeta, deserializeDependencySnapshot, withDependencyTracking } from '../util/subscription-dependency-context';
-import { MonitorManagerFunction } from './monitor.manager';
-import { WebSocketManager } from './websocket.manager';
-const v8 = require('v8');
-const sift = require('sift');
-
-function resolveHeapLimitBytes(): number {
-	const stats = v8.getHeapStatistics();
-	if (stats && typeof stats.heap_size_limit === 'number') {
-		return stats.heap_size_limit;
-	}
-
-	if (stats && typeof stats.total_available_size === 'number') {
-		return stats.total_available_size;
-	}
-
-	return 0;
-}
-
-// Performance Dependencies
-// import * as path from 'path';
-// import { Worker } from 'worker_threads';
-
-interface MongoQueueModel {
-	_id: number,
-	type: string;
-	collection: string;
-	subscription: ActiveSubscriptionModel;
-	running: boolean;
-	run_again: boolean;
-}
-
-interface OplogResumeTokenDocument {
-	_id: string;
-	token?: ResumeToken;
-	updatedAt?: Date;
-}
-
-interface SubscriptionInvalidationEvent {
-	type: string;
-	documentId?: any;
-	document?: any;
-}
-
-interface PublicationExecution {
-	result?: any;
-	packedResult?: Uint8Array | Buffer;
-	snapshot?: DependencyContextSnapshot;
-	encoding?: 'msgpack' | 'json';
-	workerUsed?: boolean;
-}
-
-// interface CurrentPerformanceMonitor {
-// 	_id: number;
-// 	function: string;
-// 	publication: string;
-// 	subscriptionData: any[];
-// 	date_start: Date;
-// 	date_end: Date;
-// 	duration: number;
-// 	result: string;
-// }
-
-export class SubscriptionManager {
-	private _websocketManager: WebSocketManager;
-	private _publications: SubscriptionModel = {};
-	private _subscriptions: ActiveSubscriptionModel[] = [];
-	private _wss: WebSocket.Server;
-	private _loggedInUsers: LoggedInUserModel[] = [];
-	private _lastRouteBySocket = new Map<string, { route: string, dateMs: number }>();
-
-	private _mongoQueue: MongoQueueModel[] = [];
-	private _mongoQueueId = 0;
-	
-	private _oplog$: ChangeStream;
-	private _oplogMode: 'auto' | 'change-stream' | 'local' = 'auto';
-	private _useLocalOplog = false;
-	private _localOplogResyncIntervalMs = 0;
-	private _localOplogResyncTimer: NodeJS.Timeout = null;
-
-	private _nodeCache;
-	private _cacheId = 1;
-
-	private _heapSize = resolveHeapLimitBytes();
-	private _heapLimit: number;
-
-	private serverConfig;
-
-	private _monitorManagerFunction: MonitorManagerFunction;
-
-	private _enableDebug = false;
-	private _enableDependencyDebug = false;
-	private _connectDebug = false;
-	private _debugOplogCollections = [];
-	private _debugOplogHits = 0;
-	private _debugSubCollections = [];
-	private _debugSubHits = 0;
-	private _debugUnSubHits = 0;
-	private _debugUnSubAllHits = 0;
-	private _debugMongoQueueHits = 0;
-	private _debugMongoQueueCollections = [];
-	private _debugSendQueueHits = 0;
-	private _debugRemoveCacheHits = 0;
-	private _subSendDebug = false;
-	private _subSendLogEnabled = false;
-	private _subSendLogThresholdMs = 0;
-	private _subSendLogBytes = 0;
-	private _subSendLogSampleRate = 1;
-	private _aiWorkerDebug = false;
-	private _aiSubscriptionDebug = false;
-	private _aiSubLastAt = new Map<string, number>();
-
-	private _oplogRetryCount = 0;
-	private _lastResumeToken: ResumeToken = null;
-	private _lastResumeTokenSaveMs = 0;
-	private _resumeTokenSavePromise: Promise<void> = null;
-	private _resumeTokenSaveForcePending = false;
-	private _fullResyncPromise: Promise<void> = null;
-	private readonly RESUME_TOKEN_COLLECTION = 'subscription-manager-resume-tokens';
-	private readonly RESUME_TOKEN_SAVE_INTERVAL_MS = 5000;
-	private readonly RESUME_TOKEN_AUTO_HEAL_RETRY_THRESHOLD = 2;
-
-	// Buffer to store throttled latency updates with timestamps
-	private latencyBuffer = new Map<string, { latency: number, lastUpdate: Date }>();
-	private _latencyFlushInProgress = false;
-	private _latencyFlushPending = false;
-
-	// Interval to flush latency updates in MongoDB
-	private readonly LATENCY_UPDATE_INTERVAL = 60000;
-
-	// Minimum time difference between two latency updates for the same user
-	private readonly LATENCY_UPDATE_THRESHOLD_MS = 30000;
-	private readonly LATENCY_DEBUG_THRESHOLD_MS = 1000;
-	private readonly PUBLICATION_DEBUG_THRESHOLD_MS = 300;
-
-	// private currentPerfomanceMonitor: CurrentPerformanceMonitor[] = [];
-	// private idPerformance: number = 0;
-	// private performanceThread;
-
-	private _invalidationDebounceTimers = new Map<string, NodeJS.Timeout>();
-	private _invalidationPendingTimestamps = new Map<string, number>();
-	private _pendingInvalidations = new Map<string, { events: SubscriptionInvalidationEvent[] }>();
-	private readonly DEBOUNCE_DELAY = 100; // 100ms debounce window
-	private readonly MAX_WAIT_TIME = 500;  // 500ms maximum delay
-
-	private _publicationWorkerQueueLimit = 0;
-
-
-	constructor() {}
-
-	static createPublicationRegistry(serverConfig?) {
-		const subscriptionManager = new SubscriptionManager();
-		subscriptionManager.initializePublicationRegistry(serverConfig);
-		return subscriptionManager;
-	}
-
-	static create(wss: WebSocket.Server, serverConfig, monitorManagerFunction: MonitorManagerFunction) {
-		const subscriptionManager = new SubscriptionManager();
-		setImmediate(async () => {
-			await subscriptionManager.initialize(wss, serverConfig, monitorManagerFunction);
-		});
-		return subscriptionManager;
-	}
-	
-	private initializePublicationRegistry(serverConfig) {
-		this.serverConfig = serverConfig || ResolveIOServer.getServerConfig();
-		this.registerCorePublications();
-	}
-
-	private async initialize(wss: WebSocket.Server, serverConfig, monitorManagerFunction: MonitorManagerFunction) {
-		this._websocketManager = ResolveIOServer.getMainServer().getWebSocketManager();
-		this._monitorManagerFunction = monitorManagerFunction;
-
-		this._nodeCache = new NodeCache( { stdTTL: 0, checkperiod: 0 } );
-
-		setInterval(() => this.flushThrottledLatencyUpdates(), this.LATENCY_UPDATE_INTERVAL);
-
-		// setTimeout(() => {
-		// 	console.log('Setting up performance thread');
-
-		// 	this.performanceThread = new Worker(path.join(__dirname, './subscription.performance.js'));
-
-		// 	this.performanceThread.on('exit', code => {
-		// 		console.error(new Date(), 'THREAD EXITED!!!!!!!!!!!!!!!!!!', code);
-		// 	});
-
-		// 	this.performanceThread.on('error', code => {
-		// 		console.error(new Date(), 'THREAD RECV ERROR !!!!!!!!!!!!!!!!!!', code);
-		// 	});
-		// }, 5000);
-
-		// setInterval(() => {
-		// 	console.log('Post thread msg');
-		// 	this.performanceThread.postMessage(this.currentPerfomanceMonitor);
-		// 	this.currentPerfomanceMonitor = [];
-		// }, 10000);
-
-		this.serverConfig = serverConfig;
-		this._wss = wss;
-		this._connectDebug = this.resolveConnectDebug();
-		this._subSendDebug = this.resolveSubSendDebug();
-		this._subSendLogEnabled = this.resolveSubSendLogEnabled();
-		this._subSendLogThresholdMs = this.resolveSubSendLogThresholdMs();
-		this._subSendLogBytes = this.resolveSubSendLogBytes();
-		this._subSendLogSampleRate = this.resolveSubSendLogSampleRate();
-		this._aiWorkerDebug = this.parseDebugFlag(process.env.AI_ASSISTANT_WORKER_DEBUG);
-		this._aiSubscriptionDebug = this.resolveAiSubscriptionDebug();
-
-		this._oplogMode = this.resolveOplogMode();
-		this._localOplogResyncIntervalMs = this.resolveLocalOplogResyncIntervalMs();
-
-		this.registerCorePublications();
-
-		if (this._oplogMode === 'local') {
-			await this.enableLocalOplogFallback('config');
-		}
-		else {
-			const resumeToken = await this.loadResumeToken();
-			await this.tailOpLog(resumeToken || undefined);
-		}
-
-		setInterval(() => {
-			this._oplogRetryCount = 0;
-		}, 15000);
-
-		setInterval(() => {
-			if (this.getEnableDebug()) {
-				console.log(new Date(), 'Sub Manager', 'Subs', this._subscriptions.length);
-				console.log(new Date(), 'Sub Manager', 'Logged In Users', this._loggedInUsers.length);
-				console.log(new Date(), 'Sub Manager', 'Mongo Queue', this._mongoQueue.length);
-				console.log(new Date(), 'Sub Manager', 'Mongo Queue Hits', this._debugMongoQueueHits);
-				console.log(new Date(), 'Sub Manager', 'Mongo Queue Collections', JSON.stringify(this._debugMongoQueueCollections.sort((a, b) => a.collection.localeCompare(b.collection) || a.publication.localeCompare(b.publication)), null, 2));
-				console.log(new Date(), 'Sub Manager', 'Oplog Hits', this._debugOplogHits);
-				console.log(new Date(), 'Sub Manager', 'Oplog Collections', JSON.stringify(this._debugOplogCollections.sort((a, b) => a.collection.localeCompare(b.collection) || a.type.localeCompare(b.type)), null, 2));
-				console.log(new Date(), 'Sub Manager', 'Send Queue Hits', this._debugSendQueueHits);
-				console.log(new Date(), 'Sub Manager', 'Sub Hits', this._debugSubHits);
-				console.log(new Date(), 'Sub Manager', 'Sub Collections', JSON.stringify(this._debugSubCollections.sort((a, b) => a.publication.localeCompare(b.publication)), null, 2));
-				console.log(new Date(), 'Sub Manager', 'Unsub Hits', this._debugUnSubHits);
-				console.log(new Date(), 'Sub Manager', 'Unsub All Hits', this._debugUnSubAllHits);
-				console.log(new Date(), 'Sub Manager', 'Cache Cleanup Hits', this._debugRemoveCacheHits);
-			}
-			
-			this._debugOplogHits = 0;
-			this._debugOplogCollections = [];
-			this._debugSubCollections = [];
-			this._debugMongoQueueHits = 0;
-			this._debugMongoQueueCollections = [];
-			this._debugSendQueueHits = 0;
-			this._debugSubHits = 0;
-			this._debugUnSubHits = 0;
-			this._debugUnSubAllHits = 0;
-			this._debugRemoveCacheHits = 0;
-		}, 60000);
-
-		setInterval(async () => {
-			this._loggedInUsers = await LoggedInUsers.find();
-	
-			let userCopy = deepCopy(this._loggedInUsers);
-			for (let i = this._loggedInUsers.length - 1; i >= 0; i--) {
-				let loggedInUser = userCopy[i];
-
-				if (!loggedInUser.date || Date.now() - loggedInUser.date.getTime() > 120000) {
-					if (this._websocketManager.getWebSocket(loggedInUser.id_ws)) {
-						if (this.getEnableDebug()) {
-							console.log(new Date(), 'Sub Manager', 'Unsub WS', this._websocketManager.getWebSocket(loggedInUser.id_ws)['user'], this._websocketManager.getWebSocket(loggedInUser.id_ws)['id_socket'], 2);
-						}
-						await this.unsubscribeAll(this._websocketManager.getWebSocket(loggedInUser.id_ws));
-					}
-					else {
-						this._subscriptions.forEach(sub => {
-							for (let j = sub.clients.length - 1; j >= 0; j--) {
-								let client = sub.clients[j];
-
-								if (client.id_socket === loggedInUser.id_ws) {
-									sub.clients.splice(j, 1);
-								}
-							}
-						});
-
-						await LoggedInUsers.deleteOne({_id: loggedInUser._id});
-
-						if (this._loggedInUsers.findIndex(a => a._id === loggedInUser._id) >= 0) {
-							this._loggedInUsers.splice(this._loggedInUsers.findIndex(a => a._id === loggedInUser._id), 1);
-						}
-					}
-				}
-			}
-
-			for (let i = 0; i < this._subscriptions.length; i++) {
-				let sub = this._subscriptions[i];
-
-				for (let j = sub.clients.length - 1; j >= 0; j--) {
-					let client = sub.clients[j];
-
-					if (!this._loggedInUsers.some(a => a.id_ws === client.id_socket)) {
-						sub.clients.splice(j, 1);
-					}
-				}
-			}
-		}, 30000);
-
-		let flag = await Flags.findOne({type: 'Enable Debug'});
-		let dependencyFlag = await Flags.findOne({type: 'Enable Dependency Debug'});
-
-		if (flag && flag.value) {
-			this._enableDebug = true;
-		}
-		else {
-			this._enableDebug = false;
-		}
-
-		if (dependencyFlag && dependencyFlag.value) {
-			this._enableDependencyDebug = true;
-		}
-		else {
-			this._enableDependencyDebug = process.env.ENABLE_DEPENDENCY_DEBUG === 'true';
-		}
-
-		this.setCacheLimit();
-		this.configurePublicationWorkers();
-	}
-
-	private registerCorePublications() {
-		loadSuperAdminPublications(this);
-		loadAiTerminalPublications(this);
-		loadAppStatusPublications(this);
-		loadAppSettingsPublications(this);
-		loadLogPublications(this);
-		loadFilePublications(this);
-		loadCronJobPublications(this);
-		loadFlagsUpdatePublications(this);
-		loadFlagsPublications(this);
-		loadNotificationPublications(this);
-		loadCustomerNotificationPublications(this);
-		loadReportBuilderReportPublications(this);
-		loadReportBuilderLibraryPublications(this);
-		loadUserGroupPublications(this);
-		loadUserGuidePublications(this);
-		loadReportBuilderDashboardBuilderPublications(this);
-	}
-
-	private setCacheLimit() {	
-		if (process.env.IS_WORKERS_ENABLED === 'true') {
-			this._heapLimit = this._heapSize * 0.4;
-		}
-		else {
-			this._heapLimit = this._heapSize * 0.3; // Use 50% of total heap size
-		}
-	}
-
-	private configurePublicationWorkers() {
-		const config = this.serverConfig || ResolveIOServer.getServerConfig() || {};
-		this._publicationWorkerQueueLimit = this.parsePositiveNumber(process.env.SUBSCRIPTION_WORKER_QUEUE_MAX ?? config['SUBSCRIPTION_WORKER_QUEUE_MAX']);
-	}
-
-	private parseBoolean(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 clampNumber(value: number, min: number, max: number): number {
-		if (value < min) {
-			return min;
-		}
-
-		if (value > max) {
-			return max;
-		}
-
-		return value;
-	}
-
-	public async invalidatePubsCache(collection: string, type: string, documentId?: any, document?: any) {
-		let queue = this._pendingInvalidations.get(collection);
-		if (!queue) {
-			queue = { events: [] };
-			this._pendingInvalidations.set(collection, queue);
-		}
-		queue.events.push({ type, documentId, document });
-
-		const debounceKey = collection;
-		const now = Date.now();
-	
-		// Initialize or get existing timestamp
-		const firstInvalidationTime = this._invalidationPendingTimestamps.get(debounceKey) || now;
-		this._invalidationPendingTimestamps.set(debounceKey, firstInvalidationTime);
-	
-		// Clear any existing timer
-		if (this._invalidationDebounceTimers.has(debounceKey)) {
-			clearTimeout(this._invalidationDebounceTimers.get(debounceKey));
-		}
-	
-		// Check if we've waited too long
-		const waitedTooLong = (now - firstInvalidationTime) >= this.MAX_WAIT_TIME;
-		
-		if (waitedTooLong) {
-			// Immediate execution path
-			this._invalidationPendingTimestamps.delete(debounceKey);
-			await this._executeInvalidation(collection);
-		} else {
-			// Normal debounce path
-			this._invalidationDebounceTimers.set(
-				debounceKey,
-				setTimeout(async () => {
-					this._invalidationPendingTimestamps.delete(debounceKey);
-					await this._executeInvalidation(collection);
-				}, this.DEBOUNCE_DELAY)
-			);
-		}
-	}
-	
-	private async _executeInvalidation(collection: string) {
-		// Clean up any existing timer (defensive)
-		if (this._invalidationDebounceTimers.has(collection)) {
-			clearTimeout(this._invalidationDebounceTimers.get(collection));
-			this._invalidationDebounceTimers.delete(collection);
-		}
-
-		const queued = this._pendingInvalidations.get(collection);
-		this._pendingInvalidations.delete(collection);
-
-		if (!queued || !queued.events.length) {
-			return;
-		}
-
-		const events = queued.events;
-	
-		// Original invalidation logic
-		ResolveIOServer.getMongoManager().invalidateQueryCache(collection, true);
-	
-		const collSubs = this._subscriptions.filter(sub => this.subscriptionReferencesCollection(sub, collection));
-	
-		for (const sub of collSubs) {
-			if (this._enableDebug) {
-				console.log(new Date(), 'Invalidate Sub', sub.publication, sub.running, sub.runAgain);
-			}
-
-			if (!(await this.shouldInvalidateSubscriptionForEvents(sub, collection, events))) {
-				continue;
-			}
-	
-			if (sub.running) {
-				sub.runAgain = true;
-				this.dependencyDebug('Subscription busy, scheduling rerun', { publication: sub.publication, collection, events: this.summarizeEvents(events) });
-				continue;
-			}
-	
-			const batchType = events.length === 1 ? events[0].type : events.map(event => event.type).join(',');
-
-			if (this._publications[sub.publication].user_specific) {
-				this.dependencyDebug('Triggering user-specific invalidation', { publication: sub.publication, collection, events: this.summarizeEvents(events), clientCount: sub.clients.length });
-				for (let client of sub.clients) {
-					const ws = this._websocketManager.getWebSocket(client.id_socket);
-					if (ws?.readyState === WebSocket.OPEN) {
-						try {
-							await this.sendDataToOneWithRetry(ws, client.messageId, sub, collection, batchType);
-						}
-						catch {
-							// Error handling
-						}
-					}
-				}
-			}
-			else {
-				this.dependencyDebug('Triggering broadcast invalidation', { publication: sub.publication, collection, events: this.summarizeEvents(events), clientCount: sub.clients.length });
-				await this.sendDataToAllWithRetry(sub, collection, batchType);
-			}
-		}
-	}
-
-	private subscriptionReferencesCollection(sub: ActiveSubscriptionModel, collection: string): boolean {
-		if (sub.collections?.includes(collection)) {
-			return true;
-		}
-
-		this.ensureDependencyContainers(sub);
-
-		const dependencyIds = sub.collectionDependencies?.get(collection);
-		if (dependencyIds && dependencyIds.size > 0) {
-			return true;
-		}
-
-		const filters = sub.collectionFilters?.get(collection);
-		if (filters && filters.length > 0) {
-			return true;
-		}
-
-		if (sub.watchAllCollections?.has(collection)) {
-			return true;
-		}
-
-		return false;
-	}
-
-	private async delay(ms: number) {
-		// eslint-disable-next-line no-restricted-syntax
-		return new Promise(resolve => setTimeout(resolve, ms));
-	}
-
-	private getMessageDateMs(messageDate: any): number {
-		if (messageDate instanceof Date && !isNaN(messageDate.getTime())) {
-			return messageDate.getTime();
-		}
-
-		if (typeof messageDate === 'string' || typeof messageDate === 'number') {
-			const parsed = new Date(messageDate);
-			if (!isNaN(parsed.getTime())) {
-				return parsed.getTime();
-			}
-		}
-
-		return Date.now();
-	}
-
-	private isStaleRouteMessage(ws: WebSocket, messageRoute: string, messageDate: any): boolean {
-		const socketId = ws ? ws['id_socket'] : '';
-		if (!socketId) {
-			return false;
-		}
-
-		if (!messageRoute || messageRoute === 'Bypass') {
-			return false;
-		}
-
-		const messageDateMs = this.getMessageDateMs(messageDate);
-		const lastRoute = this._lastRouteBySocket.get(socketId);
-
-		if (lastRoute && messageDateMs < lastRoute.dateMs) {
-			this.dependencyDebug('Skip route cleanup due to stale route message', {
-				socketId,
-				messageRoute,
-				messageDateMs,
-				lastRoute: lastRoute.route,
-				lastRouteDateMs: lastRoute.dateMs
-			});
-			return true;
-		}
-
-		this._lastRouteBySocket.set(socketId, { route: messageRoute, dateMs: messageDateMs });
-		return false;
-	}
-
-	private getPublicationWorkerDispatcher() {
-		const mainServer = ResolveIOServer.getMainServer();
-		return mainServer && typeof mainServer.getWorkerDispatcherManager === 'function'
-			? mainServer.getWorkerDispatcherManager()
-			: null;
-	}
-
-	private shouldUsePublicationWorkers(): boolean {
-		const dispatcher = this.getPublicationWorkerDispatcher();
-		if (!dispatcher || !dispatcher.hasWorkers()) {
-			return false;
-		}
-		if (typeof dispatcher.hasWorkersForMethod === 'function' && !dispatcher.hasWorkersForMethod('runPublication')) {
-			return false;
-		}
-
-		if (this._publicationWorkerQueueLimit > 0) {
-			const snapshot = dispatcher.getQueueSnapshot();
-			if (snapshot.queueDepth >= this._publicationWorkerQueueLimit) {
-				return false;
-			}
-		}
-
-		return true;
-	}
-
-	private async runPublicationViaWorker(sub: ActiveSubscriptionModel, userId?: string): Promise<PublicationExecution | null> {
-		if (!this.shouldUsePublicationWorkers()) {
-			return null;
-		}
-
-		const dispatcher = this.getPublicationWorkerDispatcher();
-		if (!dispatcher) {
-			return null;
-		}
-
-		try {
-			const response = await dispatcher.sendInternalPromiseRaw('runPublication', [
-				sub.publication,
-				sub.subscriptionData,
-				userId
-			]);
-
-			if (!response || response.error) {
-				throw response?.result || new Error('Publication worker error');
-			}
-
-			if (!response.packedResult) {
-				throw new Error('Publication worker missing packedResult');
-			}
-
-			const meta = response.meta || {};
-			const snapshot = meta.snapshot ? deserializeDependencySnapshot(meta.snapshot) : undefined;
-
-			return {
-				packedResult: response.packedResult,
-				snapshot,
-				encoding: response.encoding || meta.encoding || 'msgpack',
-				workerUsed: true
-			};
-		}
-		catch (error) {
-			if (this._enableDebug) {
-				console.log(new Date(), 'Sub Manager', 'Worker publication failed, falling back', sub.publication, error?.message || error);
-			}
-			return null;
-		}
-	}
-
-	private async runPublicationLocally(sub: ActiveSubscriptionModel, userId?: string): Promise<PublicationExecution> {
-		const pub = this._publications[sub.publication];
-		if (!pub) {
-			throw new Error(`Publication not found: ${sub.publication}`);
-		}
-
-		const context = Object.assign({}, this, SubscriptionManager.prototype);
-		const metadata: PublicationContext = {
-			publication: sub.publication,
-			subscriptionData: sub.subscriptionData
-		};
-
-		const execution = pub.user_specific
-			? await withDependencyTracking(() => pub.function.call(context, userId || '', ...sub.subscriptionData), Object.assign({}, metadata, { userId }))
-			: await withDependencyTracking(() => pub.function.call(context, ...sub.subscriptionData), metadata);
-
-		return {
-			result: execution.result,
-			packedResult: this.packCachePayload(execution.result),
-			snapshot: execution.snapshot,
-			encoding: 'msgpack',
-			workerUsed: false
-		};
-	}
-
-	private async runPublicationExecution(sub: ActiveSubscriptionModel, userId?: string): Promise<PublicationExecution> {
-		const pub = this._publications[sub.publication];
-		if (!pub) {
-			throw new Error(`Publication not found: ${sub.publication}`);
-		}
-
-		const effectiveUserId = pub.user_specific ? userId : undefined;
-		const workerExecution = await this.runPublicationViaWorker(sub, effectiveUserId);
-		if (workerExecution) {
-			return workerExecution;
-		}
-
-		return this.runPublicationLocally(sub, effectiveUserId);
-	}
-
-	private async sendDataToAllWithRetry(sub: ActiveSubscriptionModel, collection: string, type: string) {
-		sub.running = true;
-
-		do {
-			if (this._enableDebug) {
-				console.log(new Date(), 'Running sendDataToAll Sub', sub.publication);
-			}
-
-			sub.runAgain = false;
-			await this.sendDataToAll(sub, collection, type);
-
-			if (this._enableDebug) {
-				console.log(new Date(), 'Done sendDataToAll Sub', sub.publication, sub.runAgain);
-			}
-
-			if (sub.runAgain) {
-				await this.delay(500); // delay, adjust as needed
-			}
-		} while (sub.runAgain);
-
-		sub.running = false;
-	}
-
-	private async sendDataToOneWithRetry(ws: WebSocket, messageId: number, sub: ActiveSubscriptionModel, collection: string, type: string) {
-		sub.running = true;
-
-		do {
-			if (this._enableDebug) {
-				console.log(new Date(), 'Running sendDataToOne Sub', sub.publication);
-			}
-
-			sub.runAgain = false;
-			await this.sendDataToOne(ws, messageId, sub, collection, type);
-
-			if (this._enableDebug) {
-				console.log(new Date(), 'Done sendDataToOne Sub', sub.publication, sub.runAgain);
-			}
-
-			if (sub.runAgain) {
-				await this.delay(500); // delay, adjust as needed
-			}
-		} while (sub.runAgain);
-		sub.running = false;
-	}
-
-	// Add all files to publications private object
-	public publications(method: SubscriptionModel) {
-		this._publications = Object.assign(this._publications, method);
-	}
-
-	public getPublication(publication: string): SubscriptionPubModel | undefined {
-		return this._publications[publication];
-	}
-
-	public getPublications(): SubscriptionModel {
-		return this._publications;
-	}
-
-	// Throttled `loggedInLatency` method
-	public loggedInLatency(ws: WebSocket) {
-		const now = new Date();
-		const newLatency = ws['latency'];
-		const socketId = ws['id_socket'];
-		let loggedInUser = this._loggedInUsers.find(a => a.id_ws === socketId);
-
-		if (!loggedInUser) {
-			return;
-		}
-
-		const existingEntry = this.latencyBuffer.get(socketId);
-
-		// Throttle updates: only update if time threshold has passed or latency has significantly changed
-		if (
-			!existingEntry || 
-			(now.getTime() - existingEntry.lastUpdate.getTime() >= this.LATENCY_UPDATE_THRESHOLD_MS) || 
-			(Math.abs(newLatency - existingEntry.latency) > 100)  // Optional: log only significant changes
-		) {
-			// Update in-memory and buffer
-			loggedInUser.date = now;
-			this.latencyBuffer.set(socketId, { latency: newLatency, lastUpdate: now });
-		}
-	}
-
-	// Method to flush buffered latency updates in bulk
-	private async flushThrottledLatencyUpdates() {
-		if (this.latencyBuffer.size === 0) return; // No updates to flush
-		if (this._latencyFlushInProgress) {
-			this._latencyFlushPending = true;
-			return;
-		}
-
-		this._latencyFlushInProgress = true;
-
-		const pendingEntries = Array.from(this.latencyBuffer.entries());
-		this.latencyBuffer.clear();
-		const updates = pendingEntries.map(([id_ws, { latency, lastUpdate }]) => ({
-			updateOne: {
-				filter: { id_ws },
-				update: { $set: { latency, date: lastUpdate } }
-			}
-		}));
-
-		try {
-			await LoggedInUsers.bulkWrite(updates, { ordered: false });
-
-			if (this.getEnableDebug()) {
-				console.log(new Date(), 'Sub Manager', 'Throttled latency batch update successful', updates.length);
-			}
-		}
-		catch (error) {
-			for (const [id_ws, payload] of pendingEntries) {
-				const current = this.latencyBuffer.get(id_ws);
-				if (!current || current.lastUpdate < payload.lastUpdate) {
-					this.latencyBuffer.set(id_ws, payload);
-				}
-			}
-			console.error(new Date(), 'Sub Manager', 'Throttled latency batch update failed', error);
-			// Optional: implement retry logic or logging for failed updates
-		}
-		finally {
-			this._latencyFlushInProgress = false;
-			if (this._latencyFlushPending) {
-				this._latencyFlushPending = false;
-				setImmediate(() => this.flushThrottledLatencyUpdates());
-			}
-		}
-	}
-
-	// Subscribe to publication
-	public async subscribe(messageRoute: string, messageDate: Date, ws: WebSocket, messageId: number, publication: string, subscriptionData: any[]) {
-		this._debugSubHits += 1;
-		this.connectDebug('Subscribe request', {
-			publication,
-			messageRoute,
-			messageId,
-			id_socket: ws ? ws['id_socket'] : null,
-			user: ws ? ws['user'] : null,
-			args: Array.isArray(subscriptionData) ? subscriptionData.length : 0
-		});
-
-		if (!this._debugSubCollections.some(a => a.publication === publication)) {
-			this._debugSubCollections.push({
-				publication: publication,
-				hits: 1
-			});
-		}
-		else {
-			this._debugSubCollections.find(a => a.publication === publication).hits += 1;
-		}
-
-		let pub = this._publications[publication];
-
-		if (!pub) {
-			console.error(new Date(), 'No Publication: ' + publication);
-			this.connectDebug('Missing publication', { publication, messageRoute, messageId });
-			return;
-		}
-		else {
-			if (subscriptionData.length > 1 || subscriptionData[0]) {
-				if (!pub.check) {
-					console.error(new Date(), 'No Check Function For Pub ' + publication);
-					this.connectDebug('Missing check for publication', { publication, messageRoute, messageId });
-					return;
-				}
-				else if (!pub.check._schema) {
-					console.error(new Date(), 'No Check Schema For Pub ' + publication);
-					this.connectDebug('Missing check schema for publication', { publication, messageRoute, messageId });
-					return;
-				}
-				else {
-					let valObj = {};
-					let valKeys = Object.keys(pub.check._schema);
-
-					let rootKeys = valKeys.filter(a => !a.includes('.'));
-
-					for (let i = 0; i < subscriptionData.length; i++) {
-						valObj[rootKeys[i]] = subscriptionData[i];
-					}
-
-					try {
-						pub.check.validate(valObj);
-					}
-					catch (errors) {
-						if (errors) {
-							console.error(new Date(), 'Error in Pub Check (' + publication + ')', errors);
-							this.connectDebug('Publication check failed', {
-								publication,
-								messageRoute,
-								messageId,
-								args: subscriptionData.length,
-								valObj,
-								error: errors?.message || errors
-							});
-							return;
-						}
-					}
-				}
-			}
-
-			const staleRouteMessage = this.isStaleRouteMessage(ws, messageRoute, messageDate);
-			if (messageRoute !== 'Bypass' && messageRoute !== '/' && !staleRouteMessage) {
-				let urlData = messageRoute.split('/');
-				let urlModule = '';
-				let urlNext = urlData[0];
-
-				if (urlData[0] === '') {
-					urlModule = '/';
-					urlNext = urlData[1];
-				}
-
-				urlModule += urlNext;
-
-				if (urlData.length > 1) {
-					urlModule += '/';
-				}
-
-				let otherRouteSubs = this._subscriptions.filter(a => a.clients.some(b => b.id_socket === ws['id_socket'] && b.messageRoute !== 'Bypass' && b.messageRoute !== '/' && b.messageRoute !== messageRoute && !b.messageRoute.startsWith(urlModule)));
-
-				if (otherRouteSubs.length) {
-					// ResolveIOServer.getMainServer().getMethodManager().sendEmail('dev@resolveio.com', 'SERVER - Detected Undestroyed Subscription - ' + this.serverConfig['CLIENT_NAME'], 'USER: ' + ws['user'] + ' (Socket: ' + ws['id_socket'] + ') ' + ' is on route: ' + messageRoute + ' but has the following subscriptions on other routes:' + JSON.stringify(otherRouteSubs, null, 2));
-
-					otherRouteSubs.forEach(otherSub => {
-						otherSub.clients.filter(a => a.id_socket === ws['id_socket']).forEach(client => {
-							this.unsubscribe(client.messageRoute, new Date(), ws, client.messageId, otherSub.publication, otherSub.subscriptionData);
-						});
-					});
-				}
-			}
-
-			const normalizedSubscriptionData = Array.isArray(subscriptionData) ? subscriptionData : [];
-			const subscriptionKey = JSON.stringify(normalizedSubscriptionData);
-			let sub = this._subscriptions.find(a => a.publication === publication && a.subscriptionKey === subscriptionKey);
-			const isAiPublication = this.isAiPublication(publication);
-			const wsId = ws ? ws['id_socket'] : null;
-			const wsUserId = ws ? ws['id_user'] : null;
-
-			// If sub found (another user watching same data), add client to same sub
-			if (sub) {
-				if (isAiPublication && wsId) {
-					const existingIndex = sub.clients.findIndex(a => a.id_socket === wsId);
-					if (existingIndex >= 0) {
-						const existingClient = sub.clients[existingIndex];
-						for (let i = sub.clients.length - 1; i >= 0; i--) {
-							if (i !== existingIndex && sub.clients[i].id_socket === wsId) {
-								sub.clients.splice(i, 1);
-							}
-						}
-						existingClient.id_user = wsUserId;
-						existingClient.messageId = messageId;
-						existingClient.messageRoute = messageRoute;
-					}
-					else {
-						sub.clients.push({
-							id_user: wsUserId,
-							messageId: messageId,
-							id_socket: wsId,
-							messageRoute: messageRoute
-						});
-					}
-				}
-				else if (!sub.clients.some(a => a.id_socket === ws['id_socket'] && a.messageId === messageId)) {
-					sub.clients.push({
-						id_user: ws['id_user'],
-						messageId: messageId,
-						id_socket: ws['id_socket'],
-						messageRoute: messageRoute
-					});
-				}
-			}
-			// If sub not found, create new sub
-			else {
-				this._subscriptions.push({
-					publication: publication,
-					subscriptionKey: subscriptionKey,
-					subscriptionData: normalizedSubscriptionData,
-					collections: this.getPublicationCollections(publication),
-					clients: [{
-						id_user: ws['id_user'],
-						messageId: messageId,
-						id_socket: ws['id_socket'],
-						messageRoute: messageRoute,
-					}],
-				cacheId: 0,
-				running: false,
-				runAgain: false,
-				collectionDependencies: new Map(),
-				collectionFilters: new Map(),
-				watchAllCollections: new Set(),
-				collectionQueryMeta: new Map()
-			});
-		}
-
-			if (!sub) {
-				sub = this._subscriptions.find(a => a.publication === publication && a.subscriptionKey === subscriptionKey);
-			}
-			this.ensureDependencyContainers(sub);
-			this.logAiSubscriptionEvent('sub', {
-				publication,
-				subscriptionKey,
-				messageId,
-				id_socket: ws ? ws['id_socket'] : null,
-				messageRoute,
-				clients: sub?.clients?.length || 0,
-				subscriptionData: normalizedSubscriptionData
-			});
-
-			if (this._enableDebug) {
-				console.log(new Date(), 'New Sub', sub.publication, sub.running, sub.runAgain, sub.clients.length);
-			}
-
-			// Immediately send data to the new client
-			await this.processSubscription(sub, ws, messageId);
-		}
-	}
-
-	public async createLoggedInUser(id_ws: string): Promise<LoggedInUserModel> {
-		let ws = this._websocketManager.getWebSocket(id_ws);
-
-		if (ws) {
-			let user = {
-				_id: objectIdHexString(),
-				__v: 0,
-				date: new Date(),
-				id_user: ws['id_user'],
-				user: ws['user'],
-				id_ws: ws['id_socket']
-			};
-			
-			this._loggedInUsers.push(user);
-			await LoggedInUsers.insertOne(user);
-			
-			return user;
-		}
-		else {
-			throw new Error('Error in Create Logged In User: No WS');
-		}
-	}
-
-	// Unsubscribe from publication 
-	public unsubscribe(messageRoute: string, messageDate: Date, ws: WebSocket, messageId: number, publication: string, subscriptionData: any[]) {		
-		this._debugUnSubHits += 1;
-
-		if (!this._publications[publication]) {
-			console.log('No Publication: ' + publication);
-			return;
-		}
-		else {
-			const normalizedSubscriptionData = Array.isArray(subscriptionData) ? subscriptionData : [];
-			const subscriptionKey = JSON.stringify(normalizedSubscriptionData);
-			let sub = this._subscriptions.find(a => a.publication === publication && a.subscriptionKey === subscriptionKey);
-
-			if (sub) {
-				const isAiPublication = this.isAiPublication(publication);
-				for (let i = sub.clients.length - 1; i >= 0; i--) {
-					if (isAiPublication && sub.clients[i].id_socket === ws['id_socket']) {
-						sub.clients.splice(i, 1);
-					}
-					else if (sub.clients[i].id_user === ws['id_user'] && sub.clients[i].messageId === messageId && sub.clients[i].id_socket === ws['id_socket']) {
-						sub.clients.splice(i, 1);
-					}
-				}
-
-				this.logAiSubscriptionEvent('unsub', {
-					publication,
-					subscriptionKey,
-					messageId,
-					id_socket: ws ? ws['id_socket'] : null,
-					messageRoute,
-					clients: sub.clients.length,
-					subscriptionData: normalizedSubscriptionData
-				});
-
-				if (this._enableDebug) {
-					console.log(new Date(), 'Unsub', sub.publication, sub.running, sub.runAgain, sub.clients.length);
-				}
-			}
-		}
-	}
-
-
-	// Unsubscribe from publication
-	public async unsubscribeAll(ws: WebSocket) {
-		this._debugUnSubAllHits += 1;
-
-		if (ws) {
-			if (ws['id_socket']) {
-				this._lastRouteBySocket.delete(ws['id_socket']);
-			}
-
-			// Check if WebSocket has already been unsubscribed
-			if (ws['isUnsubscribed']) {
-				return; // Skip if already unsubscribed
-			}
-			
-			// Mark the WebSocket as unsubscribed to prevent further calls
-			ws['isUnsubscribed'] = true;
-			
-			if (this._loggedInUsers.map(a => a.id_ws).indexOf(ws['id_socket']) >= 0) {
-				this._loggedInUsers.splice(this._loggedInUsers.map(a => a.id_ws).indexOf(ws['id_socket']), 1);
-			}
-			
-			await LoggedInUsers.deleteOne({ id_ws: ws['id_socket'] });
-
-			let userSubs = this._subscriptions.filter(a => a.clients.some(b => b.id_user === ws['id_user'] && b.id_socket === ws['id_socket']));
-
-			for (let i = userSubs.length - 1; i >= 0; i--) {
-				let sub = userSubs[i];
-
-				for (let j = sub.clients.length - 1; j >= 0; j--) {
-					if (sub.clients[j].id_socket === ws['id_socket']) {
-						sub.clients.splice(j, 1);
-					}
-				}
-			}
-
-			this._websocketManager.removeWebSocket(ws);
-		}
-	}
-
-	public getActiveSubscriptions() {
-		return this._subscriptions;
-	}
-
-	// Get publication collection
-	private getPublicationCollections(publication: string) {
-		return this._publications[publication].collections;
-	}
-
-	private getWatchedDatabases(): string[] {
-		const mongoManager = ResolveIOServer.getMongoManager();
-		const managerDatabases = mongoManager?.getWatchedDatabases() || [];
-
-		if (managerDatabases.length) {
-			return managerDatabases;
-		}
-
-		const config = this.serverConfig || ResolveIOServer.getServerConfig();
-		const mainDb = config && typeof config['DATABASE'] === 'string' ? config['DATABASE'] : '';
-
-		return mainDb ? [mainDb] : [];
-	}
-
-	private resolveOplogMode(): 'auto' | 'change-stream' | 'local' {
-		const config = this.serverConfig || ResolveIOServer.getServerConfig() || {};
-		const raw = process.env.SUBSCRIPTION_OPLOG_MODE || process.env.OPLOG_MODE || config['SUBSCRIPTION_OPLOG_MODE'] || config['OPLOG_MODE'];
-
-		if (typeof raw !== 'string' || !raw.trim()) {
-			return 'auto';
-		}
-
-		const normalized = raw.trim().toLowerCase();
-
-		if (['local', 'single', 'standalone', 'fallback', 'poll'].includes(normalized)) {
-			return 'local';
-		}
-
-		if (['change-stream', 'changestream', 'oplog', 'replica', 'replicaset', 'rs'].includes(normalized)) {
-			return 'change-stream';
-		}
-
-		return 'auto';
-	}
-
-	private resolveLocalOplogResyncIntervalMs(): number {
-		const config = this.serverConfig || ResolveIOServer.getServerConfig() || {};
-		const raw = process.env.OPLOG_FALLBACK_RESYNC_MS
-			|| process.env.SUBSCRIPTION_OPLOG_RESYNC_MS
-			|| config['OPLOG_FALLBACK_RESYNC_MS']
-			|| config['SUBSCRIPTION_OPLOG_RESYNC_MS'];
-
-		return this.parsePositiveNumber(raw);
-	}
-
-	private resolveResumeTokenMaxAgeMs(): number {
-		const config = this.serverConfig || ResolveIOServer.getServerConfig() || {};
-		const raw = process.env.OPLOG_RESUME_TOKEN_MAX_AGE_MS
-			|| process.env.SUBSCRIPTION_OPLOG_RESUME_TOKEN_MAX_AGE_MS
-			|| config['OPLOG_RESUME_TOKEN_MAX_AGE_MS']
-			|| config['SUBSCRIPTION_OPLOG_RESUME_TOKEN_MAX_AGE_MS'];
-
-		return this.parsePositiveNumber(raw);
-	}
-
-	private resolveConnectDebug(): boolean {
-		const config = this.serverConfig || ResolveIOServer.getServerConfig() || {};
-		const raw = process.env.WS_CONNECT_DEBUG
-			|| process.env.CONNECT_DEBUG
-			|| config['WS_CONNECT_DEBUG']
-			|| config['CONNECT_DEBUG'];
-
-		return this.parseDebugFlag(raw);
-	}
-
-	private resolveSubSendDebug(): boolean {
-		const config = this.serverConfig || ResolveIOServer.getServerConfig() || {};
-		const raw = process.env.SUB_SEND_DEBUG
-			|| process.env.SUBSCRIPTION_SEND_DEBUG
-			|| config['SUB_SEND_DEBUG']
-			|| config['SUBSCRIPTION_SEND_DEBUG'];
-
-		return this.parseDebugFlag(raw);
-	}
-
-	private resolveSubSendLogEnabled(): boolean {
-		const config = this.serverConfig || ResolveIOServer.getServerConfig() || {};
-		const raw = process.env.SUB_SEND_LOG_ENABLED
-			|| process.env.SUBSCRIPTION_SEND_LOG_ENABLED
-			|| config['SUB_SEND_LOG_ENABLED']
-			|| config['SUBSCRIPTION_SEND_LOG_ENABLED'];
-
-		if (raw === undefined || raw === null || raw === '') {
-			return this._subSendDebug;
-		}
-
-		return this.parseDebugFlag(raw);
-	}
-
-	private resolveSubSendLogThresholdMs(): number {
-		const config = this.serverConfig || ResolveIOServer.getServerConfig() || {};
-		const raw = process.env.SUB_SEND_LOG_THRESHOLD_MS
-			|| process.env.SUBSCRIPTION_SEND_LOG_THRESHOLD_MS
-			|| config['SUB_SEND_LOG_THRESHOLD_MS']
-			|| config['SUBSCRIPTION_SEND_LOG_THRESHOLD_MS'];
-
-		return this.parsePositiveNumber(raw);
-	}
-
-	private resolveSubSendLogBytes(): number {
-		const config = this.serverConfig || ResolveIOServer.getServerConfig() || {};
-		const raw = process.env.SUB_SEND_LOG_BYTES
-			|| process.env.SUBSCRIPTION_SEND_LOG_BYTES
-			|| config['SUB_SEND_LOG_BYTES']
-			|| config['SUBSCRIPTION_SEND_LOG_BYTES'];
-
-		return this.parsePositiveNumber(raw);
-	}
-
-	private resolveSubSendLogSampleRate(): number {
-		const config = this.serverConfig || ResolveIOServer.getServerConfig() || {};
-		const raw = process.env.SUB_SEND_LOG_SAMPLE_RATE
-			|| process.env.SUBSCRIPTION_SEND_LOG_SAMPLE_RATE
-			|| config['SUB_SEND_LOG_SAMPLE_RATE']
-			|| config['SUBSCRIPTION_SEND_LOG_SAMPLE_RATE'];
-
-		return this.parseSampleRate(raw, this._subSendLogSampleRate);
-	}
-
-	private resolveAiSubscriptionDebug(): boolean {
-		const config = this.serverConfig || ResolveIOServer.getServerConfig() || {};
-		const raw = process.env.AI_ASSISTANT_SUB_DEBUG
-			|| process.env.AI_TERMINAL_SUB_DEBUG
-			|| config['AI_ASSISTANT_SUB_DEBUG']
-			|| config['AI_TERMINAL_SUB_DEBUG'];
-
-		return this.parseDebugFlag(raw);
-	}
-
-
-	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 parsePositiveNumber(value: any): number {
-		if (typeof value === 'number' && Number.isFinite(value) && value > 0) {
-			return value;
-		}
-
-		if (typeof value === 'string' && value.trim().length) {
-			const parsed = parseInt(value, 10);
-			if (Number.isFinite(parsed) && parsed > 0) {
-				return parsed;
-			}
-		}
-
-		return 0;
-	}
-
-	private parseSampleRate(value: any, fallback: number): number {
-		const parsed = parseFloat(value ?? '');
-		if (Number.isFinite(parsed) && parsed > 0 && parsed <= 1) {
-			return parsed;
-		}
-		return fallback;
-	}
-
-	private shouldLogSubSend(durationMs: number, payloadBytes: number | null): boolean {
-		if (!this._subSendLogEnabled) {
-			return false;
-		}
-
-		if (this._subSendLogSampleRate < 1 && Math.random() > this._subSendLogSampleRate) {
-			return false;
-		}
-
-		if (this._subSendDebug) {
-			return true;
-		}
-
-		if (this._subSendLogThresholdMs > 0 && durationMs >= this._subSendLogThresholdMs) {
-			return true;
-		}
-
-		if (payloadBytes !== null && this._subSendLogBytes > 0 && payloadBytes >= this._subSendLogBytes) {
-			return true;
-		}
-
-		return false;
-	}
-
-	private logSubSend(sub: ActiveSubscriptionModel, details: { collection: string; type: string; clients: number; durationMs: number; payloadBytes: number | null }) {
-		if (!details.clients) {
-			return;
-		}
-
-		if (!this.shouldLogSubSend(details.durationMs, details.payloadBytes)) {
-			return;
-		}
-
-		console.log(new Date(), '[Sub Send]', JSON.stringify({
-			publication: sub.publication,
-			subscriptionKey: sub.subscriptionKey,
-			clients: details.clients,
-			durationMs: details.durationMs,
-			payloadBytes: details.payloadBytes,
-			collection: details.collection,
-			type: details.type
-		}));
-	}
-
-	private isAiPublication(publication: string): boolean {
-		return publication === 'aiTerminalMessages' || publication === 'aiTerminalConversations';
-	}
-
-	private logAiSubSend(details: {
-		publication: string;
-		subscriptionKey: string;
-		messageId: number;
-		id_socket: string;
-		clients: number;
-		payloadBytes: number | null;
-		packed: boolean;
-		cacheHit?: boolean;
-		collection: string;
-		type: string;
-		subscriptionData?: any[];
-	}): void {
-		if (!this._aiWorkerDebug) {
-			return;
-		}
-		if (!this.isAiPublication(details.publication)) {
-			return;
-		}
-		console.log(new Date(), '[AI Worker Debug] subSend', JSON.stringify({
-			publication: details.publication,
-			subscriptionKey: details.subscriptionKey,
-			messageId: details.messageId,
-			id_socket: details.id_socket,
-			clients: details.clients,
-			payloadBytes: details.payloadBytes,
-			packed: details.packed,
-			cacheHit: details.cacheHit ?? false,
-			collection: details.collection,
-			type: details.type,
-			subscriptionData: details.subscriptionData
-		}));
-	}
-
-	private logAiSubscriptionEvent(event: 'sub' | 'unsub', details: {
-		publication: string;
-		subscriptionKey: string;
-		messageId: number;
-		id_socket: string;
-		messageRoute: string;
-		clients: number;
-		subscriptionData?: any[];
-	}): void {
-		if (!this._aiSubscriptionDebug) {
-			return;
-		}
-		if (!this.isAiPublication(details.publication)) {
-			return;
-		}
-		const wsId = details.id_socket || 'unknown';
-		const key = `${event}:${wsId}:${details.publication}:${details.subscriptionKey}`;
-		const now = Date.now();
-		const lastAt = this._aiSubLastAt.get(key);
-		const deltaMs = lastAt ? now - lastAt : null;
-		this._aiSubLastAt.set(key, now);
-		console.log(new Date(), `[AI Sub Debug] ${event}`, JSON.stringify({
-			publication: details.publication,
-			subscriptionKey: details.subscriptionKey,
-			messageId: details.messageId,
-			messageRoute: details.messageRoute,
-			id_socket: wsId,
-			clients: details.clients,
-			deltaMs,
-			subscriptionData: details.subscriptionData
-		}));
-	}
-
-	private connectDebug(message: string, details?: Record<string, unknown>) {
-		if (!this._connectDebug) {
-			return;
-		}
-
-		if (details) {
-			console.log(new Date(), '[Connect Debug]', message, JSON.stringify(details));
-		}
-		else {
-			console.log(new Date(), '[Connect Debug]', message);
-		}
-	}
-
-	private parsePositiveFloat(value: any): number {
-		if (typeof value === 'number' && Number.isFinite(value) && value > 0) {
-			return value;
-		}
-
-		if (typeof value === 'string' && value.trim().length) {
-			const parsed = parseFloat(value);
-			if (Number.isFinite(parsed) && parsed > 0) {
-				return parsed;
-			}
-		}
-
-		return 0;
-	}
-
-	private isChangeStreamUnsupported(error: any): boolean {
-		const code = typeof error?.code === 'number' ? error.code : null;
-		const codeName = typeof error?.codeName === 'string' ? error.codeName.toLowerCase() : '';
-		const message = typeof error?.message === 'string' ? error.message.toLowerCase() : '';
-
-		if (code === 40573) {
-			return true;
-		}
-
-		if (codeName && codeName.includes('changestream')) {
-			return true;
-		}
-
-		if (message.includes('change stream') && message.includes('replica')) {
-			return true;
-		}
-
-		if (message.includes('change stream') && message.includes('not supported')) {
-			return true;
-		}
-
-		if (code === 13 && message.includes('allchangesforcluster')) {
-			return true;
-		}
-
-		if (code === 13 && message.includes('not authorized') && message.includes('$db: "admin"')) {
-			return true;
-		}
-
-		return false;
-	}
-
-	private isResumeTokenInvalid(error: any): boolean {
-		const code = typeof error?.code === 'number' ? error.code : null;
-		const codeName = typeof error?.codeName === 'string' ? error.codeName.toLowerCase() : '';
-		const message = typeof error?.message === 'string' ? error.message.toLowerCase() : '';
-
-		if (code === 286) {
-			// ChangeStreamHistoryLost
-			return true;
-		}
-
-		if (codeName.includes('changestreamhistorylost')) {
-			return true;
-		}
-
-		if (message.includes('resume token') && (
-			message.includes('not found') ||
-			message.includes('not possible') ||
-			message.includes('no longer') ||
-			message.includes('not in the oplog') ||
-			message.includes('too old')
-		)) {
-			return true;
-		}
-
-		if (message.includes('resume of change stream') && message.includes('not possible')) {
-			return true;
-		}
-
-		return false;
-	}
-
-	private isChangeStreamDocumentTooLarge(error: any): boolean {
-		const code = typeof error?.code === 'number' ? error.code : null;
-		const codeName = typeof error?.codeName === 'string' ? error.codeName.toLowerCase() : '';
-		const message = typeof error?.message === 'string' ? error.message.toLowerCase() : '';
-
-		if (code === 10334) {
-			return true;
-		}
-
-		if (codeName.includes('bsonobjecttoolarge')) {
-			return true;
-		}
-
-		if (message.includes('bsonobj size') && message.includes('16mb')) {
-			return true;
-		}
-
-		return false;
-	}
-
-	private async enableLocalOplogFallback(reason: string, error?: any) {
-		if (this._useLocalOplog) {
-			return;
-		}
-
-		this._useLocalOplog = true;
-		this._oplogMode = 'local';
-		this._oplogRetryCount = 0;
-
-		if (this._oplog$ && !this._oplog$.closed) {
-			try {
-				this._oplog$.removeAllListeners();
-				await this._oplog$.close();
-			}
-			catch {
-				// ignore close errors
-			}
-			this._oplog$ = null;
-		}
-
-		const message = typeof error?.message === 'string' ? error.message : '';
-		console.log(new Date(), 'oplog fallback enabled', reason, message ? `(${message})` : '');
-
-		this.queueFullResync('oplog-fallback-enabled');
-
-		if (this._localOplogResyncIntervalMs > 0 && !this._localOplogResyncTimer) {
-			this._localOplogResyncTimer = setInterval(() => {
-				this.queueFullResync('oplog-fallback-poll');
-			}, this._localOplogResyncIntervalMs);
-		}
-	}
-
-	public getUseLocalOplog() {
-		return this._useLocalOplog;
-	}
-
-	public async handleMongoReconnect(reason: string): Promise<void> {
-		if (this._useLocalOplog) {
-			this.queueFullResync(`mongo-reconnect:${reason}`);
-			return;
-		}
-
-		try {
-			const resumeToken = this._lastResumeToken || await this.loadResumeToken();
-			await this.tailOpLog(resumeToken || undefined);
-		}
-		catch (error) {
-			console.log(new Date(), 'Sub Manager', 'Mongo reconnect: tailOpLog restart failed', reason, error);
-		}
-
-		this.queueFullResync(`mongo-reconnect:${reason}`);
-	}
-
-	public notifyLocalOplog(collection: string, type = 'update') {
-		if (!this._useLocalOplog) {
-			return;
-		}
-
-		setImmediate(async () => {
-			try {
-				await this.invalidatePubsCache(collection, type);
-			}
-			catch {
-				// ignore local oplog cache invalidation errors
-			}
-		});
-	}
-
-	private getResumeTokenDocId(): string {
-		if (process.env.NODE_APP_INSTANCE) {
-			return `oplog:${process.env.NODE_APP_INSTANCE}`;
-		}
-
-		// Fallback: avoid cross-process contention when NODE_APP_INSTANCE is not set.
-		return `oplog:${process.pid}`;
-	}
-
-	private async loadResumeToken(): Promise<ResumeToken | null> {
-		try {
-			const db = ResolveIOServer.getMainDB();
-			if (!db) {
-				return null;
-			}
-
-			const loadToken = async () => {
-				const collection = db.collection<OplogResumeTokenDocument>(this.RESUME_TOKEN_COLLECTION);
-				const doc = await collection.findOne({ _id: this.getResumeTokenDocId() });
-				const token = doc?.token || null;
-
-				if (!token) {
-					return null;
-				}
-
-				const maxAgeMs = this.resolveResumeTokenMaxAgeMs();
-				if (maxAgeMs > 0 && doc?.updatedAt instanceof Date) {
-					const ageMs = Date.now() - doc.updatedAt.getTime();
-					if (ageMs > maxAgeMs) {
-						await collection.deleteOne({ _id: this.getResumeTokenDocId() });
-						console.log(new Date(), 'Sub Manager', 'Resume token expired, clearing', round(ageMs / 1000), 's');
-						return null;
-					}
-				}
-
-				return token;
-			};
-
-			const mongoManager = ResolveIOServer.getMongoManager();
-			return mongoManager ? await mongoManager.runWithoutSession(loadToken) : await loadToken();
-		}
-		catch (error) {
-			console.log(new Date(), 'Sub Manager', 'Failed to load oplog resume token', error);
-			return null;
-		}
-	}
-
-	private async saveResumeToken(token: ResumeToken): Promise<void> {
-		if (!token) {
-			return;
-		}
-
-		try {
-			const db = ResolveIOServer.getMainDB();
-			if (!db) {
-				return;
-			}
-
-			const saveToken = async () => {
-				await db.collection<OplogResumeTokenDocument>(this.RESUME_TOKEN_COLLECTION).updateOne(
-					{ _id: this.getResumeTokenDocId() },
-					{ $set: { token, updatedAt: new Date() } },
-					{ upsert: true }
-				);
-			};
-
-			const mongoManager = ResolveIOServer.getMongoManager();
-			if (mongoManager) {
-				await mongoManager.runWithoutSession(saveToken);
-			}
-			else {
-				await saveToken();
-			}
-		}
-		catch (error) {
-			console.log(new Date(), 'Sub Manager', 'Failed to persist oplog resume token', error);
-		}
-	}
-
-	private async clearResumeToken(): Promise<void> {
-		try {
-			const db = ResolveIOServer.getMainDB();
-			if (!db) {
-				return;
-			}
-
-			const clearToken = async () => {
-				await db.collection<OplogResumeTokenDocument>(this.RESUME_TOKEN_COLLECTION)
-					.deleteOne({ _id: this.getResumeTokenDocId() });
-			};
-
-			const mongoManager = ResolveIOServer.getMongoManager();
-			if (mongoManager) {
-				await mongoManager.runWithoutSession(clearToken);
-			}
-			else {
-				await clearToken();
-			}
-		}
-		catch (error) {
-			console.log(new Date(), 'Sub Manager', 'Failed to clear oplog resume token', error);
-		}
-	}
-
-	private queueResumeTokenSave(token: ResumeToken, options?: { force?: boolean }) {
-		if (!token) {
-			return;
-		}
-
-		this._lastResumeToken = token;
-
-		const now = Date.now();
-		const shouldSave = !!options?.force || (now - this._lastResumeTokenSaveMs) >= this.RESUME_TOKEN_SAVE_INTERVAL_MS;
-
-		if (!shouldSave) {
-			return;
-		}
-
-		if (this._resumeTokenSavePromise !== null) {
-			if (options?.force) {
-				this._resumeTokenSaveForcePending = true;
-			}
-			return;
-		}
-
-		this._lastResumeTokenSaveMs = now;
-		const tokenToSave = this._lastResumeToken;
-
-		this._resumeTokenSavePromise = (async () => {
-			try {
-				await this.saveResumeToken(tokenToSave);
-			}
-			finally {
-				this._resumeTokenSavePromise = null;
-				if (this._resumeTokenSaveForcePending) {
-					this._resumeTokenSaveForcePending = false;
-					this.queueResumeTokenSave(this._lastResumeToken, { force: true });
-				}
-			}
-		})();
-	}
-
-	private queueFullResync(reason: string) {
-		if (this._fullResyncPromise !== null) {
-			return;
-		}
-
-		this._fullResyncPromise = (async () => {
-			try {
-				await this.fullResyncSubscriptions(reason);
-			}
-			finally {
-				this._fullResyncPromise = null;
-			}
-		})();
-	}
-
-	private async fullResyncSubscriptions(reason: string): Promise<void> {
-		try {
-			if (this._enableDebug) {
-				console.log(new Date(), 'Sub Manager', 'Full subscription resync', reason, this._subscriptions.length);
-			}
-
-			try {
-				ResolveIOServer.getMongoManager()?.clearQueryCache?.(reason);
-			}
-			catch {
-				// ignore cache-clear errors
-			}
-
-			try {
-				this._nodeCache?.flushAll?.();
-			}
-			catch {
-				// ignore cache-clear errors
-			}
-
-			const subs = this._subscriptions.slice();
-
-			for (const sub of subs) {
-				if (!sub?.clients?.length) {
-					continue;
-				}
-
-				const pub = this._publications[sub.publication];
-				if (!pub) {
-					continue;
-				}
-
-				if (sub.running) {
-					sub.runAgain = true;
-					continue;
-				}
-
-				if (pub.user_specific) {
-					for (const client of sub.clients) {
-						const ws = this._websocketManager.getWebSocket(client.id_socket);
-						if (ws?.readyState === WebSocket.OPEN) {
-							try {
-								await this.sendDataToOneWithRetry(ws, client.messageId, sub, '', reason);
-							}
-							catch {
-								// ignore individual failures
-							}
-						}
-					}
-				}
-				else {
-					await this.sendDataToAllWithRetry(sub, '', reason);
-				}
-			}
-		}
-		catch (error) {
-			console.log(new Date(), 'Sub Manager', 'Full resync failed', reason, error);
-		}
-	}
-
-	// Watch (tail) Mongo's operation log on the entire database (all insert/modify/delete will trigger this function)
-	private async tailOpLog(resumeToken?: ResumeToken) {
-		if (this._useLocalOplog) {
-			return;
-		}
-
-		if (this._oplog$ && !this._oplog$.closed) {
-			this._oplog$.removeAllListeners();
-			await this._oplog$.close();
-			this._oplog$ = null;
-		}
-
-		// eslint-disable-next-line no-restricted-syntax
-		await new Promise(resolve => setTimeout(resolve, 1000));
-
-		if (!this._oplog$ || this._oplog$.closed) {
-			this._oplogRetryCount += 1;
-
-			if (this._oplogRetryCount > 5) {
-				console.error('****************** TAIL OPLOG ERROR, RETRYING A BUNCH OF TIMES, KILLING PROCESS **************************');
-				process.exit(1);
-			}
-
-			const watchDatabases = this.getWatchedDatabases();
-			const pipeline = [
-				{
-					$match: {
-						$and: [
-							...(watchDatabases.length ? [{ 'ns.db': { $in: watchDatabases } }] : []),
-							{'ns.coll': { $nin: [
-								'log-method-latencies', 
-								'log-subscriptions', 
-								'logs', 
-								'counters', 
-								'cron-job-histories', 
-								'email-histories',
-								'qb-soap-request-histories', 
-								'qb-soap-request-responses', 
-								'qb-soap-requests',
-								'qb-soap-retries',
-								this.RESUME_TOKEN_COLLECTION
-							] }},
-							{'ns.coll': { $not: /.*\.versions$/ }},
-							{'ns.coll': { $not: /^monitor-/ }},
-						]
-					},
-				},
-				];
-	
-				let lastResumeToken: ResumeToken;
-				let startedWithResumeToken = false;
-				let sawChangeEvent = false;
-				let resumeTokenInvalidated = false;
-				const streamStartedAtMs = Date.now();
-		
-				if (resumeToken) {
-					lastResumeToken = resumeToken;
-					try {
-						this._oplog$ = ResolveIOServer.getMongoConnection().watch(pipeline, { resumeAfter: resumeToken, fullDocument: 'updateLookup' });
-						startedWithResumeToken = true;
-					}
-					catch (error) {
-						if (this.isChangeStreamUnsupported(error)) {
-							await this.enableLocalOplogFallback('change-stream-unsupported', error);
-							return;
-						}
-						if (this.isChangeStreamDocumentTooLarge(error)) {
-							await this.clearResumeToken();
-							lastResumeToken = null;
-							this.queueFullResync('oplog-change-stream-document-too-large');
-							await this.enableLocalOplogFallback('change-stream-document-too-large', error);
-							return;
-						}
-
-						if (this._oplog$) {
-							this._oplog$.removeAllListeners();
-							await this._oplog$.close();
-							this._oplog$ = null;
-						}
-						
-						await this.clearResumeToken();
-						lastResumeToken = null;
-						
-						console.log(new Date(), 'oplog resumeAfter failed, starting fresh', error);
-
-						try {
-							this._oplog$ = ResolveIOServer.getMongoConnection().watch(pipeline, { fullDocument: 'updateLookup' });
-							startedWithResumeToken = false;
-						}
-						catch (innerError) {
-							if (this.isChangeStreamUnsupported(innerError)) {
-								await this.enableLocalOplogFallback('change-stream-unsupported', innerError);
-								return;
-							}
-
-							throw innerError;
-						}
-
-						this.queueFullResync('oplog-resumeAfter-failed');
-					}
-				}
-				else {
-						try {
-							this._oplog$ = ResolveIOServer.getMongoConnection().watch(pipeline, { fullDocument: 'updateLookup' });
-						}
-						catch (error) {
-							if (this.isChangeStreamUnsupported(error)) {
-								await this.enableLocalOplogFallback('change-stream-unsupported', error);
-								return;
-							}
-							if (this.isChangeStreamDocumentTooLarge(error)) {
-								await this.enableLocalOplogFallback('change-stream-document-too-large', error);
-								return;
-							}
-
-							throw error;
-						}
-				}
-
-				console.log(new Date(), 'oplog started', startedWithResumeToken ? '(resumeAfter)' : '');
-
-			this._oplog$.on('change', async (doc: ChangeStreamInsertDocument | ChangeStreamUpdateDocument | ChangeStreamReplaceDocument | ChangeStreamDeleteDocument) => {
-				sawChangeEvent = true;
-				this._oplogRetryCount = 0;
-
-				if (doc.ns) {
-					if (this._enableDebug) {
-						console.log(new Date(), 'Oplog Hit', doc.ns);
-					}
-
-					let collection = doc.ns.coll;
-
-					if (!this._debugOplogCollections.some(a => a.collection === doc.ns.coll && a.type === doc.operationType)) {
-						this._debugOplogCollections.push({
-							collection: doc.ns.coll,
-							type: doc.operationType,
-							hits: 1
-						});
-					}
-					else {
-						this._debugOplogCollections.find(a => a.collection === doc.ns.coll && a.type === doc.operationType).hits += 1;
-					}
-
-					if (collection) {
-						this._debugOplogHits += 1;
-						const fullDocument = doc['fullDocument'];
-						const docId = doc.documentKey && doc.documentKey['_id'] !== undefined ? doc.documentKey['_id'] : (fullDocument && fullDocument['_id'] !== undefined ? fullDocument['_id'] : null);
-
-						if (doc.operationType === 'insert') {
-							if (collection === 'support-tickets') {
-								if (this.serverConfig['ROOT_URL'] === 'https://resolveio.com') {
-									await ResolveIOServer.getMainServer().getMethodManager().callMethod.call(ResolveIOServer.getMainServer().getMethodManager(), 'sendSupportTicketEmail', doc.documentKey['_id']);
-									await this.invalidatePubsCache(collection, 'insert', docId, fullDocument);
-								}
-							}
-
-							if (collection !== 'method-responses') {
-								await this.invalidatePubsCache(collection, 'insert', docId, fullDocument);
-							}
-						}
-						else if (doc.operationType === 'update' || doc.operationType === 'replace') {
-							if (collection !== 'method-responses') {
-								await this.invalidatePubsCache(collection, 'update', docId, fullDocument);
-							}
-						}
-						else if (doc.operationType === 'delete') {
-							if (collection !== 'method-responses') {
-								await this.invalidatePubsCache(collection, 'delete', docId);
-							}
-						}
-					}
-
-					if (collection === 'flags') {
-						let flag = await Flags.findOne({ type: 'Enable Debug' });
-						let dependencyFlag = await Flags.findOne({ type: 'Enable Dependency Debug' });
-						
-						if (flag && flag.value) {
-							this._enableDebug = true;
-						}
-						else {
-							this._enableDebug = false;
-						}
-
-						if (dependencyFlag && dependencyFlag.value) {
-							this._enableDependencyDebug = true;
-						}
-						else {
-							this._enableDependencyDebug = process.env.ENABLE_DEPENDENCY_DEBUG === 'true';
-						}
-						}
-
-						lastResumeToken = doc._id;
-						this.queueResumeTokenSave(lastResumeToken);
-
-						if ((!process.env.NODE_APP_INSTANCE || process.env.NODE_APP_INSTANCE === '0') && (process.env.IS_WORKERS_ENABLED === 'false' || (process.env.IS_WORKER_INSTANCE === 'true' && process.env.WORKER_INDEX === '0'))) {
-
-						}
-				}
-			});
-
-			this._oplog$.on('error', async error => {
-				console.log(new Date(), 'oplog error', error);
-				if (this.isChangeStreamUnsupported(error)) {
-					await this.enableLocalOplogFallback('change-stream-unsupported', error);
-					return;
-				}
-				if (this.isChangeStreamDocumentTooLarge(error)) {
-					await this.clearResumeToken();
-					lastResumeToken = null;
-					this.queueFullResync('oplog-change-stream-document-too-large');
-					await this.enableLocalOplogFallback('change-stream-document-too-large', error);
-					return;
-				}
-
-				if (this.isResumeTokenInvalid(error)) {
-					resumeTokenInvalidated = true;
-					await this.clearResumeToken();
-					lastResumeToken = null;
-					this.queueFullResync('oplog-resume-token-invalid');
-				}
-
-				await this._oplog$.close();
-			});
-
-			this._oplog$.on('end', async () => {
-				console.log(new Date(), 'oplog end');
-				await this._oplog$.close();
-			});
-
-				this._oplog$.on('close', async () => {
-					console.log(new Date(), 'oplog close');
-					const retryThresholdReached = this._oplogRetryCount >= this.RESUME_TOKEN_AUTO_HEAL_RETRY_THRESHOLD;
-					const shouldAutoHealResumeToken = startedWithResumeToken
-						&& !!lastResumeToken
-						&& !sawChangeEvent
-						&& (resumeTokenInvalidated || retryThresholdReached);
-
-					if (shouldAutoHealResumeToken) {
-						await this.clearResumeToken();
-						lastResumeToken = null;
-						if (!resumeTokenInvalidated) {
-							this.queueFullResync('oplog-resume-token-auto-heal');
-						}
-						console.log(
-							new Date(),
-							'Sub Manager',
-							'Auto-healed stale oplog resume token',
-							{ retryCount: this._oplogRetryCount, streamLifetimeMs: Date.now() - streamStartedAtMs }
-						);
-					}
-
-					if (lastResumeToken) {
-						this.queueResumeTokenSave(lastResumeToken, { force: true });
-					}
-					this._oplog$.removeAllListeners();
-					this._oplog$ = null;
-					await this.tailOpLog(lastResumeToken);
-				});
-		}
-	}
-
-	private packCachePayload(data: any): Buffer | null {
-		if (data === undefined) {
-			return null;
-		}
-
-		try {
-			const packed = pack(data);
-			return Buffer.isBuffer(packed) ? packed : Buffer.from(packed);
-		}
-		catch (err) {
-			if (this._enableDebug) {
-				console.log(new Date(), 'Sub Cache', 'Pack Failed', err?.message || err);
-			}
-			return null;
-		}
-	}
-
-	private decodeCachePayload(raw: any): any | null {
-		if (!raw) {
-			return null;
-		}
-
-		if (Buffer.isBuffer(raw)) {
-			try {
-				return unpack(raw);
-			}
-			catch (err) {
-				if (this._enableDebug) {
-					console.log(new Date(), 'Sub Cache', 'Unpack Failed', err?.message || err);
-				}
-				return null;
-			}
-		}
-
-		if (raw instanceof Uint8Array) {
-			try {
-				return unpack(raw);
-			}
-			catch (err) {
-				if (this._enableDebug) {
-					console.log(new Date(), 'Sub Cache', 'Unpack Failed', err?.message || err);
-				}
-				return null;
-			}
-		}
-
-		if (raw instanceof ArrayBuffer) {
-			try {
-				return unpack(new Uint8Array(raw));
-			}
-			catch (err) {
-				if (this._enableDebug) {
-					console.log(new Date(), 'Sub Cache', 'Unpack Failed', err?.message || err);
-				}
-				return null;
-			}
-		}
-
-		// Treat legacy string caches as invalid to avoid JSON parsing in the hot path.
-		if (typeof raw === 'string') {
-			return null;
-		}
-
-		return raw;
-	}
-
-	private getCacheBuffer(raw: any): Buffer | null {
-		if (!raw) {
-			return null;
-		}
-
-		if (Buffer.isBuffer(raw)) {
-			return raw;
-		}
-
-		if (raw instanceof Uint8Array) {
-			return Buffer.from(raw);
-		}
-
-		if (raw instanceof ArrayBuffer) {
-			return Buffer.from(new Uint8Array(raw));
-		}
-
-		return null;
-	}
-
-	private shouldCachePayload(sub: ActiveSubscriptionModel, payload: Buffer | Uint8Array | null): boolean {
-		if (!payload || payload.byteLength >= 1000000) {
-			return false;
-		}
-
-		if (sub.collections.includes('logs')) {
-			return false;
-		}
-
-		if (sub.collections.find(a => a.endsWith('.versions'))) {
-			return false;
-		}
-
-		if (sub.collections.find(a => a.startsWith('monitor-'))) {
-			return false;
-		}
-
-		return true;
-	}
-
-	private buffersEqual(a: Uint8Array | Buffer | null, b: Uint8Array | Buffer | null): boolean {
-		if (!a || !b) {
-			return false;
-		}
-
-		if (a.byteLength !== b.byteLength) {
-			return false;
-		}
-
-		const toBuffer = (value: Uint8Array | Buffer): Buffer => {
-			if (Buffer.isBuffer(value)) {
-				return value;
-			}
-			const buffer = value.buffer as ArrayBuffer;
-			return Buffer.from(buffer, value.byteOffset, value.byteLength);
-		};
-
-		const aBuf = toBuffer(a);
-		const bBuf = toBuffer(b);
-		return aBuf.equals(bBuf as Uint8Array);
-	}
-
-	private async processSubscription(sub: ActiveSubscriptionModel, ws: WebSocket, messageId: number) {
-		if (!this._publications[sub.publication].user_specific) {			
-			if (sub.cacheId) {
-				try {
-					const cachedRaw = this._nodeCache.get(sub.cacheId);
-					const cachedBuffer = this.getCacheBuffer(cachedRaw);
-
-						if (cachedBuffer && cachedBuffer.byteLength) {
-							if (this._enableDebug) {
-								console.log(new Date(), 'Process Sub, Cache (packed)', sub.publication);
-							}
-
-							this._websocketManager.sendPackedBuffer(ws, messageId, false, cachedBuffer, 'msgpack');
-							this.logAiSubSend({
-								publication: sub.publication,
-								subscriptionKey: sub.subscriptionKey,
-								messageId,
-								id_socket: ws['id_socket'],
-								clients: 1,
-								payloadBytes: cachedBuffer.byteLength,
-								packed: true,
-								cacheHit: true,
-								collection: '',
-								type: 'cache',
-								subscriptionData: sub.subscriptionData
-							});
-						}
-						else {
-							const cacheData = this.decodeCachePayload(cachedRaw);
-							if (cacheData === null || cacheData === undefined) {
-								throw new Error('cache-miss');
-						}
-
-						let serverRes: ServerResponseModel = {
-							messageId: messageId,
-							hasError: false,
-							data: cacheData
-						};
-
-						if (this._enableDebug) {
-							console.log(new Date(), 'Process Sub, Cache', sub.publication);
-						}
-
-						this.sendWS(ws, serverRes);
-						this.logAiSubSend({
-							publication: sub.publication,
-							subscriptionKey: sub.subscriptionKey,
-							messageId,
-							id_socket: ws['id_socket'],
-							clients: 1,
-							payloadBytes: cacheData ? Buffer.byteLength(JSON.stringify(cacheData)) : null,
-							packed: false,
-							cacheHit: true,
-							collection: '',
-							type: 'cache',
-							subscriptionData: sub.subscriptionData
-						});
-					}
-				}
-				catch {
-					this._nodeCache.del(sub.cacheId);
-					sub.cacheId = 0;
-
-					await this.sendDataToAllWithRetry(sub, '', 'newSub');
-				}
-			}
-			else {
-				if (this._enableDebug) {
-					console.log(new Date(), 'Process Sub, Non - Cache', sub.publication, sub.running);
-				}
-
-				if (sub.running) {
-					return;
-				}
-
-				await this.sendDataToAllWithRetry(sub, '', 'newSub');
-			}
-		}
-		else {
-			if (this._enableDebug) {
-				console.log(new Date(), 'Process Sub Specific, Non - Cache', sub.publication, sub.running);
-			}
-
-			if (sub.running) {
-				return;
-			}
-			
-			await this.sendDataToOneWithRetry(ws, messageId, sub, '', 'newSub');
-		}
-	}
-
-	private async sendDataToOne(ws: WebSocket, messageId: number, sub: ActiveSubscriptionModel, collection: string, type: string) {
-		if (!ws || ws.readyState !== WebSocket.OPEN) {
-			return;
-		}
-
-		let monitor = this._monitorManagerFunction.startMonitorFunction('User Specific Publication', sub.publication, '', '', sub.subscriptionData);
-		let dependencySnapshot: DependencyContextSnapshot;
-		let res;
-		try {
-			await ResolveIOServer.getMainServer().getMethodManager().callMethod.call(ResolveIOServer.getMainServer().getMethodManager(), 'insertSubscriptionLog', type, sub.publication, collection, JSON.stringify(sub.subscriptionData));
-
-			const execution = await this.runPublicationExecution(sub, ws['id_user']);
-			res = execution.result;
-			dependencySnapshot = execution.snapshot;
-			this.updateSubscriptionDependencies(sub, dependencySnapshot);
-			const packedRes = execution.packedResult ?? this.packCachePayload(res);
-			const payloadBytes = packedRes ? packedRes.byteLength : null;
-
-			if (execution.packedResult) {
-				this._websocketManager.sendPackedBuffer(
-					ws,
-					messageId,
-					false,
-					execution.packedResult,
-					execution.encoding || 'msgpack',
-					{ passThrough: !!execution.workerUsed }
-				);
-			}
-			else {
-				let serverRes: ServerResponseModel = {
-					messageId: messageId,
-					hasError: false,
-					data: res
-				};
-
-				this.sendWS(ws, serverRes);
-			}
-			this.logAiSubSend({
-				publication: sub.publication,
-				subscriptionKey: sub.subscriptionKey,
-				messageId,
-				id_socket: ws['id_socket'],
-				clients: 1,
-				payloadBytes,
-				packed: !!execution.packedResult,
-				cacheHit: false,
-				collection,
-				type,
-				subscriptionData: sub.subscriptionData
-			});
-		}
-		catch (err) {
-			const { error: normalizedError, correlationId } = ensureErrorWithCorrelation(err);
-
-			let serverRes: ServerResponseModel = {
-				messageId: messageId,
-				hasError: true,
-				data: Object.assign({}, normalizedError, { correlationId })
-			};
-			
-			this.sendWS(ws, serverRes);
-			
-			const errorPayload = {
-				publication: sub.publication,
-				subscriptionData: sub.subscriptionData,
-				type,
-				collection,
-				messageId,
-				correlationId,
-				error: {
-					name: normalizedError?.name,
-					message: normalizedError?.message,
-					stack: normalizedError?.stack,
-					code: normalizedError?.code,
-					codeName: normalizedError?.codeName
-				}
-			};
-
-			await ErrorReporter.report({
-				sourceApp: 'subscription-manager',
-				message: 'SERVER - Error Detected - ' + this.serverConfig['CLIENT_NAME'],
-				environment: this.serverConfig?.ROOT_URL,
-				clientSlug: ResolveIOServer.getClientName(),
-				clientName: this.serverConfig['CLIENT_NAME'],
-				stack: normalizedError?.stack,
-				context: errorPayload,
-				metadata: {
-					context: 'subscription-sendDataToOne',
-					publication: sub.publication,
-					correlationId
-				},
-				correlationId
-			});
-		}
-		finally {
-			await this._monitorManagerFunction.finishMonitorFunction(monitor);
-		}
-	}
-
-	// Fetch pub once, send to all clients linked to this pub
-	private async sendDataToAll(sub: ActiveSubscriptionModel, collection: string, type: string) {
-		const isAiPublication = this.isAiPublication(sub.publication);
-		if (isAiPublication && sub.clients.length > 1) {
-			const seenSockets = new Set<string>();
-			sub.clients = sub.clients.filter(client => {
-				if (seenSockets.has(client.id_socket)) {
-					return false;
-				}
-				seenSockets.add(client.id_socket);
-				return true;
-			});
-		}
-		const activeClients: { client: ActiveSubscriptionClientModel; ws: WebSocket }[] = [];
-		if (sub.clients.length) {
-			for (const client of sub.clients) {
-				const ws = this._websocketManager.getWebSocket(client.id_socket);
-				if (ws && ws.readyState === WebSocket.OPEN) {
-					activeClients.push({ client, ws });
-				}
-			}
-		}
-
-		if (!activeClients.length) {
-			if (sub.cacheId) {
-				this._nodeCache.del(sub.cacheId);
-				sub.cacheId = 0;
-			}
-
-			let subIndex = this._subscriptions.findIndex(a => a.publication === sub.publication && a.subscriptionKey === sub.subscriptionKey);
-			if (subIndex >= 0) {
-				this._subscriptions.splice(subIndex, 1);
-			}
-
-			return;
-		}
-		else {
-			if (activeClients.length !== sub.clients.length) {
-				sub.clients = activeClients.map(entry => entry.client);
-			}
-
-			let monitor = this._monitorManagerFunction.startMonitorFunction('Publication', sub.publication, '', '', sub.subscriptionData);
-			let res;
-			let dependencySnapshot: DependencyContextSnapshot;
-
-			try {
-				if (sub.publication !== 'superadminAPM' && sub.publication !== 'loggedInUsers') {
-					await ResolveIOServer.getMainServer().getMethodManager().callMethod.call(ResolveIOServer.getMainServer().getMethodManager(), 'insertSubscriptionLog', type, sub.publication, collection, JSON.stringify(sub.subscriptionData));
-				}
-
-				const execution = await this.runPublicationExecution(sub);
-				res = execution.result;
-				dependencySnapshot = execution.snapshot;
-				this.updateSubscriptionDependencies(sub, dependencySnapshot);
-				const packedRes = execution.packedResult ?? this.packCachePayload(res);
-				const passThrough = !!execution.workerUsed;
-				const payloadBytes = packedRes ? packedRes.byteLength : null;
-				const shouldCache = this.shouldCachePayload(sub, packedRes);
-				
-
-				if (sub.cacheId) {
-					const cachedBuffer = this.getCacheBuffer(this._nodeCache.get(sub.cacheId));
-					const isSame = this.buffersEqual(cachedBuffer, packedRes);
-
-					if (!isSame) {
-						const sendStartMs = Date.now();
-						let sentClients = 0;
-						for (const entry of activeClients) {
-							const { client, ws } = entry;
-							if (packedRes) {
-								this._websocketManager.sendPackedBuffer(
-									ws,
-									client.messageId,
-									false,
-									packedRes,
-									execution.encoding || 'msgpack',
-									{ passThrough }
-								);
-							}
-							else {
-								let serverRes: ServerResponseModel = {
-									messageId: client.messageId,
-									hasError: false,
-									data: res
-								};
-
-								this.sendWS(ws, serverRes);
-							}
-							if (isAiPublication) {
-								this.logAiSubSend({
-									publication: sub.publication,
-									subscriptionKey: sub.subscriptionKey,
-									messageId: client.messageId,
-									id_socket: ws['id_socket'],
-									clients: activeClients.length,
-									payloadBytes,
-									packed: !!packedRes,
-									cacheHit: false,
-									collection,
-									type,
-									subscriptionData: sub.subscriptionData
-								});
-							}
-							sentClients += 1;
-						}
-						this.logSubSend(sub, {
-							collection,
-							type,
-							clients: sentClients,
-							durationMs: Date.now() - sendStartMs,
-							payloadBytes
-						});
-
-						this._nodeCache.del(sub.cacheId);
-
-						if (shouldCache) {
-							this._nodeCache.set(sub.cacheId, packedRes);
-						}
-						else {
-							sub.cacheId = 0;
-						}
-					}
-					else if (!cachedBuffer && shouldCache) {
-						this._nodeCache.set(sub.cacheId, packedRes);
-					}
-					else if (!shouldCache) {
-						this._nodeCache.del(sub.cacheId);
-						sub.cacheId = 0;
-					}
-				}
-				else {
-					const sendStartMs = Date.now();
-					let sentClients = 0;
-					for (const entry of activeClients) {
-						const { client, ws } = entry;
-						if (packedRes) {
-							this._websocketManager.sendPackedBuffer(
-								ws,
-								client.messageId,
-								false,
-								packedRes,
-								execution.encoding || 'msgpack',
-								{ passThrough }
-							);
-						}
-						else {
-							let serverRes: ServerResponseModel = {
-								messageId: client.messageId,
-								hasError: false,
-								data: res
-							};
-
-							this.sendWS(ws, serverRes);
-						}
-						if (isAiPublication) {
-							this.logAiSubSend({
-								publication: sub.publication,
-								subscriptionKey: sub.subscriptionKey,
-								messageId: client.messageId,
-								id_socket: ws['id_socket'],
-								clients: activeClients.length,
-								payloadBytes,
-								packed: !!packedRes,
-								cacheHit: false,
-								collection,
-								type,
-								subscriptionData: sub.subscriptionData
-							});
-						}
-						sentClients += 1;
-					}
-					this.logSubSend(sub, {
-						collection,
-						type,
-						clients: sentClients,
-						durationMs: Date.now() - sendStartMs,
-						payloadBytes
-					});
-					
-					if (shouldCache) {
-						sub.cacheId = this._cacheId++;
-						this._nodeCache.set(sub.cacheId, packedRes);
-
-						const nodeCacheSize = this._nodeCache.getStats().vsize;
-
-						if (nodeCacheSize > this._heapLimit) {
-							// Evict cache entries as needed
-							let deleteCount = 0;
-							const subArr = this._subscriptions.filter(a => a.cacheId && !a.clients.length);
-					
-							for (let zz = 0; zz < subArr.length; zz++) {
-								this._debugRemoveCacheHits += 1;
-								this._nodeCache.del(subArr[zz].cacheId);
-								subArr[zz].cacheId = 0;
-								deleteCount += 1;
-								if (this._nodeCache.getStats().vsize < this._heapLimit * 0.75) {
-									break;
-								}
-							}
-
-							if (this._enableDebug) {
-								console.log(
-									'Sub Cache: ' +
-									'Too Big - ' +
-									sub.publication +
-									' - Deleted: ' +
-									deleteCount +
-									' - ' +
-									nodeCacheSize
-								);
-							}
-						}
-					}
-					else {
-						sub.cacheId = 0;
-					}
-				}
-			}
-			catch (err) {
-				const { error: normalizedError, correlationId } = ensureErrorWithCorrelation(err);
-
-				for (let client of sub.clients) {
-					let ws = this._websocketManager.getWebSocket(client.id_socket);
-					if (ws && ws.readyState === WebSocket.OPEN) {
-						let serverRes: ServerResponseModel = {
-							messageId: client.messageId,
-							hasError: true,
-							data: Object.assign({}, normalizedError, { correlationId })
-						};
-						
-						this.sendWS(ws, serverRes);
-					}
-				}
-				
-				const errorPayload = {
-					publication: sub.publication,
-					subscriptionData: sub.subscriptionData,
-					type,
-					collection,
-					correlationId,
-					error: {
-						name: normalizedError?.name,
-						message: normalizedError?.message,
-						stack: normalizedError?.stack,
-						code: normalizedError?.code,
-						codeName: normalizedError?.codeName
-					}
-				};
-				
-			await ErrorReporter.report({
-				sourceApp: 'subscription-manager',
-				message: 'SERVER - Error Detected - ' + this.serverConfig['CLIENT_NAME'],
-				environment: this.serverConfig?.ROOT_URL,
-				clientSlug: ResolveIOServer.getClientName(),
-				clientName: this.serverConfig['CLIENT_NAME'],
-				stack: normalizedError?.stack,
-				context: errorPayload,
-				metadata: {
-					context: 'subscription-sendDataToAll',
-					publication: sub.publication,
-					correlationId
-				},
-				correlationId
-			});
-			}
-			finally {
-				await this._monitorManagerFunction.finishMonitorFunction(monitor);
-			}
-		}
-	}
-
-	private ensureDependencyContainers(sub: ActiveSubscriptionModel) {
-		if (!sub.collectionDependencies) {
-			sub.collectionDependencies = new Map();
-		}
-
-		if (!sub.collectionFilters) {
-			sub.collectionFilters = new Map();
-		}
-
-		if (!sub.watchAllCollections) {
-			sub.watchAllCollections = new Set();
-		}
-
-		if (!sub.collectionQueryMeta) {
-			sub.collectionQueryMeta = new Map();
-		}
-	}
-
-	private updateSubscriptionDependencies(sub: ActiveSubscriptionModel, snapshot?: DependencyContextSnapshot) {
-		this.ensureDependencyContainers(sub);
-
-		if (!snapshot) {
-			sub.collectionDependencies.clear();
-			sub.collectionFilters.clear();
-			sub.watchAllCollections.clear();
-			sub.collectionQueryMeta.clear();
-			this.dependencyDebug('Cleared dependency snapshot', { publication: sub.publication });
-			return;
-		}
-
-		sub.collectionDependencies = snapshot.dependencies;
-		sub.collectionFilters = snapshot.filters;
-		sub.watchAllCollections = snapshot.watchAllCollections;
-		sub.collectionQueryMeta = snapshot.queryMetadata;
-		this.logDependencySnapshot(sub, 'Snapshot updated');
-	}
-
-	private normalizeDocumentId(rawId: any): string {
-		if (rawId === null || rawId === undefined) {
-			return null;
-		}
-
-		if (typeof rawId === 'string') {
-			return rawId;
-		}
-
-		if (typeof rawId === 'object' && typeof rawId.toHexString === 'function') {
-			return rawId.toHexString();
-		}
-
-		if (typeof rawId?.toString === 'function') {
-			const str = rawId.toString();
-			if (str && str !== '[object Object]') {
-				return str;
-			}
-		}
-
-		return null;
-	}
-
-	private getDocumentIdQueryCandidates(documentId: any): any[] {
-		const candidates: any[] = [];
-
-		if (documentId === undefined || documentId === null) {
-			return [documentId];
-		}
-
-		const addCandidate = value => {
-			if (value === undefined || value === null) {
-				return;
-			}
-
-			if (!candidates.includes(value)) {
-				candidates.push(value);
-			}
-		};
-
-		addCandidate(documentId);
-
-		if (typeof documentId === 'object') {
-			if (typeof documentId.toHexString === 'function') {
-				addCandidate(documentId.toHexString());
-			}
-
-			if (typeof documentId.toString === 'function') {
-				const str = documentId.toString();
-				if (str && str !== '[object Object]') {
-					addCandidate(str);
-				}
-			}
-		}
-		else if (typeof documentId !== 'string') {
-			addCandidate(String(documentId));
-		}
-
-		return candidates;
-	}
-
-	private isFilterSafeForInMemory(filter: any): boolean {
-		if (!filter || typeof filter !== 'object') {
-			return false;
-		}
-
-		const allowedOperators = new Set([
-			'$and',
-			'$or',
-			'$nor',
-			'$in',
-			'$nin',
-			'$eq',
-			'$ne',
-			'$gt',
-			'$gte',
-			'$lt',
-			'$lte',
-			'$exists',
-			'$size',
-			'$all',
-			'$elemMatch',
-			'$regex',
-			'$options'
-		]);
-
-		const disallowedOperators = new Set([
-			'$where',
-			'$expr',
-			'$text',
-			'$geoWithin',
-			'$geoIntersects',
-			'$near',
-			'$nearSphere',
-			'$jsonSchema',
-			'$mod',
-			'$type',
-			'$bitsAllSet',
-			'$bitsAllClear',
-			'$bitsAnySet',
-			'$bitsAnyClear'
-		]);
-
-		const walk = (value: any): boolean => {
-			if (Array.isArray(value)) {
-				return value.every(item => walk(item));
-			}
-
-			if (!value || typeof value !== 'object') {
-				return true;
-			}
-
-			for (const [key, entry] of Object.entries(value)) {
-				if (key.startsWith('$')) {
-					if (disallowedOperators.has(key)) {
-						return false;
-					}
-					if (!allowedOperators.has(key)) {
-						return false;
-					}
-				}
-
-				if (!walk(entry)) {
-					return false;
-				}
-			}
-
-			return true;
-		};
-
-		return walk(filter);
-	}
-
-	private documentIdMatchesEvent(documentId: any, document?: any): boolean {
-		if (!document || documentId === undefined || documentId === null) {
-			return true;
-		}
-
-		const eventCandidates = this.getDocumentIdQueryCandidates(documentId)
-			.map(id => this.normalizeDocumentId(id))
-			.filter(Boolean);
-		const docCandidates = this.getDocumentIdQueryCandidates(document?._id)
-			.map(id => this.normalizeDocumentId(id))
-			.filter(Boolean);
-
-		if (!eventCandidates.length || !docCandidates.length) {
-			return true;
-		}
-
-		const docSet = new Set(docCandidates);
-
-		for (const candidate of eventCandidates) {
-			if (docSet.has(candidate)) {
-				return true;
-			}
-		}
-
-		return false;
-	}
-
-	private resolveFilterMatch(filter: any, document?: any, documentId?: any): boolean | null {
-		if (!document || !filter || typeof filter !== 'object') {
-			return null;
-		}
-
-		if (!this.isFilterSafeForInMemory(filter)) {
-			return null;
-		}
-
-		if (!this.documentIdMatchesEvent(documentId, document)) {
-			return false;
-		}
-
-		try {
-			const matcher = sift(filter);
-			return matcher(document);
-		}
-		catch {
-			return null;
-		}
-	}
-
-	private async documentMatchesFilter(collection: string, documentId: any, filter: any, document?: any): Promise<boolean> {
-		try {
-			const inMemoryMatch = this.resolveFilterMatch(filter, document, documentId);
-			if (inMemoryMatch !== null) {
-				return inMemoryMatch;
-			}
-
-			const db = ResolveIOServer.getMainDB();
-			const filterCopy = deepCopy(filter) || {};
-			const idCandidates = this.getDocumentIdQueryCandidates(documentId);
-
-			for (const idValue of idCandidates) {
-				const combinedFilter = {
-					$and: [
-						{ _id: idValue },
-						filterCopy
-					]
-				};
-
-				const doc = await db.collection(collection).findOne(combinedFilter);
-				if (doc) {
-					return true;
-				}
-			}
-
-			return false;
-		}
-		catch {
-			return true;
-		}
-	}
-
-	private async shouldInvalidateSubscription(sub: ActiveSubscriptionModel, collection: string, type: string, documentId?: any, document?: any): Promise<boolean> {
-		this.ensureDependencyContainers(sub);
-
-		const normalizedDocumentId = this.normalizeDocumentId(documentId);
-		const trackedIds = sub.collectionDependencies.get(collection);
-		const filters = sub.collectionFilters.get(collection);
-		const hasTrackedIds = !!(trackedIds && trackedIds.size);
-		const hasFilters = !!(filters && filters.length);
-		const hasDependencyData =
-			(sub.collectionDependencies.get(collection)?.size || 0) > 0 ||
-			(sub.collectionFilters.get(collection)?.length || 0) > 0 ||
-			sub.watchAllCollections.has(collection);
-
-		if (!normalizedDocumentId) {
-			this.dependencyDebug('Invalidate due to missing documentId', { publication: sub.publication, collection, type });
-			return true;
-		}
-
-		if (!hasDependencyData) {
-			this.dependencyDebug('Invalidate due to missing dependency metadata', {
-				publication: sub.publication,
-				collection,
-				type
-			});
-			return true;
-		}
-
-		if (sub.watchAllCollections.has(collection)) {
-			this.dependencyDebug('Invalidate due to watch-all collection', { publication: sub.publication, collection, type });
-			return true;
-		}
-
-		if (trackedIds && trackedIds.has(normalizedDocumentId)) {
-			this.dependencyDebug('Invalidate due to tracked id', { publication: sub.publication, collection, type, documentId: normalizedDocumentId });
-			return true;
-		}
-
-		if (type === 'delete') {
-			if (hasFilters && !hasTrackedIds) {
-				this.dependencyDebug('Invalidate delete due to filter-only dependency without tracked ids', {
-					publication: sub.publication,
-					collection,
-					type,
-					documentId: normalizedDocumentId
-				});
-				return true;
-			}
-
-			this.dependencyDebug('Skip invalidation on delete for unknown id', { publication: sub.publication, collection, type, documentId: normalizedDocumentId });
-			return false;
-		}
-
-		if (type === 'update' && hasFilters && !hasTrackedIds) {
-			this.dependencyDebug('Invalidate update due to filter-only dependency without tracked ids', {
-				publication: sub.publication,
-				collection,
-				type,
-				documentId: normalizedDocumentId
-			});
-			return true;
-		}
-
-		if (filters && filters.length) {
-			for (const filter of filters) {
-				if (await this.documentMatchesFilter(collection, documentId, filter, document)) {
-					this.dependencyDebug('Invalidate due to filter match', { publication: sub.publication, collection, type, documentId: normalizedDocumentId, filter });
-					return true;
-				}
-			}
-		}
-
-		this.dependencyDebug('Skip invalidation after dependency checks', { publication: sub.publication, collection, type, documentId: normalizedDocumentId });
-		return false;
-	}
-
-	private async shouldInvalidateSubscriptionForEvents(sub: ActiveSubscriptionModel, collection: string, events: SubscriptionInvalidationEvent[]): Promise<boolean> {
-		let sawInsert = false;
-		let sawDelete = false;
-
-		for (const event of events) {
-			if (event.type === 'insert') {
-				sawInsert = true;
-			}
-			else if (event.type === 'delete') {
-				sawDelete = true;
-			}
-			if (await this.shouldInvalidateSubscription(sub, collection, event.type, event.documentId, event.document)) {
-				return true;
-			}
-		}
-
-		const paginationMeta = this.getPaginationMeta(sub, collection);
-		const paginationReasons = [];
-		if (sawInsert) {
-			paginationReasons.push('insert');
-		}
-		if (sawDelete) {
-			paginationReasons.push('delete');
-		}
-
-		if (paginationMeta?.length && paginationReasons.length) {
-			this.dependencyDebug('Invalidate due to pagination metadata', {
-				publication: sub.publication,
-				collection,
-				events: this.summarizeEvents(events),
-				reasons: paginationReasons,
-				queryMeta: paginationMeta.slice(0, 5)
-			});
-			return true;
-		}
-
-		return false;
-	}
-
-	private getPaginationMeta(sub: ActiveSubscriptionModel, collection: string): QueryMeta[] {
-		this.ensureDependencyContainers(sub);
-		const metaList = sub.collectionQueryMeta?.get(collection);
-		if (!metaList || !metaList.length) {
-			return null;
-		}
-
-		const relevantMeta = metaList.filter(meta => {
-			if (!meta) {
-				return false;
-			}
-
-			const limitUsed = typeof meta.limit === 'number' && meta.limit > 0;
-			const skipUsed = typeof meta.skip === 'number' && meta.skip > 0;
-			return limitUsed || skipUsed;
-		});
-
-		return relevantMeta.length ? relevantMeta : null;
-	}
-
-	private sendWS(ws: WebSocket, data: ServerResponseModel) {
-		this._websocketManager.send(ws, data);
-	}
-
-	public getEnableDebug() {
-		return this._enableDebug;
-	}
-
-	private dependencyDebug(message: string, details?: Record<string, unknown>) {
-		if (!this._enableDependencyDebug) {
-			return;
-		}
-
-		if (details) {
-			console.log(new Date(), '[Dependency Debug]', message, JSON.stringify(details, null, 2));
-		}
-		else {
-			console.log(new Date(), '[Dependency Debug]', message);
-		}
-	}
-
-	private summarizeEvents(events: SubscriptionInvalidationEvent[]) {
-		return events.map(event => ({
-			type: event.type,
-			documentId: this.normalizeDocumentId(event.documentId)
-		}));
-	}
-
-	private logDependencySnapshot(sub: ActiveSubscriptionModel, context: string) {
-		if (!this._enableDependencyDebug) {
-			return;
-		}
-
-		const dependencySummary = Array.from(sub.collectionDependencies.entries()).map(([collectionName, ids]) => {
-			const idList = Array.from(ids || []);
-			return {
-				collection: collectionName,
-				count: idList.length,
-				sample: idList.slice(0, 10)
-			};
-		});
-
-		const filterSummary = Array.from(sub.collectionFilters.entries()).map(([collectionName, filters]) => ({
-			collection: collectionName,
-			count: filters.length
-		}));
-
-		const queryMetaSummary = Array.from(sub.collectionQueryMeta.entries()).map(([collectionName, metaList]) => ({
-			collection: collectionName,
-			count: metaList.length,
-			meta: metaList.slice(0, 5)
-		}));
-
-		const watchAll = Array.from(sub.watchAllCollections || []);
-
-		this.dependencyDebug('Dependency snapshot updated', {
-			context,
-			publication: sub.publication,
-			dependencies: dependencySummary,
-			collectionsWithFilters: filterSummary,
-			collectionsWithMeta: queryMetaSummary,
-			watchAll
-		});
-	}
-
-	public async runPublicationOnce(publication: string, subscriptionData: any[] = [], options?: { userId?: string }) {
-		const pub = this._publications[publication];
-		if (!pub) {
-			throw new Error(`Publication not found: ${publication}`);
-		}
-
-		const context = Object.assign({}, this, SubscriptionManager.prototype);
-		const metadata: PublicationContext = {
-			publication,
-			subscriptionData
-		};
-
-		if (pub.user_specific) {
-			return withDependencyTracking(() => pub.function.call(context, options?.userId || '', ...subscriptionData), metadata);
-		}
-
-		return withDependencyTracking(() => pub.function.call(context, ...subscriptionData), metadata);
-	}
-}