@nuraly/lumenjs 0.1.3 → 0.2.0

package/dist/communication/signaling.d.ts

@@ -0,0 +1,43 @@
+import type { CallType, CallEndReason, SignalOffer, SignalIceCandidate, SignalIceRestart, ConnectionQualityReport } from './types.js';
+import type { CommunicationStore } from './store.js';
+/** Context for signaling handlers */
+export interface SignalingContext {
+    userId: string;
+    store: CommunicationStore;
+    /** Emit to a specific socket by ID */
+    emitToSocket: (socketId: string, data: any) => void;
+    /** Broadcast to all sockets in a room */
+    broadcastAll: (room: string, data: any) => void;
+}
+export declare function handleCallInitiate(ctx: SignalingContext, data: {
+    conversationId: string;
+    type: CallType;
+    calleeIds: string[];
+}): void;
+export declare function handleCallRespond(ctx: SignalingContext, data: {
+    callId: string;
+    action: 'accept' | 'reject';
+}): void;
+export declare function handleCallHangup(ctx: SignalingContext, data: {
+    callId: string;
+    reason: CallEndReason;
+}): void;
+export declare function handleCallMediaToggle(ctx: SignalingContext, data: {
+    callId: string;
+    audio?: boolean;
+    video?: boolean;
+    screenShare?: boolean;
+}): void;
+export declare function handleCallAddParticipant(ctx: SignalingContext, data: {
+    callId: string;
+    userId: string;
+}): void;
+export declare function handleCallRemoveParticipant(ctx: SignalingContext, data: {
+    callId: string;
+    userId: string;
+}): void;
+export declare function handleSignalOffer(ctx: SignalingContext, data: SignalOffer): void;
+export declare function handleSignalAnswer(ctx: SignalingContext, data: SignalOffer): void;
+export declare function handleSignalIceCandidate(ctx: SignalingContext, data: SignalIceCandidate): void;
+export declare function handleSignalIceRestart(ctx: SignalingContext, data: SignalIceRestart): void;
+export declare function handleCallQualityReport(ctx: SignalingContext, data: ConnectionQualityReport): void;

package/dist/communication/signaling.js

@@ -0,0 +1,271 @@
+/** Emit data to all sockets belonging to a user */
+function emitToUser(ctx, targetUserId, data) {
+    const sockets = ctx.store.getSocketsForUser(targetUserId);
+    for (const sid of sockets) {
+        ctx.emitToSocket(sid, data);
+    }
+}
+// ── Call Lifecycle ───────────────────────────────────────────────
+export function handleCallInitiate(ctx, data) {
+    // Check if caller is already in a call
+    const existingCall = ctx.store.getActiveCallForUser(ctx.userId);
+    if (existingCall) {
+        emitToUser(ctx, ctx.userId, {
+            event: 'call:state-changed',
+            data: { callId: existingCall.id, state: existingCall.state, error: 'already_in_call' },
+        });
+        return;
+    }
+    const callId = crypto.randomUUID();
+    const now = new Date().toISOString();
+    const call = {
+        id: callId,
+        conversationId: data.conversationId,
+        type: data.type,
+        state: 'initiating',
+        callerId: ctx.userId,
+        calleeIds: data.calleeIds,
+        startedAt: now,
+        participants: [{
+                userId: ctx.userId,
+                joinedAt: now,
+                audioMuted: false,
+                videoMuted: data.type === 'audio',
+                screenSharing: false,
+            }],
+    };
+    ctx.store.addCall(call);
+    // Notify caller that call is initiating
+    emitToUser(ctx, ctx.userId, {
+        event: 'call:state-changed',
+        data: { callId, state: 'initiating' },
+    });
+    // Notify each callee with incoming call
+    for (const calleeId of data.calleeIds) {
+        // Check if callee is busy (exclude the current call being initiated)
+        const calleeActiveCall = ctx.store.getActiveCallForUser(calleeId);
+        if (calleeActiveCall && calleeActiveCall.id !== callId) {
+            emitToUser(ctx, ctx.userId, {
+                event: 'call:state-changed',
+                data: { callId, state: 'ended', endReason: 'busy' },
+            });
+            ctx.store.updateCallState(callId, 'ended', 'busy');
+            ctx.store.removeCall(callId);
+            return;
+        }
+        emitToUser(ctx, calleeId, { event: 'call:incoming', data: call });
+    }
+    // Update state to ringing
+    ctx.store.updateCallState(callId, 'ringing');
+}
+export function handleCallRespond(ctx, data) {
+    const call = ctx.store.getCall(data.callId);
+    if (!call)
+        return;
+    if (data.action === 'reject') {
+        ctx.store.updateCallState(data.callId, 'ended', 'rejected');
+        // Notify all parties
+        emitToUser(ctx, call.callerId, {
+            event: 'call:state-changed',
+            data: { callId: data.callId, state: 'ended', endReason: 'rejected' },
+        });
+        emitToUser(ctx, ctx.userId, {
+            event: 'call:state-changed',
+            data: { callId: data.callId, state: 'ended', endReason: 'rejected' },
+        });
+        ctx.store.removeCall(data.callId);
+        return;
+    }
+    // Accept — add callee as participant
+    const now = new Date().toISOString();
+    const participant = {
+        userId: ctx.userId,
+        joinedAt: now,
+        audioMuted: false,
+        videoMuted: call.type === 'audio',
+        screenSharing: false,
+    };
+    ctx.store.addCallParticipant(data.callId, participant);
+    ctx.store.updateCallState(data.callId, 'connecting');
+    // Notify caller that callee accepted
+    emitToUser(ctx, call.callerId, {
+        event: 'call:participant-joined',
+        data: { callId: data.callId, participant },
+    });
+    emitToUser(ctx, call.callerId, {
+        event: 'call:state-changed',
+        data: { callId: data.callId, state: 'connecting' },
+    });
+    // Notify callee of connecting state
+    emitToUser(ctx, ctx.userId, {
+        event: 'call:state-changed',
+        data: { callId: data.callId, state: 'connecting' },
+    });
+}
+export function handleCallHangup(ctx, data) {
+    const call = ctx.store.getCall(data.callId);
+    if (!call)
+        return;
+    // Remove the user who hung up
+    ctx.store.removeCallParticipant(data.callId, ctx.userId);
+    // Notify other participants
+    for (const p of call.participants) {
+        if (p.userId === ctx.userId)
+            continue;
+        emitToUser(ctx, p.userId, {
+            event: 'call:participant-left',
+            data: { callId: data.callId, userId: ctx.userId },
+        });
+    }
+    // Also notify caller/callees who may not be in participants yet (e.g., still ringing)
+    const allUsers = new Set([call.callerId, ...call.calleeIds]);
+    allUsers.delete(ctx.userId);
+    // If no participants left (or only one), end the call
+    const remainingParticipants = call.participants.filter(p => p.userId !== ctx.userId);
+    if (remainingParticipants.length <= 1) {
+        ctx.store.updateCallState(data.callId, 'ended', data.reason);
+        for (const uid of allUsers) {
+            emitToUser(ctx, uid, {
+                event: 'call:state-changed',
+                data: { callId: data.callId, state: 'ended', endReason: data.reason },
+            });
+        }
+        ctx.store.removeCall(data.callId);
+    }
+}
+export function handleCallMediaToggle(ctx, data) {
+    const call = ctx.store.getCall(data.callId);
+    if (!call)
+        return;
+    const participant = call.participants.find(p => p.userId === ctx.userId);
+    if (!participant)
+        return;
+    if (data.audio !== undefined)
+        participant.audioMuted = !data.audio;
+    if (data.video !== undefined)
+        participant.videoMuted = !data.video;
+    if (data.screenShare !== undefined)
+        participant.screenSharing = data.screenShare;
+    // Notify all other participants
+    for (const p of call.participants) {
+        if (p.userId === ctx.userId)
+            continue;
+        emitToUser(ctx, p.userId, {
+            event: 'call:media-changed',
+            data: {
+                callId: data.callId,
+                userId: ctx.userId,
+                audio: data.audio,
+                video: data.video,
+                screenShare: data.screenShare,
+            },
+        });
+    }
+}
+// ── Mid-Call Participant Management ──────────────────────────────
+export function handleCallAddParticipant(ctx, data) {
+    const call = ctx.store.getCall(data.callId);
+    if (!call)
+        return;
+    // Only existing participants can add someone
+    const isParticipant = call.participants.some(p => p.userId === ctx.userId);
+    if (!isParticipant)
+        return;
+    // Don't add someone already in the call
+    if (call.participants.some(p => p.userId === data.userId))
+        return;
+    // Check if the target user is already in another call
+    const targetActiveCall = ctx.store.getActiveCallForUser(data.userId);
+    if (targetActiveCall) {
+        emitToUser(ctx, ctx.userId, {
+            event: 'call:state-changed',
+            data: { callId: data.callId, state: call.state, error: 'user_busy' },
+        });
+        return;
+    }
+    // Add to calleeIds so they are tracked
+    if (!call.calleeIds.includes(data.userId)) {
+        call.calleeIds.push(data.userId);
+    }
+    // Send incoming call notification to the new user
+    emitToUser(ctx, data.userId, { event: 'call:incoming', data: call });
+}
+export function handleCallRemoveParticipant(ctx, data) {
+    const call = ctx.store.getCall(data.callId);
+    if (!call)
+        return;
+    // Only the caller (owner) or admins can kick participants
+    if (ctx.userId !== call.callerId)
+        return;
+    // Can't remove yourself (use hangup instead)
+    if (data.userId === ctx.userId)
+        return;
+    // Check the target is actually in the call
+    const targetParticipant = call.participants.find(p => p.userId === data.userId);
+    if (!targetParticipant)
+        return;
+    ctx.store.removeCallParticipant(data.callId, data.userId);
+    // Notify all remaining participants
+    for (const p of call.participants) {
+        if (p.userId === data.userId)
+            continue;
+        emitToUser(ctx, p.userId, {
+            event: 'call:participant-left',
+            data: { callId: data.callId, userId: data.userId },
+        });
+    }
+    // Notify the removed user
+    emitToUser(ctx, data.userId, {
+        event: 'call:participant-left',
+        data: { callId: data.callId, userId: data.userId },
+    });
+    emitToUser(ctx, data.userId, {
+        event: 'call:state-changed',
+        data: { callId: data.callId, state: 'ended', endReason: 'completed' },
+    });
+}
+// ── WebRTC Signal Relay ─────────────────────────────────────────
+/** Verify the sender is part of an active call with the target user. */
+function verifyCallMembership(ctx, fromUserId, toUserId) {
+    // Ensure fromUserId matches the authenticated user
+    if (fromUserId !== ctx.userId)
+        return false;
+    // Check both users are participants in the same active call
+    const call = ctx.store.getActiveCallForUser(ctx.userId);
+    if (!call)
+        return false;
+    const isTarget = call.callerId === toUserId || call.calleeIds.includes(toUserId) ||
+        call.participants.some(p => p.userId === toUserId);
+    return isTarget;
+}
+export function handleSignalOffer(ctx, data) {
+    if (!verifyCallMembership(ctx, data.fromUserId, data.toUserId))
+        return;
+    emitToUser(ctx, data.toUserId, { event: 'signal:offer', data });
+}
+export function handleSignalAnswer(ctx, data) {
+    if (!verifyCallMembership(ctx, data.fromUserId, data.toUserId))
+        return;
+    emitToUser(ctx, data.toUserId, { event: 'signal:answer', data });
+}
+export function handleSignalIceCandidate(ctx, data) {
+    if (!verifyCallMembership(ctx, data.fromUserId, data.toUserId))
+        return;
+    emitToUser(ctx, data.toUserId, { event: 'signal:ice-candidate', data });
+}
+export function handleSignalIceRestart(ctx, data) {
+    if (!verifyCallMembership(ctx, data.fromUserId, data.toUserId))
+        return;
+    emitToUser(ctx, data.toUserId, { event: 'signal:ice-restart', data });
+}
+export function handleCallQualityReport(ctx, data) {
+    const call = ctx.store.getCall(data.callId);
+    if (!call)
+        return;
+    // Broadcast quality report to all other participants in the call
+    for (const p of call.participants) {
+        if (p.userId === ctx.userId)
+            continue;
+        emitToUser(ctx, p.userId, { event: 'call:quality-changed', data });
+    }
+}

package/dist/communication/store.d.ts

@@ -0,0 +1,71 @@
+import type { PresenceStatus, Call, CallState, CallEndReason, CallParticipant, KeyBundle, PreKey, RateLimitConfig } from './types.js';
+export interface PresenceEntry {
+    userId: string;
+    status: PresenceStatus;
+    lastSeen: string;
+    socketIds: Set<string>;
+}
+export declare class CommunicationStore {
+    /** userId → presence info */
+    private presence;
+    /** conversationId → map of userId → typing timer */
+    private typing;
+    /** callId → active call */
+    private calls;
+    /** userId → set of socket IDs (multi-device support) */
+    private userSockets;
+    /** socketId → userId (reverse lookup) */
+    private socketUser;
+    /** userId → set of conversation IDs the user has joined */
+    private userConversations;
+    /** userId → public key bundle for E2E encryption */
+    private keyBundles;
+    /** userId → rate limit tracking */
+    private rateLimits;
+    /** conversationId → set of user IDs currently in the room */
+    private conversationMembers;
+    /** Configurable typing timeout in ms */
+    typingTimeoutMs: number;
+    /** Max call age before auto-cleanup (1 hour) */
+    private static CALL_TTL_MS;
+    constructor();
+    mapUserSocket(userId: string, socketId: string): void;
+    unmapUserSocket(socketId: string): string | undefined;
+    getSocketsForUser(userId: string): Set<string>;
+    getUserForSocket(socketId: string): string | undefined;
+    isUserOnline(userId: string): boolean;
+    joinConversation(userId: string, conversationId: string): void;
+    leaveConversation(userId: string, conversationId: string): void;
+    getUserConversations(userId: string): Set<string>;
+    setPresence(userId: string, status: PresenceStatus): PresenceEntry;
+    getPresence(userId: string): PresenceEntry | undefined;
+    removePresence(userId: string): void;
+    setTyping(conversationId: string, userId: string, onExpire: () => void): void;
+    clearTyping(conversationId: string, userId: string): void;
+    clearAllTypingForUser(userId: string): string[];
+    getTypingUsers(conversationId: string): string[];
+    addCall(call: Call): void;
+    getCall(callId: string): Call | undefined;
+    updateCallState(callId: string, state: CallState, endReason?: CallEndReason): Call | undefined;
+    addCallParticipant(callId: string, participant: CallParticipant): Call | undefined;
+    removeCallParticipant(callId: string, userId: string): Call | undefined;
+    removeCall(callId: string): void;
+    getActiveCallForUser(userId: string): Call | undefined;
+    addConversationMember(conversationId: string, userId: string): void;
+    removeConversationMember(conversationId: string, userId: string): void;
+    getConversationMembers(conversationId: string): Set<string>;
+    removeUserFromAllConversations(userId: string): string[];
+    setKeyBundle(userId: string, bundle: KeyBundle): void;
+    getKeyBundle(userId: string): KeyBundle | undefined;
+    /** Pop one one-time pre-key (consumed once per session setup). Returns undefined if depleted. */
+    popOneTimePreKey(userId: string): PreKey | undefined;
+    /** Check how many one-time pre-keys remain */
+    getOneTimePreKeyCount(userId: string): number;
+    removeKeyBundle(userId: string): void;
+    /**
+     * Check whether a user is rate-limited. If not, records the message timestamp.
+     * Returns true if the message is allowed, false if rate-limited.
+     */
+    checkRateLimit(userId: string, config: RateLimitConfig): boolean;
+}
+export declare function useCommunicationStore(): CommunicationStore;

package/dist/communication/store.js

@@ -0,0 +1,289 @@
+// ── CommunicationStore ────────────────────────────────────────────
+const DEFAULT_TYPING_TIMEOUT_MS = 5000;
+export class CommunicationStore {
+    /** Max call age before auto-cleanup (1 hour) */
+    static { this.CALL_TTL_MS = 60 * 60 * 1000; }
+    constructor() {
+        /** userId → presence info */
+        this.presence = new Map();
+        /** conversationId → map of userId → typing timer */
+        this.typing = new Map();
+        /** callId → active call */
+        this.calls = new Map();
+        /** userId → set of socket IDs (multi-device support) */
+        this.userSockets = new Map();
+        /** socketId → userId (reverse lookup) */
+        this.socketUser = new Map();
+        /** userId → set of conversation IDs the user has joined */
+        this.userConversations = new Map();
+        /** userId → public key bundle for E2E encryption */
+        this.keyBundles = new Map();
+        /** userId → rate limit tracking */
+        this.rateLimits = new Map();
+        /** conversationId → set of user IDs currently in the room */
+        this.conversationMembers = new Map();
+        /** Configurable typing timeout in ms */
+        this.typingTimeoutMs = DEFAULT_TYPING_TIMEOUT_MS;
+        // Periodically clean up stale calls that were never properly ended
+        setInterval(() => {
+            const now = Date.now();
+            for (const [id, call] of this.calls) {
+                const startedAt = call.startedAt ? new Date(call.startedAt).getTime() : 0;
+                if (now - startedAt > CommunicationStore.CALL_TTL_MS) {
+                    this.calls.delete(id);
+                }
+            }
+        }, 5 * 60 * 1000).unref(); // every 5 min, unref so it doesn't keep process alive
+    }
+    // ── User-Socket Mapping ───────────────────────────────────────
+    mapUserSocket(userId, socketId) {
+        let sockets = this.userSockets.get(userId);
+        if (!sockets) {
+            sockets = new Set();
+            this.userSockets.set(userId, sockets);
+        }
+        sockets.add(socketId);
+        this.socketUser.set(socketId, userId);
+    }
+    unmapUserSocket(socketId) {
+        const userId = this.socketUser.get(socketId);
+        if (!userId)
+            return undefined;
+        this.socketUser.delete(socketId);
+        const sockets = this.userSockets.get(userId);
+        if (sockets) {
+            sockets.delete(socketId);
+            if (sockets.size === 0)
+                this.userSockets.delete(userId);
+        }
+        return userId;
+    }
+    getSocketsForUser(userId) {
+        return this.userSockets.get(userId) || new Set();
+    }
+    getUserForSocket(socketId) {
+        return this.socketUser.get(socketId);
+    }
+    isUserOnline(userId) {
+        const sockets = this.userSockets.get(userId);
+        return !!sockets && sockets.size > 0;
+    }
+    // ── Conversation Membership ────────────────────────────────────
+    joinConversation(userId, conversationId) {
+        let convs = this.userConversations.get(userId);
+        if (!convs) {
+            convs = new Set();
+            this.userConversations.set(userId, convs);
+        }
+        convs.add(conversationId);
+    }
+    leaveConversation(userId, conversationId) {
+        const convs = this.userConversations.get(userId);
+        if (!convs)
+            return;
+        convs.delete(conversationId);
+        if (convs.size === 0)
+            this.userConversations.delete(userId);
+    }
+    getUserConversations(userId) {
+        return this.userConversations.get(userId) || new Set();
+    }
+    // ── Presence ──────────────────────────────────────────────────
+    setPresence(userId, status) {
+        const existing = this.presence.get(userId);
+        const entry = {
+            userId,
+            status,
+            lastSeen: new Date().toISOString(),
+            socketIds: existing?.socketIds || this.getSocketsForUser(userId),
+        };
+        this.presence.set(userId, entry);
+        return entry;
+    }
+    getPresence(userId) {
+        return this.presence.get(userId);
+    }
+    removePresence(userId) {
+        this.presence.delete(userId);
+    }
+    // ── Typing ────────────────────────────────────────────────────
+    setTyping(conversationId, userId, onExpire) {
+        let convTyping = this.typing.get(conversationId);
+        if (!convTyping) {
+            convTyping = new Map();
+            this.typing.set(conversationId, convTyping);
+        }
+        const existing = convTyping.get(userId);
+        if (existing)
+            clearTimeout(existing.timer);
+        const timer = setTimeout(() => {
+            this.clearTyping(conversationId, userId);
+            onExpire();
+        }, this.typingTimeoutMs);
+        convTyping.set(userId, { userId, timer });
+    }
+    clearTyping(conversationId, userId) {
+        const convTyping = this.typing.get(conversationId);
+        if (!convTyping)
+            return;
+        const entry = convTyping.get(userId);
+        if (entry) {
+            clearTimeout(entry.timer);
+            convTyping.delete(userId);
+        }
+        if (convTyping.size === 0)
+            this.typing.delete(conversationId);
+    }
+    clearAllTypingForUser(userId) {
+        const cleared = [];
+        for (const [convId, convTyping] of this.typing) {
+            if (convTyping.has(userId)) {
+                const entry = convTyping.get(userId);
+                clearTimeout(entry.timer);
+                convTyping.delete(userId);
+                cleared.push(convId);
+            }
+            if (convTyping.size === 0)
+                this.typing.delete(convId);
+        }
+        return cleared;
+    }
+    getTypingUsers(conversationId) {
+        const convTyping = this.typing.get(conversationId);
+        if (!convTyping)
+            return [];
+        return Array.from(convTyping.keys());
+    }
+    // ── Calls ─────────────────────────────────────────────────────
+    addCall(call) {
+        this.calls.set(call.id, call);
+    }
+    getCall(callId) {
+        return this.calls.get(callId);
+    }
+    updateCallState(callId, state, endReason) {
+        const call = this.calls.get(callId);
+        if (!call)
+            return undefined;
+        call.state = state;
+        if (endReason)
+            call.endReason = endReason;
+        if (state === 'connected' && !call.answeredAt)
+            call.answeredAt = new Date().toISOString();
+        if (state === 'ended')
+            call.endedAt = new Date().toISOString();
+        return call;
+    }
+    addCallParticipant(callId, participant) {
+        const call = this.calls.get(callId);
+        if (!call)
+            return undefined;
+        const existing = call.participants.findIndex(p => p.userId === participant.userId);
+        if (existing >= 0)
+            call.participants[existing] = participant;
+        else
+            call.participants.push(participant);
+        return call;
+    }
+    removeCallParticipant(callId, userId) {
+        const call = this.calls.get(callId);
+        if (!call)
+            return undefined;
+        call.participants = call.participants.filter(p => p.userId !== userId);
+        return call;
+    }
+    removeCall(callId) {
+        this.calls.delete(callId);
+    }
+    getActiveCallForUser(userId) {
+        for (const call of this.calls.values()) {
+            if (call.state === 'ended')
+                continue;
+            if (call.callerId === userId || call.calleeIds.includes(userId))
+                return call;
+        }
+        return undefined;
+    }
+    // ── Conversation Membership ─────────────────────────────────────
+    addConversationMember(conversationId, userId) {
+        let members = this.conversationMembers.get(conversationId);
+        if (!members) {
+            members = new Set();
+            this.conversationMembers.set(conversationId, members);
+        }
+        members.add(userId);
+    }
+    removeConversationMember(conversationId, userId) {
+        const members = this.conversationMembers.get(conversationId);
+        if (!members)
+            return;
+        members.delete(userId);
+        if (members.size === 0)
+            this.conversationMembers.delete(conversationId);
+    }
+    getConversationMembers(conversationId) {
+        return this.conversationMembers.get(conversationId) || new Set();
+    }
+    removeUserFromAllConversations(userId) {
+        const removed = [];
+        for (const [convId, members] of this.conversationMembers) {
+            if (members.has(userId)) {
+                members.delete(userId);
+                removed.push(convId);
+            }
+            if (members.size === 0)
+                this.conversationMembers.delete(convId);
+        }
+        return removed;
+    }
+    // ── E2E Encryption Key Bundles ──────────────────────────────────
+    setKeyBundle(userId, bundle) {
+        this.keyBundles.set(userId, bundle);
+    }
+    getKeyBundle(userId) {
+        return this.keyBundles.get(userId);
+    }
+    /** Pop one one-time pre-key (consumed once per session setup). Returns undefined if depleted. */
+    popOneTimePreKey(userId) {
+        const bundle = this.keyBundles.get(userId);
+        if (!bundle || bundle.oneTimePreKeys.length === 0)
+            return undefined;
+        return bundle.oneTimePreKeys.shift();
+    }
+    /** Check how many one-time pre-keys remain */
+    getOneTimePreKeyCount(userId) {
+        const bundle = this.keyBundles.get(userId);
+        return bundle?.oneTimePreKeys.length || 0;
+    }
+    removeKeyBundle(userId) {
+        this.keyBundles.delete(userId);
+    }
+    // ── Rate Limiting ──────────────────────────────────────────────
+    /**
+     * Check whether a user is rate-limited. If not, records the message timestamp.
+     * Returns true if the message is allowed, false if rate-limited.
+     */
+    checkRateLimit(userId, config) {
+        const now = Date.now();
+        const windowStart = now - config.windowSeconds * 1000;
+        let entry = this.rateLimits.get(userId);
+        if (!entry) {
+            entry = { timestamps: [] };
+            this.rateLimits.set(userId, entry);
+        }
+        // Prune timestamps outside the current window
+        entry.timestamps = entry.timestamps.filter(t => t > windowStart);
+        if (entry.timestamps.length >= config.maxMessages) {
+            return false;
+        }
+        entry.timestamps.push(now);
+        return true;
+    }
+}
+// ── Singleton ─────────────────────────────────────────────────────
+let _instance = null;
+export function useCommunicationStore() {
+    if (!_instance)
+        _instance = new CommunicationStore();
+    return _instance;
+}