nodejs-insta-private-api-mqt 1.3.70

package/dist/realtime/features/persistent-logger.js

@@ -0,0 +1,186 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const DEFAULT_MAX_FILE_SIZE = 10 * 1024 * 1024;
+const DEFAULT_MAX_FILES = 5;
+const DEFAULT_FLUSH_INTERVAL = 30000;
+
+class PersistentLogger {
+    constructor(options = {}) {
+        this.logDir = options.logDir || './logs';
+        this.prefix = options.prefix || 'instagram-mqtt';
+        this.maxFileSize = options.maxFileSize || DEFAULT_MAX_FILE_SIZE;
+        this.maxFiles = options.maxFiles || DEFAULT_MAX_FILES;
+        this.flushIntervalMs = options.flushIntervalMs || DEFAULT_FLUSH_INTERVAL;
+        this.logToConsole = options.logToConsole !== false;
+        this.logLevel = options.logLevel || 'info';
+
+        this._buffer = [];
+        this._currentFile = null;
+        this._currentFileSize = 0;
+        this._flushTimer = null;
+        this._started = false;
+        this._totalLines = 0;
+
+        this._levels = { debug: 0, info: 1, warn: 2, error: 3 };
+    }
+
+    start() {
+        if (this._started) return;
+        this._started = true;
+
+        try {
+            if (!fs.existsSync(this.logDir)) {
+                fs.mkdirSync(this.logDir, { recursive: true });
+            }
+        } catch (e) {
+            console.error('[LOGGER] Failed to create log directory:', e?.message || e);
+        }
+
+        this._rotateIfNeeded();
+
+        this._flushTimer = setInterval(() => {
+            this._flush();
+        }, this.flushIntervalMs);
+
+        this.info('PersistentLogger started', { logDir: this.logDir, maxFileSize: this.maxFileSize, maxFiles: this.maxFiles });
+    }
+
+    stop() {
+        this._started = false;
+        if (this._flushTimer) {
+            clearInterval(this._flushTimer);
+            this._flushTimer = null;
+        }
+        this._flush();
+    }
+
+    debug(...args) { this._write('debug', args); }
+    info(...args) { this._write('info', args); }
+    warn(...args) { this._write('warn', args); }
+    error(...args) { this._write('error', args); }
+
+    _write(level, args) {
+        if (this._levels[level] < this._levels[this.logLevel]) return;
+
+        const timestamp = new Date().toISOString();
+        const message = args.map(a => {
+            if (typeof a === 'object') {
+                try { return JSON.stringify(a); } catch (e) { return String(a); }
+            }
+            return String(a);
+        }).join(' ');
+
+        const line = `[${timestamp}] [${level.toUpperCase()}] ${message}`;
+
+        if (this.logToConsole) {
+            const consoleFn = level === 'error' ? console.error : (level === 'warn' ? console.warn : console.log);
+            consoleFn(line);
+        }
+
+        this._buffer.push(line);
+        this._totalLines++;
+
+        if (this._buffer.length >= 50) {
+            this._flush();
+        }
+    }
+
+    _flush() {
+        if (this._buffer.length === 0) return;
+        if (!this._currentFile) this._rotateIfNeeded();
+
+        try {
+            const content = this._buffer.join('\n') + '\n';
+            fs.appendFileSync(this._currentFile, content);
+            this._currentFileSize += Buffer.byteLength(content);
+            this._buffer = [];
+
+            if (this._currentFileSize >= this.maxFileSize) {
+                this._rotateIfNeeded();
+            }
+        } catch (e) {
+            if (this.logToConsole) {
+                console.error('[LOGGER] Failed to flush:', e?.message || e);
+            }
+        }
+    }
+
+    _rotateIfNeeded() {
+        try {
+            if (this._currentFile && fs.existsSync(this._currentFile)) {
+                try {
+                    const stat = fs.statSync(this._currentFile);
+                    this._currentFileSize = stat.size;
+                    if (this._currentFileSize < this.maxFileSize) return;
+                } catch (e) {}
+            }
+
+            const timestamp = new Date().toISOString().replace(/[:.]/g, '-').replace('T', '_').slice(0, 19);
+            this._currentFile = path.join(this.logDir, `${this.prefix}_${timestamp}.log`);
+            this._currentFileSize = 0;
+
+            this._cleanOldFiles();
+        } catch (e) {
+            if (this.logToConsole) {
+                console.error('[LOGGER] Rotation error:', e?.message || e);
+            }
+        }
+    }
+
+    _cleanOldFiles() {
+        try {
+            const files = fs.readdirSync(this.logDir)
+                .filter(f => f.startsWith(this.prefix) && f.endsWith('.log'))
+                .sort();
+
+            while (files.length > this.maxFiles) {
+                const oldest = files.shift();
+                try {
+                    fs.unlinkSync(path.join(this.logDir, oldest));
+                } catch (e) {}
+            }
+        } catch (e) {}
+    }
+
+    getLogFiles() {
+        try {
+            return fs.readdirSync(this.logDir)
+                .filter(f => f.startsWith(this.prefix) && f.endsWith('.log'))
+                .sort()
+                .map(f => path.join(this.logDir, f));
+        } catch (e) {
+            return [];
+        }
+    }
+
+    getRecentLines(count = 100) {
+        this._flush();
+        try {
+            const files = this.getLogFiles();
+            if (files.length === 0) return [];
+
+            const lastFile = files[files.length - 1];
+            const content = fs.readFileSync(lastFile, 'utf8');
+            const lines = content.trim().split('\n');
+            return lines.slice(-count);
+        } catch (e) {
+            return [];
+        }
+    }
+
+    getStats() {
+        return {
+            started: this._started,
+            totalLines: this._totalLines,
+            bufferSize: this._buffer.length,
+            currentFile: this._currentFile,
+            currentFileSize: this._currentFileSize,
+            logFiles: this.getLogFiles(),
+        };
+    }
+}
+
+module.exports = { PersistentLogger };

package/dist/realtime/features/presence.manager.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PresenceManager = void 0;
+const shared_1 = require("../../shared");
+const uuid_1 = require("uuid");
+/**
+ * Presence Manager - Handle online/offline status
+ */
+class PresenceManager {
+    constructor(client) {
+        this.presenceDebug = (0, shared_1.debugChannel)('realtime', 'presence');
+        this.userPresence = new Map();
+        this.client = client;
+    }
+    /**
+     * Update user presence
+     */
+    updatePresence(userId, status, lastActivity = Date.now()) {
+        this.presenceDebug(`User ${userId} is ${status}`);
+        this.userPresence.set(userId, { status, lastActivity });
+        this.client.emit('presence', {
+            user_id: userId,
+            status,
+            last_activity: lastActivity,
+        });
+    }
+    /**
+     * Get user presence
+     */
+    getPresence(userId) {
+        return this.userPresence.get(userId) || { status: 'offline', lastActivity: null };
+    }
+    /**
+     * Broadcast user's own presence
+     */
+    async broadcastPresence(status = 'online') {
+        this.presenceDebug(`Broadcasting presence: ${status}`);
+        const payload = {
+            action: 'presence_status',
+            status,
+            timestamp: Date.now(),
+            client_context: (0, uuid_1.v4)(),
+        };
+        return this.client.directCommands?.sendCommand({
+            action: 'send_presence',
+            data: payload,
+            threadId: '',
+        });
+    }
+    /**
+     * Handle presence update
+     */
+    handlePresenceUpdate(data) {
+        try {
+            const update = typeof data === 'string' ? JSON.parse(data) : data;
+            if (update.user_id && update.status) {
+                this.updatePresence(update.user_id, update.status, update.last_activity);
+            }
+            return update;
+        } catch (err) {
+            this.presenceDebug(`Failed to parse presence update: ${err.message}`);
+            return null;
+        }
+    }
+}
+exports.PresenceManager = PresenceManager;

package/dist/realtime/features/session-health-monitor.js

@@ -0,0 +1,345 @@
+'use strict';
+
+const EventEmitter = require('eventemitter3');
+
+const SESSION_CHECK_INTERVAL = 30 * 60 * 1000;
+const SESSION_CHECK_JITTER = 5 * 60 * 1000;
+const MIN_CHECK_INTERVAL = 5 * 60 * 1000;
+
+class SessionHealthMonitor extends EventEmitter {
+    constructor(realtimeClient, options = {}) {
+        super();
+        this.rt = realtimeClient;
+        this.ig = realtimeClient.ig;
+        this.options = {
+            checkIntervalMs: options.checkIntervalMs || SESSION_CHECK_INTERVAL,
+            jitterMs: options.jitterMs || SESSION_CHECK_JITTER,
+            autoRelogin: options.autoRelogin !== false,
+            credentials: options.credentials || null,
+            onSessionExpired: options.onSessionExpired || null,
+            maxConsecutiveFailures: options.maxConsecutiveFailures || 5,
+            ...options,
+        };
+
+        this._checkTimer = null;
+        this._running = false;
+        this._consecutiveFailures = 0;
+        this._lastCheckAt = null;
+        this._lastCheckResult = null;
+        this._sessionValid = true;
+        this._reloginInProgress = false;
+        this._reloginCount = 0;
+
+        this._stats = {
+            startedAt: null,
+            totalChecks: 0,
+            successfulChecks: 0,
+            failedChecks: 0,
+            sessionExpiries: 0,
+            relogins: 0,
+            successfulRelogins: 0,
+            failedRelogins: 0,
+            totalUptimeMs: 0,
+            longestUptimeMs: 0,
+            reconnects: 0,
+            lastUptimeStart: null,
+            uptimeSegments: [],
+        };
+    }
+
+    start() {
+        if (this._running) return;
+        this._running = true;
+        this._stats.startedAt = Date.now();
+        this._stats.lastUptimeStart = Date.now();
+        this._log('[HEALTH] Session health monitor started');
+        this._log(`[HEALTH] Check interval: ${Math.round(this.options.checkIntervalMs / 60000)}min + up to ${Math.round(this.options.jitterMs / 60000)}min jitter`);
+        this._log(`[HEALTH] Auto-relogin: ${this.options.autoRelogin ? 'enabled' : 'disabled'}`);
+
+        this._scheduleNextCheck();
+
+        if (this.rt) {
+            this.rt.on('reconnected', () => {
+                this._stats.reconnects++;
+                this._recordUptimeSegment();
+                this._stats.lastUptimeStart = Date.now();
+                this._log('[HEALTH] Reconnected - uptime segment recorded');
+            });
+
+            this.rt.on('disconnect', () => {
+                this._recordUptimeSegment();
+            });
+
+            this.rt.on('reconnect_failed', () => {
+                this._log('[HEALTH] All reconnect attempts exhausted - checking session validity');
+                this._performCheck().catch(() => {});
+            });
+        }
+    }
+
+    stop() {
+        this._running = false;
+        if (this._checkTimer) {
+            clearTimeout(this._checkTimer);
+            this._checkTimer = null;
+        }
+        this._recordUptimeSegment();
+        this._log('[HEALTH] Session health monitor stopped');
+    }
+
+    _scheduleNextCheck() {
+        if (!this._running) return;
+        if (this._checkTimer) clearTimeout(this._checkTimer);
+
+        const jitter = Math.floor(Math.random() * this.options.jitterMs);
+        const delay = Math.max(MIN_CHECK_INTERVAL, this.options.checkIntervalMs + jitter);
+
+        this._checkTimer = setTimeout(async () => {
+            try {
+                await this._performCheck();
+            } catch (e) {
+                this._log('[HEALTH] Check error:', e?.message || e);
+            }
+            this._scheduleNextCheck();
+        }, delay);
+    }
+
+    async _performCheck() {
+        this._stats.totalChecks++;
+        this._lastCheckAt = Date.now();
+
+        try {
+            const result = await this._checkSessionValidity();
+            this._lastCheckResult = result;
+
+            if (result.valid) {
+                this._consecutiveFailures = 0;
+                this._sessionValid = true;
+                this._stats.successfulChecks++;
+                this._log(`[HEALTH] Session valid (userId: ${result.userId || 'unknown'}, check #${this._stats.totalChecks})`);
+                this.emit('health_check', { status: 'ok', result, stats: this.getStats() });
+                return true;
+            } else {
+                this._consecutiveFailures++;
+                this._stats.failedChecks++;
+                this._log(`[HEALTH] Session check failed (${this._consecutiveFailures}/${this.options.maxConsecutiveFailures}): ${result.reason}`);
+                this.emit('health_check', { status: 'failed', result, consecutiveFailures: this._consecutiveFailures });
+
+                if (this._consecutiveFailures >= 2) {
+                    this._sessionValid = false;
+                    this._stats.sessionExpiries++;
+                    this._log('[HEALTH] Session appears expired');
+                    this.emit('session_expired', { result, consecutiveFailures: this._consecutiveFailures });
+
+                    if (this.options.autoRelogin) {
+                        return await this._attemptRelogin();
+                    } else if (typeof this.options.onSessionExpired === 'function') {
+                        try { await this.options.onSessionExpired(result); } catch (e) {}
+                    }
+                }
+                return false;
+            }
+        } catch (e) {
+            this._consecutiveFailures++;
+            this._stats.failedChecks++;
+            this._log('[HEALTH] Session check threw:', e?.message || e);
+            this.emit('health_check', { status: 'error', error: e?.message, consecutiveFailures: this._consecutiveFailures });
+
+            if (this._consecutiveFailures >= this.options.maxConsecutiveFailures) {
+                this._log(`[HEALTH] Max consecutive failures (${this.options.maxConsecutiveFailures}) reached`);
+                if (this.options.autoRelogin) {
+                    return await this._attemptRelogin();
+                }
+            }
+            return false;
+        }
+    }
+
+    async _checkSessionValidity() {
+        try {
+            const response = await this.ig.request.send({
+                url: '/api/v1/accounts/current_user/',
+                method: 'GET',
+                qs: { edit: true },
+            });
+
+            if (response?.body?.user) {
+                return {
+                    valid: true,
+                    userId: response.body.user.pk || response.body.user.pk_id,
+                    username: response.body.user.username,
+                    fullName: response.body.user.full_name,
+                };
+            }
+
+            return { valid: false, reason: 'No user data in response', statusCode: response?.statusCode };
+        } catch (e) {
+            const status = e?.response?.statusCode || e?.statusCode;
+            const body = e?.response?.body;
+
+            if (status === 401 || status === 403) {
+                return { valid: false, reason: `Auth error (${status})`, statusCode: status, requiresRelogin: true };
+            }
+            if (status === 429) {
+                return { valid: false, reason: 'Rate limited (429) - session might still be valid', statusCode: status, rateLimited: true };
+            }
+            if (body?.message === 'login_required' || body?.error_type === 'inactive user') {
+                return { valid: false, reason: body.message || body.error_type, statusCode: status, requiresRelogin: true };
+            }
+            if (e.code === 'ENOTFOUND' || e.code === 'ECONNREFUSED' || e.code === 'ETIMEDOUT') {
+                return { valid: false, reason: `Network error: ${e.code}`, networkError: true };
+            }
+
+            return { valid: false, reason: e?.message || 'Unknown error', statusCode: status };
+        }
+    }
+
+    async _attemptRelogin() {
+        if (this._reloginInProgress) {
+            this._log('[HEALTH] Relogin already in progress, skipping');
+            return false;
+        }
+        this._reloginInProgress = true;
+        this._stats.relogins++;
+
+        try {
+            const creds = this.options.credentials;
+            if (!creds || !creds.username || !creds.password) {
+                this._log('[HEALTH] No credentials available for auto-relogin');
+                this.emit('relogin_needed', { reason: 'No credentials configured' });
+                return false;
+            }
+
+            this._log(`[HEALTH] Attempting auto-relogin as ${creds.username}...`);
+            this.emit('relogin_start', { username: creds.username });
+
+            try {
+                await this.ig.login({ username: creds.username, password: creds.password });
+                this._log('[HEALTH] Relogin successful!');
+                this._stats.successfulRelogins++;
+                this._reloginCount++;
+                this._consecutiveFailures = 0;
+                this._sessionValid = true;
+
+                if (this.rt._attachedAuthState && typeof this.rt._attachedAuthState.saveCreds === 'function') {
+                    try {
+                        await this.rt._attachedAuthState.saveCreds(this.ig);
+                        this._log('[HEALTH] Credentials saved after relogin');
+                    } catch (e) {
+                        this._log('[HEALTH] Failed to save credentials:', e?.message || e);
+                    }
+                }
+
+                this.emit('relogin_success', { username: creds.username, reloginCount: this._reloginCount });
+
+                try {
+                    this._log('[HEALTH] Triggering MQTT reconnect with fresh session...');
+                    await this.rt._attemptReconnectSafely();
+                } catch (e) {
+                    this._log('[HEALTH] MQTT reconnect after relogin failed:', e?.message || e);
+                }
+
+                return true;
+            } catch (e) {
+                this._stats.failedRelogins++;
+                const isChallenge = e?.message?.includes('challenge') || e?.message?.includes('checkpoint');
+                this._log(`[HEALTH] Relogin failed: ${e?.message || e}`);
+
+                if (isChallenge) {
+                    this._log('[HEALTH] Account requires verification - cannot auto-relogin');
+                    this.emit('relogin_challenge', { error: e?.message });
+                }
+
+                this.emit('relogin_failed', { error: e?.message, isChallenge });
+                return false;
+            }
+        } finally {
+            this._reloginInProgress = false;
+        }
+    }
+
+    async forceCheck() {
+        return this._performCheck();
+    }
+
+    isSessionValid() {
+        return this._sessionValid;
+    }
+
+    getStats() {
+        const now = Date.now();
+        const currentSegmentMs = this._stats.lastUptimeStart ? (now - this._stats.lastUptimeStart) : 0;
+        const totalUptime = this._stats.totalUptimeMs + currentSegmentMs;
+        const totalRuntime = this._stats.startedAt ? (now - this._stats.startedAt) : 0;
+
+        return {
+            running: this._running,
+            sessionValid: this._sessionValid,
+            startedAt: this._stats.startedAt ? new Date(this._stats.startedAt).toISOString() : null,
+            totalRuntimeMs: totalRuntime,
+            totalRuntimeHuman: this._humanDuration(totalRuntime),
+            totalUptimeMs: totalUptime,
+            totalUptimeHuman: this._humanDuration(totalUptime),
+            uptimePercent: totalRuntime > 0 ? Math.round((totalUptime / totalRuntime) * 10000) / 100 : 100,
+            currentSessionMs: currentSegmentMs,
+            currentSessionHuman: this._humanDuration(currentSegmentMs),
+            longestSessionMs: Math.max(this._stats.longestUptimeMs, currentSegmentMs),
+            longestSessionHuman: this._humanDuration(Math.max(this._stats.longestUptimeMs, currentSegmentMs)),
+            totalChecks: this._stats.totalChecks,
+            successfulChecks: this._stats.successfulChecks,
+            failedChecks: this._stats.failedChecks,
+            sessionExpiries: this._stats.sessionExpiries,
+            reconnects: this._stats.reconnects,
+            relogins: this._stats.relogins,
+            successfulRelogins: this._stats.successfulRelogins,
+            failedRelogins: this._stats.failedRelogins,
+            consecutiveFailures: this._consecutiveFailures,
+            lastCheckAt: this._lastCheckAt ? new Date(this._lastCheckAt).toISOString() : null,
+            lastCheckResult: this._lastCheckResult,
+        };
+    }
+
+    _recordUptimeSegment() {
+        if (this._stats.lastUptimeStart) {
+            const segmentMs = Date.now() - this._stats.lastUptimeStart;
+            this._stats.totalUptimeMs += segmentMs;
+            if (segmentMs > this._stats.longestUptimeMs) this._stats.longestUptimeMs = segmentMs;
+            this._stats.uptimeSegments.push({
+                start: new Date(this._stats.lastUptimeStart).toISOString(),
+                end: new Date().toISOString(),
+                durationMs: segmentMs,
+            });
+            if (this._stats.uptimeSegments.length > 100) {
+                this._stats.uptimeSegments = this._stats.uptimeSegments.slice(-50);
+            }
+            this._stats.lastUptimeStart = null;
+        }
+    }
+
+    _humanDuration(ms) {
+        if (!ms || ms <= 0) return '0s';
+        const d = Math.floor(ms / 86400000);
+        const h = Math.floor((ms % 86400000) / 3600000);
+        const m = Math.floor((ms % 3600000) / 60000);
+        const s = Math.floor((ms % 60000) / 1000);
+        const parts = [];
+        if (d > 0) parts.push(`${d}d`);
+        if (h > 0) parts.push(`${h}h`);
+        if (m > 0) parts.push(`${m}m`);
+        if (s > 0 || parts.length === 0) parts.push(`${s}s`);
+        return parts.join(' ');
+    }
+
+    _log(...args) {
+        if (this.rt && typeof this.rt.realtimeDebug === 'function') {
+            this.rt.realtimeDebug(...args);
+        } else {
+            console.log(...args);
+        }
+        try {
+            this.emit('log', args.join(' '));
+        } catch (e) {}
+    }
+}
+
+module.exports = { SessionHealthMonitor };

package/dist/realtime/index.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PresenceTypingMixin = exports.EnhancedDirectCommands = exports.GapHandler = exports.ErrorHandler = exports.DMSender = exports.PresenceManager = exports.SkywalkerProtocol = exports.IrisHandshake = exports.RealtimeClient = void 0;
+
+const realtime_client_1 = require("./realtime.client");
+Object.defineProperty(exports, "RealtimeClient", { enumerable: true, get: function () { return realtime_client_1.RealtimeClient; } });
+
+const iris_handshake_1 = require("./protocols/iris.handshake");
+Object.defineProperty(exports, "IrisHandshake", { enumerable: true, get: function () { return iris_handshake_1.IrisHandshake; } });
+
+const skywalker_protocol_1 = require("./protocols/skywalker.protocol");
+Object.defineProperty(exports, "SkywalkerProtocol", { enumerable: true, get: function () { return skywalker_protocol_1.SkywalkerProtocol; } });
+
+const presence_manager_1 = require("./features/presence.manager");
+Object.defineProperty(exports, "PresenceManager", { enumerable: true, get: function () { return presence_manager_1.PresenceManager; } });
+
+const dm_sender_1 = require("./features/dm-sender");
+Object.defineProperty(exports, "DMSender", { enumerable: true, get: function () { return dm_sender_1.DMSender; } });
+
+const error_handler_1 = require("./features/error-handler");
+Object.defineProperty(exports, "ErrorHandler", { enumerable: true, get: function () { return error_handler_1.ErrorHandler; } });
+
+const gap_handler_1 = require("./features/gap-handler");
+Object.defineProperty(exports, "GapHandler", { enumerable: true, get: function () { return gap_handler_1.GapHandler; } });
+
+const presence_typing_mixin_1 = require("./mixins/presence-typing.mixin");
+Object.defineProperty(exports, "PresenceTypingMixin", { enumerable: true, get: function () { return presence_typing_mixin_1.PresenceTypingMixin; } });
+
+const enhanced_direct_commands_1 = require("./commands/enhanced.direct.commands");
+Object.defineProperty(exports, "EnhancedDirectCommands", { enumerable: true, get: function () { return enhanced_direct_commands_1.EnhancedDirectCommands; } });

package/dist/realtime/messages/app-presence.event.d.ts

@@ -0,0 +1,9 @@
+export interface AppPresenceEvent {
+    user_id: string;
+    is_active: boolean;
+    last_activity_at_ms: string;
+    in_threads: any[];
+}
+export interface AppPresenceEventWrapper {
+    presence_event: AppPresenceEvent;
+}

package/dist/realtime/messages/app-presence.event.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=app-presence.event.js.map

package/dist/realtime/messages/app-presence.event.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"app-presence.event.js","sourceRoot":"","sources":["../../../src/realtime/messages/app-presence.event.ts"],"names":[],"mappings":""}

package/dist/realtime/messages/index.d.ts

@@ -0,0 +1,3 @@
+export * from './message-sync.message';
+export * from './realtime-sub.direct.data';
+export * from './app-presence.event';

package/dist/realtime/messages/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./message-sync.message"), exports);
+__exportStar(require("./realtime-sub.direct.data"), exports);
+__exportStar(require("./app-presence.event"), exports);
+//# sourceMappingURL=index.js.map

package/dist/realtime/messages/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/realtime/messages/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,yDAAuC;AACvC,6DAA2C;AAC3C,uDAAqC"}