factory-factory 0.2.4 → 0.2.6

package/dist/src/backend/services/session-store.service.js

@@ -0,0 +1,732 @@
+import { createHash } from 'node:crypto';
+import { DEFAULT_CHAT_SETTINGS, MessageState, QUEUED_MESSAGE_ORDER_BASE, resolveSelectedModel, shouldPersistClaudeMessage, shouldSuppressDuplicateResultMessage, } from '../../shared/claude/index.js';
+import { createInitialSessionRuntimeState, } from '../../shared/session-runtime.js';
+import { SessionManager } from '../claude/index.js';
+import { chatConnectionService } from './chat-connection.service.js';
+import { createLogger } from './logger.service.js';
+import { sessionFileLogger } from './session-file-logger.service.js';
+const logger = createLogger('session-store-service');
+const MAX_QUEUE_SIZE = 100;
+function messageSort(a, b) {
+    return a.order - b.order;
+}
+class SessionStoreService {
+    stores = new Map();
+    summarizeAttachment(attachment) {
+        return {
+            id: attachment.id,
+            name: attachment.name,
+            type: attachment.type,
+            size: attachment.size,
+            ...(attachment.contentType ? { contentType: attachment.contentType } : {}),
+        };
+    }
+    normalizeTranscriptMessage(message) {
+        if (message.source === 'user') {
+            return {
+                source: 'user',
+                order: message.order,
+                text: message.text,
+                attachments: message.attachments?.map((attachment) => this.summarizeAttachment(attachment)),
+            };
+        }
+        return {
+            source: 'claude',
+            order: message.order,
+            message: message.message,
+        };
+    }
+    normalizeTranscript(messages) {
+        return messages.map((message) => this.normalizeTranscriptMessage(message));
+    }
+    logParityTrace(sessionId, data) {
+        sessionFileLogger.log(sessionId, 'INFO', {
+            type: 'parity_trace',
+            ...data,
+        });
+    }
+    getOrCreate(sessionId) {
+        let store = this.stores.get(sessionId);
+        if (!store) {
+            store = {
+                sessionId,
+                initialized: false,
+                hydratePromise: null,
+                hydratingKey: null,
+                hydratedKey: null,
+                hydrateGeneration: 0,
+                lastKnownProjectPath: null,
+                lastKnownClaudeSessionId: null,
+                transcript: [],
+                queue: [],
+                pendingInteractiveRequest: null,
+                runtime: createInitialSessionRuntimeState(),
+                nextOrder: 0,
+                lastHydratedAt: null,
+            };
+            this.stores.set(sessionId, store);
+        }
+        return store;
+    }
+    buildDeterministicHistoryId(historyMsg, index) {
+        const fingerprint = JSON.stringify({
+            index,
+            type: historyMsg.type,
+            timestamp: historyMsg.timestamp,
+            content: historyMsg.content,
+            toolName: 'toolName' in historyMsg ? (historyMsg.toolName ?? null) : null,
+            toolId: 'toolId' in historyMsg ? (historyMsg.toolId ?? null) : null,
+            toolInput: 'toolInput' in historyMsg ? (historyMsg.toolInput ?? null) : null,
+            isError: 'isError' in historyMsg ? (historyMsg.isError ?? false) : false,
+            attachments: historyMsg.attachments ?? null,
+            userToolResultContent: historyMsg.type === 'user_tool_result' ? historyMsg.content : null,
+        });
+        const digest = createHash('sha1').update(fingerprint).digest('hex').slice(0, 12);
+        return `history-${index}-${digest}`;
+    }
+    upsertTranscriptMessage(store, message) {
+        const idx = store.transcript.findIndex((m) => m.id === message.id);
+        if (idx >= 0) {
+            store.transcript[idx] = message;
+        }
+        else {
+            store.transcript.push(message);
+        }
+        store.transcript.sort(messageSort);
+    }
+    hasPersistedToolUseStart(store, toolUseId) {
+        return store.transcript.some((entry) => {
+            if (entry.source !== 'claude' || !entry.message || entry.message.type !== 'stream_event') {
+                return false;
+            }
+            const event = entry.message.event;
+            if (!event || event.type !== 'content_block_start') {
+                return false;
+            }
+            return event.content_block.type === 'tool_use' && event.content_block.id === toolUseId;
+        });
+    }
+    setNextOrderFromTranscript(store) {
+        let maxOrder = -1;
+        for (const message of store.transcript) {
+            if (message.order > maxOrder) {
+                maxOrder = message.order;
+            }
+        }
+        store.nextOrder = maxOrder + 1;
+    }
+    historyToClaudeMessage(msg) {
+        const assertNever = (value) => {
+            throw new Error(`Unhandled history message type: ${JSON.stringify(value)}`);
+        };
+        switch (msg.type) {
+            case 'user':
+                return {
+                    type: 'user',
+                    message: { role: 'user', content: msg.content },
+                };
+            case 'tool_use':
+                if (msg.toolName && msg.toolId) {
+                    return {
+                        type: 'stream_event',
+                        event: {
+                            type: 'content_block_start',
+                            index: 0,
+                            content_block: {
+                                type: 'tool_use',
+                                id: msg.toolId,
+                                name: msg.toolName,
+                                input: msg.toolInput || {},
+                            },
+                        },
+                    };
+                }
+                return {
+                    type: 'assistant',
+                    message: { role: 'assistant', content: [{ type: 'text', text: msg.content }] },
+                };
+            case 'tool_result': {
+                return {
+                    type: 'user',
+                    message: {
+                        role: 'user',
+                        content: [
+                            {
+                                type: 'tool_result',
+                                tool_use_id: msg.toolId || 'unknown',
+                                content: msg.content,
+                                ...(msg.isError !== undefined ? { is_error: msg.isError } : {}),
+                            },
+                        ],
+                    },
+                };
+            }
+            case 'user_tool_result':
+                return {
+                    type: 'user',
+                    message: {
+                        role: 'user',
+                        content: msg.content,
+                    },
+                };
+            case 'thinking':
+                return {
+                    type: 'stream_event',
+                    event: {
+                        type: 'content_block_start',
+                        index: 0,
+                        content_block: { type: 'thinking', thinking: msg.content },
+                    },
+                };
+            case 'assistant':
+                return {
+                    type: 'assistant',
+                    message: { role: 'assistant', content: [{ type: 'text', text: msg.content }] },
+                };
+        }
+        return assertNever(msg);
+    }
+    buildTranscriptFromHistory(history) {
+        const transcript = [];
+        let order = 0;
+        for (const [index, historyMsg] of history.entries()) {
+            const messageBaseId = historyMsg.uuid ?? this.buildDeterministicHistoryId(historyMsg, index);
+            const messageId = `${messageBaseId}-${order}`;
+            if (historyMsg.type === 'user') {
+                transcript.push({
+                    id: messageId,
+                    source: 'user',
+                    text: historyMsg.content,
+                    attachments: historyMsg.attachments,
+                    timestamp: historyMsg.timestamp,
+                    order,
+                });
+                order += 1;
+                continue;
+            }
+            if (historyMsg.type === 'assistant' ||
+                historyMsg.type === 'tool_use' ||
+                historyMsg.type === 'tool_result' ||
+                historyMsg.type === 'thinking' ||
+                historyMsg.type === 'user_tool_result') {
+                transcript.push({
+                    id: messageId,
+                    source: 'claude',
+                    message: this.historyToClaudeMessage(historyMsg),
+                    timestamp: historyMsg.timestamp,
+                    order,
+                });
+                order += 1;
+            }
+        }
+        return transcript;
+    }
+    buildSnapshotMessages(store) {
+        const snapshot = [...store.transcript];
+        store.queue.forEach((queued, index) => {
+            snapshot.push({
+                id: queued.id,
+                source: 'user',
+                text: queued.text,
+                attachments: queued.attachments,
+                timestamp: queued.timestamp,
+                order: QUEUED_MESSAGE_ORDER_BASE + index,
+            });
+        });
+        snapshot.sort(messageSort);
+        return snapshot;
+    }
+    forwardSnapshot(store, options) {
+        const snapshotMessages = this.buildSnapshotMessages(store);
+        const payload = {
+            type: 'session_snapshot',
+            messages: snapshotMessages,
+            queuedMessages: [...store.queue],
+            pendingInteractiveRequest: store.pendingInteractiveRequest,
+            sessionRuntime: store.runtime,
+            ...(options?.loadRequestId ? { loadRequestId: options.loadRequestId } : {}),
+        };
+        if (options?.includeParitySnapshot) {
+            this.logParityTrace(store.sessionId, {
+                path: 'snapshot',
+                reason: options.reason ?? 'manual_emit',
+                loadRequestId: options.loadRequestId ?? null,
+                queuedCount: store.queue.length,
+                snapshot: this.normalizeTranscript(snapshotMessages),
+            });
+        }
+        chatConnectionService.forwardToSession(store.sessionId, payload);
+    }
+    buildReplayEvents(store) {
+        const replayEvents = [
+            {
+                type: 'session_runtime_snapshot',
+                sessionRuntime: store.runtime,
+            },
+        ];
+        const transcript = [...store.transcript].sort(messageSort);
+        for (const message of transcript) {
+            if (message.source === 'user') {
+                replayEvents.push({
+                    type: 'message_state_changed',
+                    id: message.id,
+                    newState: MessageState.ACCEPTED,
+                    userMessage: {
+                        text: message.text ?? '',
+                        timestamp: message.timestamp,
+                        attachments: message.attachments,
+                        settings: {
+                            selectedModel: resolveSelectedModel(DEFAULT_CHAT_SETTINGS.selectedModel),
+                            thinkingEnabled: DEFAULT_CHAT_SETTINGS.thinkingEnabled,
+                            planModeEnabled: DEFAULT_CHAT_SETTINGS.planModeEnabled,
+                        },
+                        order: message.order,
+                    },
+                });
+                replayEvents.push({
+                    type: 'message_state_changed',
+                    id: message.id,
+                    newState: MessageState.COMMITTED,
+                });
+                continue;
+            }
+            if (message.message) {
+                replayEvents.push({
+                    type: 'claude_message',
+                    data: message.message,
+                    order: message.order,
+                });
+            }
+        }
+        for (const [queuePosition, queued] of store.queue.entries()) {
+            replayEvents.push({
+                type: 'message_state_changed',
+                id: queued.id,
+                newState: MessageState.ACCEPTED,
+                queuePosition,
+                userMessage: {
+                    text: queued.text,
+                    timestamp: queued.timestamp,
+                    attachments: queued.attachments,
+                    settings: {
+                        selectedModel: resolveSelectedModel(queued.settings.selectedModel),
+                        thinkingEnabled: queued.settings.thinkingEnabled,
+                        planModeEnabled: queued.settings.planModeEnabled,
+                    },
+                },
+            });
+        }
+        if (store.pendingInteractiveRequest) {
+            if (store.pendingInteractiveRequest.toolName === 'AskUserQuestion') {
+                replayEvents.push({
+                    type: 'user_question',
+                    requestId: store.pendingInteractiveRequest.requestId,
+                    questions: (store.pendingInteractiveRequest.input
+                        .questions ?? []),
+                });
+            }
+            else {
+                replayEvents.push({
+                    type: 'permission_request',
+                    requestId: store.pendingInteractiveRequest.requestId,
+                    toolName: store.pendingInteractiveRequest.toolName,
+                    toolInput: store.pendingInteractiveRequest.input,
+                    planContent: store.pendingInteractiveRequest.planContent,
+                });
+            }
+        }
+        return replayEvents;
+    }
+    forwardReplayBatch(store, options) {
+        const replayEvents = this.buildReplayEvents(store);
+        const payload = {
+            type: 'session_replay_batch',
+            replayEvents,
+            ...(options?.loadRequestId ? { loadRequestId: options.loadRequestId } : {}),
+        };
+        if (options?.includeParitySnapshot) {
+            this.logParityTrace(store.sessionId, {
+                path: 'replay_batch',
+                reason: options.reason ?? 'manual_emit',
+                loadRequestId: options.loadRequestId ?? null,
+                replayEventCount: replayEvents.length,
+            });
+        }
+        chatConnectionService.forwardToSession(store.sessionId, payload);
+    }
+    emitDelta(sessionId, event) {
+        const payload = {
+            type: 'session_delta',
+            data: event,
+        };
+        chatConnectionService.forwardToSession(sessionId, payload);
+    }
+    markRuntime(store, updates, options) {
+        const hasExplicitLastExit = Object.hasOwn(updates, 'lastExit');
+        store.runtime = {
+            ...store.runtime,
+            phase: updates.phase,
+            processState: updates.processState,
+            activity: updates.activity,
+            ...(hasExplicitLastExit ? { lastExit: updates.lastExit } : { lastExit: undefined }),
+            updatedAt: new Date().toISOString(),
+        };
+        if (options?.emitDelta !== false) {
+            this.emitDelta(store.sessionId, {
+                type: 'session_runtime_updated',
+                sessionRuntime: store.runtime,
+            });
+        }
+    }
+    async subscribe(options) {
+        const { sessionId, claudeProjectPath, claudeSessionId, isRunning, isWorking, loadRequestId } = options;
+        const store = this.getOrCreate(sessionId);
+        store.lastKnownProjectPath = claudeProjectPath;
+        store.lastKnownClaudeSessionId = claudeSessionId;
+        await this.ensureHydrated(store, { claudeSessionId, claudeProjectPath });
+        if (isRunning) {
+            this.markRuntime(store, {
+                phase: isWorking ? 'running' : 'idle',
+                processState: 'alive',
+                activity: isWorking ? 'WORKING' : 'IDLE',
+            }, { emitDelta: false });
+        }
+        else {
+            this.markRuntime(store, {
+                phase: 'idle',
+                processState: 'stopped',
+                activity: 'IDLE',
+            }, { emitDelta: false });
+        }
+        this.forwardReplayBatch(store, {
+            loadRequestId,
+            reason: 'subscribe_load',
+            includeParitySnapshot: true,
+        });
+        logger.info('Session subscribed', {
+            sessionId,
+            isRunning,
+            isWorking,
+            transcriptCount: store.transcript.length,
+            queueCount: store.queue.length,
+        });
+    }
+    async ensureHydrated(store, options) {
+        const hydrateKey = `${options.claudeSessionId ?? 'none'}::${options.claudeProjectPath ?? 'none'}`;
+        if (store.initialized && store.hydratedKey === hydrateKey) {
+            return;
+        }
+        if (store.hydratePromise && store.hydratingKey === hydrateKey) {
+            await store.hydratePromise;
+            return;
+        }
+        const generation = store.hydrateGeneration + 1;
+        store.hydrateGeneration = generation;
+        store.hydratingKey = hydrateKey;
+        const hydratePromise = (async () => {
+            let transcript = [];
+            if (options.claudeSessionId && options.claudeProjectPath) {
+                const history = await SessionManager.getHistoryFromProjectPath(options.claudeSessionId, options.claudeProjectPath);
+                transcript = this.buildTranscriptFromHistory(history);
+                transcript.sort(messageSort);
+                this.logParityTrace(store.sessionId, {
+                    path: 'jsonl_hydrate',
+                    claudeSessionId: options.claudeSessionId,
+                    claudeProjectPath: options.claudeProjectPath,
+                    historyCount: history.length,
+                    transcriptCount: transcript.length,
+                    transcript: this.normalizeTranscript(transcript),
+                });
+            }
+            if (store.hydrateGeneration !== generation) {
+                return;
+            }
+            store.transcript = transcript;
+            this.setNextOrderFromTranscript(store);
+            store.initialized = true;
+            store.hydratedKey = hydrateKey;
+            store.lastHydratedAt = new Date().toISOString();
+        })().finally(() => {
+            if (store.hydrateGeneration === generation) {
+                store.hydratePromise = null;
+                store.hydratingKey = null;
+            }
+        });
+        store.hydratePromise = hydratePromise;
+        await hydratePromise;
+    }
+    enqueue(sessionId, message) {
+        const store = this.getOrCreate(sessionId);
+        if (store.queue.length >= MAX_QUEUE_SIZE) {
+            return { error: `Queue full (max ${MAX_QUEUE_SIZE} messages)` };
+        }
+        store.queue.push(message);
+        this.forwardSnapshot(store, { reason: 'enqueue' });
+        return { position: store.queue.length - 1 };
+    }
+    removeQueuedMessage(sessionId, messageId) {
+        const store = this.getOrCreate(sessionId);
+        const idx = store.queue.findIndex((message) => message.id === messageId);
+        if (idx < 0) {
+            return false;
+        }
+        store.queue.splice(idx, 1);
+        this.forwardSnapshot(store, { reason: 'remove_queued_message' });
+        return true;
+    }
+    dequeueNext(sessionId, options) {
+        const store = this.getOrCreate(sessionId);
+        const next = store.queue.shift();
+        if (next && options?.emitSnapshot !== false) {
+            this.forwardSnapshot(store, { reason: 'dequeue' });
+        }
+        return next;
+    }
+    requeueFront(sessionId, message) {
+        const store = this.getOrCreate(sessionId);
+        store.queue.unshift(message);
+        this.forwardSnapshot(store, { reason: 'requeue' });
+    }
+    commitSentUserMessage(sessionId, message, options) {
+        const store = this.getOrCreate(sessionId);
+        const order = store.nextOrder;
+        store.nextOrder += 1;
+        this.commitSentUserMessageWithOrder(store, message, order, options);
+    }
+    commitSentUserMessageAtOrder(sessionId, message, order, options) {
+        const store = this.getOrCreate(sessionId);
+        this.commitSentUserMessageWithOrder(store, message, order, options);
+    }
+    commitSentUserMessageWithOrder(store, message, order, options) {
+        const transcriptMessage = {
+            id: message.id,
+            source: 'user',
+            text: message.text,
+            attachments: message.attachments,
+            timestamp: message.timestamp,
+            order,
+        };
+        this.upsertTranscriptMessage(store, transcriptMessage);
+        if (store.nextOrder <= order) {
+            store.nextOrder = order + 1;
+        }
+        if (options?.emitSnapshot !== false) {
+            this.forwardSnapshot(store, { reason: 'commit_user_message' });
+        }
+    }
+    appendClaudeEvent(sessionId, claudeMessage) {
+        const store = this.getOrCreate(sessionId);
+        const order = store.nextOrder;
+        store.nextOrder += 1;
+        if (claudeMessage.type === 'stream_event') {
+            const event = claudeMessage.event;
+            if (event &&
+                event.type === 'content_block_start' &&
+                event.content_block.type === 'tool_use' &&
+                this.hasPersistedToolUseStart(store, event.content_block.id)) {
+                this.logParityTrace(sessionId, {
+                    path: 'live_stream_filtered',
+                    reason: 'duplicate_tool_use_start_suppressed',
+                    order,
+                    claudeMessage,
+                });
+                return order;
+            }
+        }
+        const shouldPersist = shouldPersistClaudeMessage(claudeMessage);
+        const isDuplicateResult = shouldSuppressDuplicateResultMessage(store.transcript, claudeMessage);
+        if (!shouldPersist || isDuplicateResult) {
+            this.logParityTrace(sessionId, {
+                path: 'live_stream_filtered',
+                reason: !shouldPersist ? 'non_renderable_claude_message' : 'duplicate_result_suppressed',
+                order,
+                claudeMessage,
+            });
+            return order;
+        }
+        const entry = {
+            id: `${sessionId}-${order}`,
+            source: 'claude',
+            message: claudeMessage,
+            timestamp: claudeMessage.timestamp ?? new Date().toISOString(),
+            order,
+        };
+        store.transcript.push(entry);
+        this.logParityTrace(sessionId, {
+            path: 'live_stream_persisted',
+            order,
+            claudeMessage,
+        });
+        return order;
+    }
+    allocateOrder(sessionId) {
+        const store = this.getOrCreate(sessionId);
+        const order = store.nextOrder;
+        store.nextOrder += 1;
+        return order;
+    }
+    setPendingInteractiveRequest(sessionId, request) {
+        const store = this.getOrCreate(sessionId);
+        store.pendingInteractiveRequest = request;
+        this.forwardSnapshot(store, { reason: 'pending_request_set' });
+    }
+    getPendingInteractiveRequest(sessionId) {
+        const store = this.getOrCreate(sessionId);
+        return store.pendingInteractiveRequest;
+    }
+    clearPendingInteractiveRequest(sessionId) {
+        const store = this.getOrCreate(sessionId);
+        if (!store.pendingInteractiveRequest) {
+            return;
+        }
+        store.pendingInteractiveRequest = null;
+        this.forwardSnapshot(store, { reason: 'pending_request_cleared' });
+    }
+    clearPendingInteractiveRequestIfMatches(sessionId, requestId) {
+        const store = this.getOrCreate(sessionId);
+        if (store.pendingInteractiveRequest?.requestId !== requestId) {
+            return;
+        }
+        store.pendingInteractiveRequest = null;
+        this.forwardSnapshot(store, { reason: 'pending_request_cleared' });
+    }
+    markStarting(sessionId) {
+        const store = this.getOrCreate(sessionId);
+        this.markRuntime(store, {
+            phase: 'starting',
+            processState: 'alive',
+            activity: 'IDLE',
+        });
+    }
+    markStopping(sessionId) {
+        const store = this.getOrCreate(sessionId);
+        this.markRuntime(store, {
+            phase: 'stopping',
+            processState: store.runtime.processState,
+            activity: store.runtime.activity,
+        });
+    }
+    markRunning(sessionId) {
+        const store = this.getOrCreate(sessionId);
+        this.markRuntime(store, {
+            phase: 'running',
+            processState: 'alive',
+            activity: 'WORKING',
+        });
+    }
+    markIdle(sessionId, processState) {
+        const store = this.getOrCreate(sessionId);
+        this.markRuntime(store, {
+            phase: 'idle',
+            processState,
+            activity: 'IDLE',
+        });
+    }
+    markError(sessionId) {
+        const store = this.getOrCreate(sessionId);
+        this.markRuntime(store, {
+            phase: 'error',
+            processState: store.runtime.processState,
+            activity: store.runtime.activity,
+        });
+    }
+    markProcessExit(sessionId, code) {
+        const store = this.getOrCreate(sessionId);
+        const unexpected = code === null || code !== 0;
+        store.queue = [];
+        store.pendingInteractiveRequest = null;
+        store.transcript = [];
+        store.nextOrder = 0;
+        store.initialized = false;
+        store.hydratedKey = null;
+        store.hydrateGeneration += 1;
+        store.hydratePromise = null;
+        this.markRuntime(store, {
+            phase: unexpected ? 'error' : 'idle',
+            processState: 'stopped',
+            activity: 'IDLE',
+            lastExit: {
+                code,
+                timestamp: new Date().toISOString(),
+                unexpected,
+            },
+        });
+        this.forwardSnapshot(store, {
+            reason: 'process_exit_reset',
+            includeParitySnapshot: true,
+        });
+        const { lastKnownClaudeSessionId, lastKnownProjectPath } = store;
+        if (lastKnownClaudeSessionId && lastKnownProjectPath) {
+            void this.ensureHydrated(store, {
+                claudeSessionId: lastKnownClaudeSessionId,
+                claudeProjectPath: lastKnownProjectPath,
+            })
+                .then(() => {
+                this.forwardSnapshot(store, {
+                    reason: 'process_exit_rehydrate',
+                    includeParitySnapshot: true,
+                });
+            })
+                .catch((error) => {
+                logger.warn('Failed to rehydrate transcript after process exit', {
+                    sessionId,
+                    error: error instanceof Error ? error.message : String(error),
+                });
+            });
+        }
+    }
+    emitSessionSnapshot(sessionId, loadRequestId) {
+        const store = this.getOrCreate(sessionId);
+        this.forwardSnapshot(store, {
+            loadRequestId,
+            reason: 'manual_emit',
+            includeParitySnapshot: true,
+        });
+    }
+    injectCommittedUserMessage(sessionId, text, options) {
+        const store = this.getOrCreate(sessionId);
+        const messageId = options?.messageId ?? `injected-${Date.now()}`;
+        const message = {
+            id: messageId,
+            source: 'user',
+            text,
+            timestamp: new Date().toISOString(),
+            order: store.nextOrder,
+        };
+        store.nextOrder += 1;
+        this.upsertTranscriptMessage(store, message);
+        this.forwardSnapshot(store, { reason: 'inject_user_message' });
+    }
+    getConnectionCount(sessionId) {
+        let count = 0;
+        for (const info of chatConnectionService.values()) {
+            if (info.dbSessionId === sessionId) {
+                count += 1;
+            }
+        }
+        return count;
+    }
+    clearSession(sessionId) {
+        this.stores.delete(sessionId);
+    }
+    clearAllSessions() {
+        this.stores.clear();
+    }
+    getAllPendingRequests() {
+        const pending = new Map();
+        for (const [sessionId, store] of this.stores.entries()) {
+            if (store.pendingInteractiveRequest) {
+                pending.set(sessionId, store.pendingInteractiveRequest);
+            }
+        }
+        return pending;
+    }
+    getQueueLength(sessionId) {
+        return this.getOrCreate(sessionId).queue.length;
+    }
+    getQueueSnapshot(sessionId) {
+        return [...this.getOrCreate(sessionId).queue];
+    }
+}
+export const sessionStoreService = new SessionStoreService();
+//# sourceMappingURL=session-store.service.js.map