@resolveio/server-lib 22.3.219 → 22.3.221

package/src/managers/subscription.manager.ts

@@ -0,0 +1,3128 @@
+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);
+	}
+}