@vibesdotdev/session 0.0.0-stage → 1.0.0-rc.2

package/dist/testing/harness/transport-mocks.js

@@ -0,0 +1,809 @@
+/**
+ * Transport-Specific Mocks
+ *
+ * Context-level mocks for MCP transports (stdio and HTTP).
+ * These mocks simulate what the MCP adapter produces without the full protocol stack.
+ */
+/**
+ * Create a mock session manager for testing
+ */
+export function createMockSessionManager() {
+    const todos = new Map();
+    const sessions = new Map();
+    const participants = new Map();
+    const participantExtras = new Map();
+    const scratchpad = new Map();
+    const jobRefs = new Map();
+    const messages = new Map();
+    let activeSessionId = null;
+    const createId = () => crypto.randomUUID();
+    let defaultSessionId = null;
+    const participantSessionMap = new Map();
+    const normalizeSessionStatus = (status) => {
+        if (status === 'paused' || status === 'archived')
+            return status;
+        return 'active';
+    };
+    const manager = {
+        todos,
+        sessions,
+        participants,
+        scratchpad,
+        activeSessionId,
+        // Session methods
+        async createSession(data) {
+            const session = {
+                id: createId(),
+                title: data.title || 'Test Session',
+                description: data.description,
+                status: normalizeSessionStatus(data.status),
+                scope: 'project',
+                ownerParticipant: data.ownerParticipant || 'test-participant',
+                metadata: {},
+                tags: data.tags || [],
+                createdAt: new Date(),
+                updatedAt: new Date(),
+                lastActivityAt: new Date()
+            };
+            sessions.set(session.id, session);
+            activeSessionId = session.id;
+            return session;
+        },
+        async getSession(id) {
+            return sessions.get(id) ?? null;
+        },
+        async listSessions(filters) {
+            return Array.from(sessions.values()).filter((s) => {
+                if (filters?.status && s.status !== filters.status)
+                    return false;
+                return true;
+            });
+        },
+        async countSessions(filters) {
+            // True count over the same filter listSessions uses (ledger L-11).
+            return Array.from(sessions.values()).filter((s) => {
+                if (filters?.status && s.status !== filters.status)
+                    return false;
+                return true;
+            }).length;
+        },
+        async updateSession(id, data) {
+            const session = sessions.get(id);
+            if (session) {
+                Object.assign(session, data, { updatedAt: new Date() });
+            }
+        },
+        async archiveSession(id) {
+            const session = sessions.get(id);
+            if (session) {
+                session.status = 'archived';
+                session.archivedAt = new Date();
+                if (activeSessionId === id) {
+                    activeSessionId = null;
+                }
+            }
+        },
+        async pauseSession(id) {
+            const session = sessions.get(id);
+            if (session) {
+                session.status = 'paused';
+                session.pausedAt = new Date();
+                if (activeSessionId === id)
+                    activeSessionId = null;
+            }
+        },
+        async pauseActiveSession() {
+            if (activeSessionId) {
+                await this.pauseSession(activeSessionId);
+            }
+        },
+        async openSessionForWork(id) {
+            const session = sessions.get(id);
+            if (!session)
+                throw new Error(`Session ${id} not found`);
+            if (session.status === 'archived') {
+                throw new Error(`Session ${id} is archived; resume it explicitly before writing to it.`);
+            }
+            if (session.status === 'paused') {
+                session.status = 'active';
+                activeSessionId = id;
+            }
+            return session;
+        },
+        async resumeSession(id) {
+            const session = sessions.get(id);
+            if (session) {
+                session.status = 'active';
+                session.pausedAt = undefined;
+                activeSessionId = id;
+            }
+        },
+        async getActiveSession() {
+            return activeSessionId ? (sessions.get(activeSessionId) ?? null) : null;
+        },
+        async setParticipantActiveSession(_participantId, sessionId) {
+            activeSessionId = sessionId;
+            participantSessionMap.set(_participantId, sessionId);
+        },
+        async getDefaultActiveSession() {
+            return defaultSessionId;
+        },
+        async setDefaultActiveSession(id) {
+            defaultSessionId = id;
+        },
+        async getParticipantActiveSession(participantId) {
+            return participantSessionMap.get(participantId) ?? null;
+        },
+        async ensureSessionActive(sessionId) {
+            const session = sessions.get(sessionId);
+            if (!session) {
+                throw new Error(`Session ${sessionId} not found`);
+            }
+            if (session.status !== 'active') {
+                throw new Error(`Session ${sessionId} is ${session.status}; resume it explicitly before writing to it.`);
+            }
+            return session;
+        },
+        async ensureParticipantSession(participantId) {
+            const mappedId = participantSessionMap.get(participantId);
+            if (mappedId) {
+                const mapped = sessions.get(mappedId);
+                if (mapped?.status === 'active')
+                    return mapped;
+                participantSessionMap.delete(participantId);
+                return null;
+            }
+            return activeSessionId ? (sessions.get(activeSessionId) ?? null) : null;
+        },
+        async deleteSession(id) {
+            sessions.delete(id);
+            if (activeSessionId === id)
+                activeSessionId = null;
+            if (defaultSessionId === id)
+                defaultSessionId = null;
+            todos.delete(id);
+            scratchpad.delete(id);
+        },
+        async getSessionStats(sessionId) {
+            // Mirrors the real SessionManager contract: every figure is a true
+            // count; `blocked` is the todo's own explicit status, while
+            // dependency-incomplete rows are reported as awaitingDependencies.
+            const sessionTodos = todos.get(sessionId) || [];
+            const todosByStatus = (status) => sessionTodos.filter((t) => t.status === status).length;
+            const statusById = new Map(sessionTodos.map((t) => [t.id, t.status]));
+            const awaitingDependencies = sessionTodos.filter((t) => {
+                if (t.status === 'completed' || t.status === 'cancelled')
+                    return false;
+                if (!t.dependencies || t.dependencies.length === 0)
+                    return false;
+                return t.dependencies.some((depId) => {
+                    const depStatus = statusById.get(depId);
+                    return depStatus !== undefined && depStatus !== 'completed';
+                });
+            }).length;
+            const sessionScratchpad = scratchpad.get(sessionId);
+            const byType = {};
+            for (const entry of sessionScratchpad?.values() ?? []) {
+                byType[entry.contentType] = (byType[entry.contentType] || 0) + 1;
+            }
+            const sessionJobs = jobRefs.get(sessionId) || [];
+            const jobsByStatus = (status) => sessionJobs.filter((j) => j.status === status).length;
+            const sessionMessages = messages.get(sessionId) || [];
+            return {
+                todos: {
+                    total: sessionTodos.length,
+                    completed: todosByStatus('completed'),
+                    active: todosByStatus('in_progress'),
+                    blocked: todosByStatus('blocked'),
+                    awaitingDependencies,
+                    pending: todosByStatus('pending')
+                },
+                scratchpad: { total: sessionScratchpad?.size ?? 0, byType },
+                jobs: {
+                    total: sessionJobs.length,
+                    completed: jobsByStatus('completed'),
+                    pending: jobsByStatus('pending'),
+                    processing: jobsByStatus('processing'),
+                    failed: jobsByStatus('failed')
+                },
+                messages: {
+                    total: sessionMessages.length,
+                    unread: sessionMessages.filter((m) => !m.isRead).length
+                }
+            };
+        },
+        // Todo methods
+        async createTodo(sessionId, data) {
+            const todo = {
+                id: createId(),
+                sessionId,
+                content: data.content,
+                activeForm: data.activeForm ?? data.content,
+                status: data.status ?? 'pending',
+                priority: data.priority ?? 'medium',
+                parentId: data.parentId,
+                dependencies: data.dependencies ?? [],
+                assignedParticipant: data.assignedParticipant,
+                estimatedMinutes: data.estimatedMinutes,
+                actualMinutes: data.actualMinutes,
+                tags: data.tags ?? [],
+                metadata: data.metadata ?? {},
+                createdAt: new Date(),
+                updatedAt: new Date()
+            };
+            const sessionTodos = todos.get(sessionId) || [];
+            sessionTodos.push(todo);
+            todos.set(sessionId, sessionTodos);
+            return todo;
+        },
+        listTodos(sessionId, filters) {
+            const sessionTodos = todos.get(sessionId) || [];
+            const matching = sessionTodos.filter((t) => {
+                if (filters?.status && t.status !== filters.status)
+                    return false;
+                if (filters?.priority && t.priority !== filters.priority)
+                    return false;
+                if (filters?.parentId !== undefined && t.parentId !== filters.parentId)
+                    return false;
+                return true;
+            });
+            // Mirror the real manager: lists page (default 100)…
+            const offset = filters?.offset ?? 0;
+            const limit = filters?.limit ?? 100;
+            return Promise.resolve(matching.slice(offset, offset + limit));
+        },
+        async countTodos(sessionId, filters) {
+            // …while counts report ALL matching rows, ignoring pagination.
+            const sessionTodos = todos.get(sessionId) || [];
+            return sessionTodos.filter((t) => {
+                if (filters?.status && t.status !== filters.status)
+                    return false;
+                if (filters?.priority && t.priority !== filters.priority)
+                    return false;
+                if (filters?.parentId !== undefined && t.parentId !== filters.parentId)
+                    return false;
+                return true;
+            }).length;
+        },
+        async getTodo(todoId) {
+            for (const sessionTodos of todos.values()) {
+                const todo = sessionTodos.find((t) => t.id === todoId);
+                if (todo)
+                    return todo;
+            }
+            return null;
+        },
+        async getTodoWithComputed(todoId) {
+            const todo = await this.getTodo(todoId);
+            if (!todo)
+                return null;
+            return {
+                ...todo,
+                isBlocked: false,
+                blockedBy: [],
+                subtaskStats: { total: 0, completed: 0 }
+            };
+        },
+        async updateTodo(todoId, data) {
+            for (const sessionTodos of todos.values()) {
+                const todo = sessionTodos.find((t) => t.id === todoId);
+                if (todo) {
+                    Object.assign(todo, data, { updatedAt: new Date() });
+                    if (data.status === 'completed') {
+                        todo.completedAt = new Date();
+                    }
+                    break;
+                }
+            }
+        },
+        async deleteTodo(todoId) {
+            for (const [sessionId, sessionTodos] of todos.entries()) {
+                todos.set(sessionId, sessionTodos.filter((t) => t.id !== todoId));
+            }
+        },
+        // Participant methods
+        async registerParticipant(data) {
+            const participantId = data.participantId || createId();
+            const participant = {
+                participantId,
+                name: data.name,
+                role: data.role,
+                capabilities: data.capabilities ?? [],
+                preferences: data.preferences ?? {},
+                metadata: data.metadata ?? {},
+                createdAt: new Date(),
+                lastSeenAt: new Date()
+            };
+            participants.set(participant.participantId, participant);
+            participantExtras.set(participant.participantId, {
+                slug: data.slug,
+                type: data.type
+            });
+            return {
+                ...participant,
+                ...participantExtras.get(participant.participantId)
+            };
+        },
+        async getParticipant(id) {
+            const participant = participants.get(id);
+            if (!participant)
+                return null;
+            return { ...participant, ...participantExtras.get(id) };
+        },
+        async findParticipantBySlug(slug) {
+            for (const [participantId, extras] of participantExtras.entries()) {
+                if (extras.slug === slug) {
+                    const participant = participants.get(participantId);
+                    if (participant)
+                        return { ...participant, slug };
+                }
+            }
+            return null;
+        },
+        async updateParticipant(id, data) {
+            const participant = participants.get(id);
+            if (participant) {
+                Object.assign(participant, data);
+            }
+        },
+        async listParticipants(filters) {
+            let all = Array.from(participants.values());
+            if (filters?.role) {
+                all = all.filter((p) => p.role === filters.role);
+            }
+            if (filters?.search) {
+                const q = filters.search.toLowerCase();
+                all = all.filter((p) => p.name.toLowerCase().includes(q) ||
+                    p.participantId.toLowerCase().includes(q));
+            }
+            const offset = filters?.offset ?? 0;
+            const limit = filters?.limit ?? 200;
+            return all.slice(offset, offset + limit);
+        },
+        // Scratchpad methods
+        async writeScratchpad(sessionId, data) {
+            const sessionScratchpad = scratchpad.get(sessionId) || new Map();
+            // Match real SessionManager semantics: a rewrite of an existing key
+            // replaces the entry in place (same id, same createdAt); every other
+            // field is reset from the incoming payload.
+            const existing = sessionScratchpad.get(data.key);
+            const entry = {
+                id: existing?.id ?? createId(),
+                sessionId,
+                key: data.key,
+                content: data.content,
+                contentType: data.contentType ?? 'text',
+                language: data.language,
+                tags: data.tags ?? [],
+                metadata: data.metadata ?? {},
+                expiresAt: data.expiresAt,
+                createdAt: existing?.createdAt ?? new Date(),
+                updatedAt: new Date()
+            };
+            sessionScratchpad.set(data.key, entry);
+            scratchpad.set(sessionId, sessionScratchpad);
+            return entry;
+        },
+        async readScratchpad(sessionId, key) {
+            const sessionScratchpad = scratchpad.get(sessionId);
+            return sessionScratchpad?.get(key) ?? null;
+        },
+        async deleteScratchpadEntry(id) {
+            for (const sessionScratchpad of scratchpad.values()) {
+                for (const [key, entry] of sessionScratchpad.entries()) {
+                    if (entry.id === id) {
+                        sessionScratchpad.delete(key);
+                        return;
+                    }
+                }
+            }
+        },
+        listScratchpad(sessionId, filters) {
+            const sessionScratchpad = scratchpad.get(sessionId);
+            if (!sessionScratchpad)
+                return Promise.resolve([]);
+            const matching = Array.from(sessionScratchpad.values()).filter((e) => {
+                if (filters?.contentType && e.contentType !== filters.contentType)
+                    return false;
+                return true;
+            });
+            // Mirror the real manager: lists page (default 100)…
+            const offset = filters?.offset ?? 0;
+            const limit = filters?.limit ?? 100;
+            return Promise.resolve(matching
+                .slice(offset, offset + limit)
+                .map((e) => ({ ...e, contentLength: e.content.length })));
+        },
+        async countScratchpad(sessionId, filters) {
+            // …while counts report ALL matching rows, ignoring pagination.
+            const sessionScratchpad = scratchpad.get(sessionId);
+            if (!sessionScratchpad)
+                return 0;
+            return Array.from(sessionScratchpad.values()).filter((e) => {
+                if (filters?.contentType && e.contentType !== filters.contentType)
+                    return false;
+                return true;
+            }).length;
+        },
+        searchScratchpad(sessionId, query, options) {
+            const sessionScratchpad = scratchpad.get(sessionId);
+            if (!sessionScratchpad)
+                return Promise.resolve({ items: [], total: 0 });
+            const results = Array.from(sessionScratchpad.values()).filter((e) => e.key.includes(query) || e.content.includes(query));
+            // Mirror the real manager: items = one page, total = true match count.
+            return Promise.resolve({
+                items: results
+                    .slice(0, options?.limit || 50)
+                    .map((e) => ({ ...e, contentLength: e.content.length })),
+                total: results.length
+            });
+        },
+        // Job refs
+        async addJobRef(sessionId, data) {
+            const ref = {
+                id: createId(),
+                jobId: data.jobId,
+                queueName: data.queueName,
+                jobType: data.jobType,
+                description: data.description,
+                status: data.status || 'pending',
+                createdAt: new Date()
+            };
+            const refs = jobRefs.get(sessionId) || [];
+            refs.push(ref);
+            jobRefs.set(sessionId, refs);
+            return ref;
+        },
+        getJobRefs(sessionId, filters) {
+            const refs = jobRefs.get(sessionId) || [];
+            return Promise.resolve(refs.filter((r) => {
+                if (filters?.status && r.status !== filters.status)
+                    return false;
+                if (filters?.queueName && r.queueName !== filters.queueName)
+                    return false;
+                return true;
+            }));
+        },
+        // Messages
+        async sendMessage(sessionId, data) {
+            const message = {
+                id: createId(),
+                sessionId,
+                fromParticipant: data.fromParticipant,
+                toParticipant: data.toParticipant,
+                messageType: data.messageType || 'notification',
+                content: data.content,
+                isRead: false,
+                createdAt: new Date()
+            };
+            const sessionMessages = messages.get(sessionId) || [];
+            sessionMessages.push(message);
+            messages.set(sessionId, sessionMessages);
+            return message;
+        },
+        async getMessages(sessionId, filters) {
+            const sessionMessages = messages.get(sessionId) || [];
+            return sessionMessages.filter((m) => {
+                if (filters?.fromParticipant && m.fromParticipant !== filters.fromParticipant)
+                    return false;
+                if (filters?.toParticipant && m.toParticipant !== filters.toParticipant)
+                    return false;
+                if (filters?.isRead !== undefined && m.isRead !== filters.isRead)
+                    return false;
+                return true;
+            });
+        },
+        async countMessages(sessionId, filters) {
+            // True count over the same filter getMessages uses, ignoring pagination
+            // (ledger L-11).
+            const sessionMessages = messages.get(sessionId) || [];
+            return sessionMessages.filter((m) => {
+                if (filters?.fromParticipant && m.fromParticipant !== filters.fromParticipant)
+                    return false;
+                if (filters?.toParticipant && m.toParticipant !== filters.toParticipant)
+                    return false;
+                if (filters?.isRead !== undefined && m.isRead !== filters.isRead)
+                    return false;
+                return true;
+            }).length;
+        },
+        async getMessage(messageId) {
+            for (const sessionMessages of messages.values()) {
+                const msg = sessionMessages.find((m) => m.id === messageId);
+                if (msg)
+                    return msg;
+            }
+            return null;
+        },
+        // The mock does not track connection→participant bindings; caller identity in
+        // unit tests is asserted via explicit participantId. Returns null accordingly.
+        async getParticipantByConnection() {
+            return null;
+        },
+        async markMessageRead(messageId) {
+            for (const sessionMessages of messages.values()) {
+                const msg = sessionMessages.find((m) => m.id === messageId);
+                if (msg) {
+                    msg.isRead = true;
+                    msg.readAt = new Date();
+                    break;
+                }
+            }
+        },
+        async markAllMessagesRead(sessionId, participantId) {
+            const sessionMessages = messages.get(sessionId) || [];
+            let count = 0;
+            for (const msg of sessionMessages) {
+                if (msg.toParticipant === participantId && !msg.isRead) {
+                    msg.isRead = true;
+                    msg.readAt = new Date();
+                    count++;
+                }
+            }
+            return count;
+        },
+        async deleteMessage(messageId) {
+            for (const [sessionId, sessionMessages] of messages.entries()) {
+                messages.set(sessionId, sessionMessages.filter((m) => m.id !== messageId));
+            }
+        },
+        // Knowledge refs
+        async addKnowledgeRef(_sessionId, _data) {
+            return { id: createId() };
+        },
+        // Search
+        async searchSessions(query, filters) {
+            return Array.from(sessions.values()).filter((s) => {
+                if (filters?.status && s.status !== filters.status)
+                    return false;
+                return s.title.includes(query) || s.description?.includes(query);
+            });
+        },
+        async searchSessionsPaged(query, filters) {
+            const matches = await manager.searchSessions(query, filters);
+            const offset = filters?.offset ?? 0;
+            const limit = filters?.limit ?? 100;
+            return {
+                results: matches.slice(offset, offset + limit),
+                total: matches.length
+            };
+        },
+        // Presence (no-ops)
+        async recordPresence(_data) { },
+        async removePresence(_id) { },
+        async updateHeartbeat(_id) { },
+        // Reset
+        reset() {
+            todos.clear();
+            sessions.clear();
+            participants.clear();
+            scratchpad.clear();
+            jobRefs.clear();
+            messages.clear();
+            activeSessionId = null;
+            defaultSessionId = null;
+            participantSessionMap.clear();
+        }
+    };
+    return manager;
+}
+// Transport Mock Factories
+/**
+ * Create a mock for stdio transport
+ * Stdio has a single global context (no session isolation)
+ */
+export function createStdioTransportMock() {
+    const connectionId = `stdio-${crypto.randomUUID().slice(0, 8)}`;
+    return {
+        sessionId: '', // Empty for stdio (global context)
+        connectionId,
+        transport: 'stdio',
+        clientInfo: {
+            name: 'test-client',
+            version: '1.0.0',
+            connectionId,
+            transport: 'stdio'
+        },
+        connectionState: {
+            connectionId,
+            transport: 'stdio',
+            agentId: null,
+            agentSlug: null
+        }
+    };
+}
+/**
+ * Create a mock for HTTP transport
+ * HTTP has per-session isolation via mcpSessionId
+ */
+export function createHttpTransportMock(sessionId) {
+    const mcpSessionId = sessionId || crypto.randomUUID();
+    const connectionId = `http-${crypto.randomUUID().slice(0, 8)}`;
+    const httpPeer = {
+        remoteAddress: '127.0.0.1',
+        remotePort: 54321,
+        userAgent: 'TestClient/1.0',
+        origin: 'http://localhost:3000'
+    };
+    return {
+        sessionId: mcpSessionId,
+        connectionId,
+        transport: 'http',
+        clientInfo: {
+            name: 'test-client',
+            version: '1.0.0',
+            connectionId,
+            transport: 'http',
+            httpPeer
+        },
+        connectionState: {
+            connectionId,
+            sessionId: mcpSessionId,
+            transport: 'http',
+            agentId: null,
+            agentSlug: null,
+            httpPeer
+        }
+    };
+}
+/**
+ * Create a mock session registry for isolation testing
+ */
+export function createSessionRegistryMock() {
+    const sessions = new Map();
+    // Global context for stdio fallback
+    const globalContext = {
+        // SAFETY: Session manager is initialized lazily for fallback stdio contexts
+        sessionManager: null,
+        // SAFETY: Session state is initialized lazily for fallback stdio contexts
+        sessionState: null,
+        participantCache: new Map()
+    };
+    function createContext(mcpSessionId) {
+        return {
+            mcpSessionId,
+            sessionManager: createMockSessionManager(),
+            sessionState: null,
+            clientInfo: null,
+            connectionState: null,
+            participantCache: new Map(),
+            createdAt: Date.now(),
+            lastActivityAt: Date.now()
+        };
+    }
+    const registry = {
+        sessions,
+        getOrCreate(mcpSessionId) {
+            if (!mcpSessionId)
+                return null;
+            let ctx = sessions.get(mcpSessionId);
+            if (!ctx) {
+                ctx = createContext(mcpSessionId);
+                sessions.set(mcpSessionId, ctx);
+            }
+            ctx.lastActivityAt = Date.now();
+            return ctx;
+        },
+        get(mcpSessionId) {
+            if (!mcpSessionId)
+                return null;
+            const ctx = sessions.get(mcpSessionId);
+            if (ctx)
+                ctx.lastActivityAt = Date.now();
+            return ctx ?? null;
+        },
+        has(mcpSessionId) {
+            return sessions.has(mcpSessionId);
+        },
+        remove(mcpSessionId) {
+            return sessions.delete(mcpSessionId);
+        },
+        getSessionManager(mcpSessionId) {
+            const ctx = this.get(mcpSessionId);
+            if (ctx)
+                return ctx.sessionManager;
+            return globalContext.sessionManager;
+        },
+        setSessionManager(mcpSessionId, manager) {
+            const ctx = this.getOrCreate(mcpSessionId);
+            if (ctx) {
+                ctx.sessionManager = manager;
+            }
+            else {
+                globalContext.sessionManager = manager;
+            }
+        },
+        getSessionState(mcpSessionId) {
+            const ctx = this.get(mcpSessionId);
+            if (ctx)
+                return ctx.sessionState;
+            return globalContext.sessionState;
+        },
+        setSessionState(mcpSessionId, state) {
+            const ctx = this.getOrCreate(mcpSessionId);
+            if (ctx) {
+                ctx.sessionState = state;
+            }
+            else {
+                globalContext.sessionState = state;
+            }
+        },
+        getClientInfo(mcpSessionId) {
+            const ctx = this.get(mcpSessionId);
+            return ctx?.clientInfo ?? null;
+        },
+        setClientInfo(mcpSessionId, info) {
+            const ctx = this.getOrCreate(mcpSessionId);
+            if (ctx)
+                ctx.clientInfo = info;
+        },
+        getConnectionState(mcpSessionId) {
+            const ctx = this.get(mcpSessionId);
+            return ctx?.connectionState ?? null;
+        },
+        setConnectionState(mcpSessionId, state) {
+            const ctx = this.getOrCreate(mcpSessionId);
+            if (ctx)
+                ctx.connectionState = state;
+        },
+        getParticipantCache(mcpSessionId) {
+            const ctx = this.get(mcpSessionId);
+            if (ctx)
+                return ctx.participantCache;
+            return globalContext.participantCache;
+        },
+        get size() {
+            return sessions.size;
+        },
+        cleanupExpired() {
+            // No-op for mock
+            return 0;
+        },
+        shutdown() {
+            sessions.clear();
+        },
+        reset() {
+            sessions.clear();
+            globalContext.sessionManager = null;
+            globalContext.sessionState = null;
+            globalContext.participantCache.clear();
+        }
+    };
+    function createIsolatedSession(id) {
+        const ctx = createContext(id);
+        sessions.set(id, ctx);
+        return ctx;
+    }
+    function assertNoLeakage(session1, session2) {
+        const ctx1 = sessions.get(session1);
+        const ctx2 = sessions.get(session2);
+        if (!ctx1 || !ctx2) {
+            throw new Error(`Missing session context: ${!ctx1 ? session1 : session2}`);
+        }
+        // Check session managers are different instances
+        if (ctx1.sessionManager === ctx2.sessionManager && ctx1.sessionManager !== null) {
+            throw new Error('Session managers should be isolated but share the same instance');
+        }
+        // Check participant caches are different instances
+        if (ctx1.participantCache === ctx2.participantCache) {
+            throw new Error('Participant caches should be isolated but share the same instance');
+        }
+        // Check no cross-session data
+        if (ctx1.sessionManager && ctx2.sessionManager) {
+            const todos1 = ctx1.sessionManager.todos;
+            const todos2 = ctx2.sessionManager.todos;
+            for (const [sessionId] of todos1) {
+                if (todos2.has(sessionId)) {
+                    throw new Error(`Session ${sessionId} found in both session managers - possible leakage`);
+                }
+            }
+        }
+    }
+    return {
+        registry,
+        globalContext,
+        createIsolatedSession,
+        assertNoLeakage
+    };
+}
+//# sourceMappingURL=transport-mocks.js.map