@vibesdotdev/chat 0.0.0-stage → 1.0.0-rc.0

package/dist/svelte/stores/chat/svelte/runtime-chat-sync.d.ts

@@ -0,0 +1,71 @@
+import type { ChatSurfaceClient } from '../../../surface-client.svelte.ts';
+import type { ChatRoomParticipant, UnifiedChatMessage, UnifiedChatRoom } from '@vibesdotdev/chat/schemas/unified';
+import type { ChatUIPreferences } from '@vibesdotdev/chat/schemas/ui';
+import type { ChatRoom } from '@vibesdotdev/chat/client/contracts';
+import type { ChatRunEvent } from '@vibesdotdev/chat/client/schemas/contracts';
+import { type ToolRunEvent } from '../../../../client/tool-run-events.ts';
+interface ChatRunEventHooks {
+    getStreamingId: () => string | null;
+    setStreamingId: (id: string | null) => void;
+    getPendingPlaceholderId: () => string | null;
+    setPendingPlaceholderId: (id: string | null) => void;
+}
+export declare class ChatStoreSync {
+    private readonly stores;
+    constructor(stores: ChatSurfaceClient);
+    applyRoomsSnapshot(snapshot: {
+        rooms: Record<string, UnifiedChatRoom>;
+        activeRoomId: string | null;
+    }, currentUserId: string | null): void;
+    syncRoom(room: UnifiedChatRoom, currentUserId: string | null): void;
+    syncMessages(roomId: string, messages: UnifiedChatMessage[]): void;
+    syncParticipants(roomId: string, participants: ChatRoomParticipant[]): void;
+    /** Add a single message to the store without a full sync (used for optimistic streaming inserts). */
+    syncMessageAdd(roomId: string, message: UnifiedChatMessage): void;
+    /** Remove a single message id from the store (used to retire an optimistic placeholder). */
+    syncMessageRemove(roomId: string, messageId: string): void;
+    /** Append a content delta to a streaming message in the store. */
+    syncMessageChunk(messageId: string, contentDelta: string, snapshotContent?: string): void;
+    /** Replace a single message with its final persisted state. */
+    syncMessageUpdate(message: UnifiedChatMessage): void;
+    clearActiveRoomState(): void;
+    /**
+     * Drop the previous room's ephemeral typing/presence from the SINGLETON realtime
+     * store. These sets have no per-room key, so on a room→room switch (which does NOT
+     * go through clearActiveRoomState) they would otherwise leak room A's typers /
+     * online dots into room B until B emits its own frames — and room A's client-side
+     * typing-expiry timers died with its closed stream, so a stuck typer never clears.
+     * Call this whenever the active room changes.
+     */
+    resetRoomRealtimeState(): void;
+    /** Stable, client-generated id for the optimistic assistant skeleton. */
+    makePlaceholderId(): string;
+    /**
+     * Hooks the store hands to {@link handleChatRunEvent} so it can drive the
+     * `streamingAssistantId` (the message whose growing content must never be
+     * frozen) and the `pendingPlaceholderId` (the optimistic empty assistant
+     * skeleton that shows a typing indicator the instant the user sends, BEFORE
+     * the server's real assistant row arrives ~9s later).
+     */
+    isToolRunEvent(event: ChatRunEvent): event is ToolRunEvent;
+    syncToolRunEvent(roomId: string, event: ToolRunEvent): void;
+    /** Process a run event, updating message stores and streaming state. */
+    handleChatRunEvent(room: ChatRoom, event: ChatRunEvent, messagesStore: ChatSurfaceClient['chatMessagesStore'], hooks: ChatRunEventHooks): void;
+    /** Drop the optimistic assistant skeleton, if one is pending. */
+    retirePlaceholder(roomId: string, placeholderId: string | null, setPendingPlaceholderId: (id: string | null) => void): void;
+    applyUiPreferences(ui: ChatUIPreferences | null | undefined): void;
+}
+export declare const applyRoomsSnapshot: (...args: Parameters<ChatStoreSync["applyRoomsSnapshot"]>) => ReturnType<ChatStoreSync["applyRoomsSnapshot"]>;
+export declare const syncRoom: (...args: Parameters<ChatStoreSync["syncRoom"]>) => ReturnType<ChatStoreSync["syncRoom"]>;
+export declare const syncMessages: (...args: Parameters<ChatStoreSync["syncMessages"]>) => ReturnType<ChatStoreSync["syncMessages"]>;
+export declare const syncParticipants: (...args: Parameters<ChatStoreSync["syncParticipants"]>) => ReturnType<ChatStoreSync["syncParticipants"]>;
+export declare const syncMessageAdd: (...args: Parameters<ChatStoreSync["syncMessageAdd"]>) => ReturnType<ChatStoreSync["syncMessageAdd"]>;
+export declare const syncMessageRemove: (...args: Parameters<ChatStoreSync["syncMessageRemove"]>) => ReturnType<ChatStoreSync["syncMessageRemove"]>;
+export declare const syncMessageChunk: (...args: Parameters<ChatStoreSync["syncMessageChunk"]>) => ReturnType<ChatStoreSync["syncMessageChunk"]>;
+export declare const syncMessageUpdate: (...args: Parameters<ChatStoreSync["syncMessageUpdate"]>) => ReturnType<ChatStoreSync["syncMessageUpdate"]>;
+export declare const clearActiveRoomState: (...args: Parameters<ChatStoreSync["clearActiveRoomState"]>) => ReturnType<ChatStoreSync["clearActiveRoomState"]>;
+export declare const resetRoomRealtimeState: (...args: Parameters<ChatStoreSync["resetRoomRealtimeState"]>) => ReturnType<ChatStoreSync["resetRoomRealtimeState"]>;
+export declare const handleChatRunEvent: (...args: Parameters<ChatStoreSync["handleChatRunEvent"]>) => ReturnType<ChatStoreSync["handleChatRunEvent"]>;
+export declare const applyUiPreferences: (...args: Parameters<ChatStoreSync["applyUiPreferences"]>) => ReturnType<ChatStoreSync["applyUiPreferences"]>;
+export {};
+//# sourceMappingURL=runtime-chat-sync.d.ts.map

package/dist/svelte/stores/chat/svelte/runtime-chat-sync.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime-chat-sync.d.ts","sourceRoot":"","sources":["../../../../../src/svelte/stores/chat/svelte/runtime-chat-sync.ts"],"names":[],"mappings":"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"}

package/dist/svelte/stores/chat/svelte/runtime-chat-sync.js

@@ -0,0 +1,351 @@
+import { SvelteMap } from 'svelte/reactivity';
+import { appendStreamingDelta } from '@vibesdotdev/chat/client';
+import { mapParticipantStyleToAgentMode, mapUnifiedMessageToLegacyMessage, mapUnifiedMessageToRef, mapUnifiedRoomToLegacyRoom } from "./runtime-chat-mappers.js";
+import { diffMessages, buildRoomIndex } from "./message-diff.js";
+import { applyToolRunEventToCalls, readLiveToolCalls } from "../../../../client/tool-run-events.js";
+import { appendMessageSegment, readMessageSegments } from "../../../../client/message-segments.js";
+export class ChatStoreSync {
+    stores;
+    constructor(stores) {
+        this.stores = stores;
+    }
+    applyRoomsSnapshot(snapshot, currentUserId) {
+        this.stores.chatStore.activeRoomId = snapshot.activeRoomId;
+        const rooms = new SvelteMap();
+        for (const room of Object.values(snapshot.rooms)) {
+            rooms.set(room.id, mapUnifiedRoomToLegacyRoom(room, currentUserId));
+        }
+        this.stores.chatStore.rooms = rooms;
+    }
+    syncRoom(room, currentUserId) {
+        this.stores.chatRoomStore.roomId = room.id;
+        this.stores.chatRoomStore.room = mapUnifiedRoomToLegacyRoom(room, currentUserId);
+        this.stores.chatRoomStore.roomMode = room.roomMode ?? 'standard';
+        this.stores.chatRealtimeStore.currentRoomId = room.id;
+        this.stores.chatRealtimeStore.connectionStatus = 'connected';
+    }
+    syncMessages(roomId, messages) {
+        const uniqueMessages = [...new Map(messages.map((message) => [message.id, message])).values()];
+        const previous = this.stores.chatMessagesStore.roomRefs.get(roomId) ?? [];
+        const previousIndex = this.stores.chatMessagesStore.roomIndex.get(roomId);
+        const diff = diffMessages(uniqueMessages, previous, (id) => this.stores.chatMessagesStore.data.get(id), (id) => this.stores.chatMessagesStore.refs.get(id), mapUnifiedMessageToLegacyMessage, mapUnifiedMessageToRef);
+        // Remove stale entries that are no longer in the room
+        for (const id of diff.removed) {
+            this.stores.chatMessagesStore.data.delete(id);
+            this.stores.chatMessagesStore.refs.delete(id);
+        }
+        // Only write entries that are new or actually changed — this prevents
+        // unchanged message rows from triggering Svelte 5 fine-grained reactivity
+        // on every SSE poll/snapshot that falls through to full sync.
+        for (const [id, mapping] of diff.mappings) {
+            this.stores.chatMessagesStore.data.set(id, mapping.data);
+            this.stores.chatMessagesStore.refs.set(id, mapping.ref);
+        }
+        // Only replace roomRefs if the order actually changed
+        if (diff.orderChanged) {
+            this.stores.chatMessagesStore.roomRefs.set(roomId, diff.newOrder);
+        }
+        // Rebuild roomIndex preserving pagination metadata
+        this.stores.chatMessagesStore.roomIndex.set(roomId, buildRoomIndex(diff, previousIndex));
+    }
+    syncParticipants(roomId, participants) {
+        const users = new SvelteMap(this.stores.chatParticipantsStore.users);
+        const agents = new SvelteMap(this.stores.chatParticipantsStore.agents);
+        users.clear();
+        agents.clear();
+        for (const participant of participants) {
+            if (participant.type === 'agent') {
+                agents.set(participant.id, {
+                    chatRoomId: roomId,
+                    agentId: participant.id,
+                    alias: participant.name,
+                    responseMode: mapParticipantStyleToAgentMode(participant.responseStyle)
+                });
+                continue;
+            }
+            users.set(participant.id, {
+                id: participant.id,
+                email: null,
+                displayName: participant.name,
+                avatarUrl: null,
+                role: 'member'
+            });
+        }
+        this.stores.chatParticipantsStore.users = users;
+        this.stores.chatParticipantsStore.agents = agents;
+    }
+    /** Add a single message to the store without a full sync (used for optimistic streaming inserts). */
+    syncMessageAdd(roomId, message) {
+        this.stores.chatMessagesStore.data.set(message.id, mapUnifiedMessageToLegacyMessage(message));
+        this.stores.chatMessagesStore.refs.set(message.id, mapUnifiedMessageToRef(message));
+        const prev = this.stores.chatMessagesStore.roomRefs.get(roomId) ?? [];
+        if (!prev.includes(message.id)) {
+            this.stores.chatMessagesStore.roomRefs.set(roomId, [...prev, message.id]);
+            const idx = this.stores.chatMessagesStore.roomIndex.get(roomId);
+            if (idx) {
+                this.stores.chatMessagesStore.roomIndex.set(roomId, { ...idx, order: [...idx.order, message.id] });
+            }
+        }
+    }
+    /** Remove a single message id from the store (used to retire an optimistic placeholder). */
+    syncMessageRemove(roomId, messageId) {
+        this.stores.chatMessagesStore.data.delete(messageId);
+        this.stores.chatMessagesStore.refs.delete(messageId);
+        const prev = this.stores.chatMessagesStore.roomRefs.get(roomId) ?? [];
+        if (prev.includes(messageId)) {
+            const next = prev.filter((id) => id !== messageId);
+            this.stores.chatMessagesStore.roomRefs.set(roomId, next);
+            const idx = this.stores.chatMessagesStore.roomIndex.get(roomId);
+            if (idx) {
+                this.stores.chatMessagesStore.roomIndex.set(roomId, {
+                    ...idx,
+                    order: idx.order.filter((id) => id !== messageId)
+                });
+            }
+        }
+    }
+    /** Append a content delta to a streaming message in the store. */
+    syncMessageChunk(messageId, contentDelta, snapshotContent) {
+        const msg = this.stores.chatMessagesStore.data.get(messageId);
+        if (msg) {
+            const content = snapshotContent ?? appendStreamingDelta(msg.content ?? '', contentDelta);
+            if (content === msg.content)
+                return;
+            this.stores.chatMessagesStore.data.set(messageId, {
+                ...msg,
+                content,
+                metadata: {
+                    ...msg.metadata,
+                    segments: appendMessageSegment(readMessageSegments(msg.metadata, msg.content ?? ''), {
+                        kind: 'text', text: content.slice((msg.content ?? '').length)
+                    })
+                }
+            });
+        }
+    }
+    /** Replace a single message with its final persisted state. */
+    syncMessageUpdate(message) {
+        this.stores.chatMessagesStore.data.set(message.id, mapUnifiedMessageToLegacyMessage(message));
+        this.stores.chatMessagesStore.refs.set(message.id, mapUnifiedMessageToRef(message));
+    }
+    clearActiveRoomState() {
+        this.stores.chatRoomStore.roomId = null;
+        this.stores.chatRoomStore.room = null;
+        this.stores.chatRoomStore.roomMode = 'standard';
+        this.stores.chatRoomStore.pendingRoomMode = 'standard';
+        this.stores.chatParticipantsStore.users = new SvelteMap();
+        this.stores.chatParticipantsStore.agents = new SvelteMap();
+        this.resetRoomRealtimeState();
+    }
+    /**
+     * Drop the previous room's ephemeral typing/presence from the SINGLETON realtime
+     * store. These sets have no per-room key, so on a room→room switch (which does NOT
+     * go through clearActiveRoomState) they would otherwise leak room A's typers /
+     * online dots into room B until B emits its own frames — and room A's client-side
+     * typing-expiry timers died with its closed stream, so a stuck typer never clears.
+     * Call this whenever the active room changes.
+     */
+    resetRoomRealtimeState() {
+        this.stores.chatRealtimeStore.currentRoomId = null;
+        this.stores.chatRealtimeStore.connectionStatus = 'disconnected';
+        this.stores.chatRealtimeStore.typingUsers = new Set();
+        this.stores.chatRealtimeStore.onlineUsers = new SvelteMap();
+    }
+    /** Stable, client-generated id for the optimistic assistant skeleton. */
+    makePlaceholderId() {
+        const uuid = globalThis.crypto?.randomUUID?.();
+        if (uuid)
+            return `optimistic-assistant-${uuid}`;
+        return `optimistic-assistant-${Math.random().toString(36).slice(2)}`;
+    }
+    /**
+     * Hooks the store hands to {@link handleChatRunEvent} so it can drive the
+     * `streamingAssistantId` (the message whose growing content must never be
+     * frozen) and the `pendingPlaceholderId` (the optimistic empty assistant
+     * skeleton that shows a typing indicator the instant the user sends, BEFORE
+     * the server's real assistant row arrives ~9s later).
+     */
+    isToolRunEvent(event) {
+        return (event.type === 'tool.started' ||
+            event.type === 'tool.progress' ||
+            event.type === 'tool.completed' ||
+            event.type === 'tool.failed');
+    }
+    syncToolRunEvent(roomId, event) {
+        const messageId = event.messageId;
+        if (!this.stores.chatMessagesStore.data.has(messageId)) {
+            const now = new Date().toISOString();
+            this.syncMessageAdd(roomId, {
+                id: messageId,
+                roomId,
+                role: 'assistant',
+                content: '',
+                senderType: 'agent',
+                status: 'streaming',
+                createdAt: now,
+                updatedAt: now
+            });
+        }
+        const msg = this.stores.chatMessagesStore.data.get(messageId);
+        if (!msg)
+            return;
+        const metadata = { ...msg.metadata };
+        this.stores.chatMessagesStore.data.set(messageId, {
+            ...msg,
+            metadata: {
+                ...metadata,
+                segments: appendMessageSegment(readMessageSegments(metadata, msg.content ?? ''), {
+                    kind: 'tool', toolCallId: event.toolCallId
+                }),
+                toolCalls: applyToolRunEventToCalls(readLiveToolCalls(metadata), event).map((call) => ({
+                    ...call,
+                    input: call.input,
+                    timestamp: call.startedAt,
+                    status: call.status === 'timeout' ? 'failed' : call.status
+                }))
+            }
+        });
+    }
+    /** Process a run event, updating message stores and streaming state. */
+    handleChatRunEvent(room, event, messagesStore, hooks) {
+        const { setStreamingId, getPendingPlaceholderId, setPendingPlaceholderId } = hooks;
+        if (event.type === 'message.created') {
+            if (event.role === 'user') {
+                // The optimistic user echo just landed. Drop an empty assistant skeleton
+                // (status 'streaming') RIGHT NOW so a typing indicator shows immediately,
+                // instead of waiting for the server's assistant message to arrive. The
+                // real assistant row replaces it (see below) once SSE delivers it.
+                if (!messagesStore.data.has(event.messageId)) {
+                    const now = new Date().toISOString();
+                    this.syncMessageAdd(room.id, {
+                        id: event.messageId,
+                        roomId: room.id,
+                        role: 'user',
+                        content: event.content,
+                        senderType: 'user',
+                        status: 'sent',
+                        createdAt: now,
+                        updatedAt: now
+                    });
+                }
+                if (!getPendingPlaceholderId()) {
+                    const placeholderId = this.makePlaceholderId();
+                    const now = new Date().toISOString();
+                    this.syncMessageAdd(room.id, {
+                        id: placeholderId,
+                        roomId: room.id,
+                        role: 'assistant',
+                        content: '',
+                        senderType: 'agent',
+                        status: 'streaming',
+                        createdAt: now,
+                        updatedAt: now
+                    });
+                    setPendingPlaceholderId(placeholderId);
+                    setStreamingId(placeholderId);
+                }
+                return;
+            }
+            // Real assistant row arrived — retire the optimistic skeleton and hand the
+            // streaming baton to the authoritative id so chunks land on it live.
+            this.retirePlaceholder(room.id, getPendingPlaceholderId(), setPendingPlaceholderId);
+            if (!messagesStore.data.has(event.messageId)) {
+                const now = new Date().toISOString();
+                this.syncMessageAdd(room.id, {
+                    id: event.messageId,
+                    roomId: room.id,
+                    role: 'assistant',
+                    content: event.content,
+                    senderType: 'agent',
+                    status: 'streaming',
+                    createdAt: now,
+                    updatedAt: now
+                });
+            }
+            setStreamingId(event.messageId);
+        }
+        else if (event.type === 'chunk') {
+            // A real chunk means the authoritative assistant row exists — retire the
+            // skeleton and point streaming at the real id before applying the delta.
+            this.retirePlaceholder(room.id, getPendingPlaceholderId(), setPendingPlaceholderId);
+            setStreamingId(event.messageId);
+            this.syncMessageChunk(event.messageId, event.content, event.snapshotContent);
+        }
+        else if (this.isToolRunEvent(event)) {
+            this.retirePlaceholder(room.id, getPendingPlaceholderId(), setPendingPlaceholderId);
+            setStreamingId(event.messageId);
+            this.syncToolRunEvent(room.id, event);
+        }
+        else if (event.type === 'done') {
+            this.retirePlaceholder(room.id, getPendingPlaceholderId(), setPendingPlaceholderId);
+            setStreamingId(null);
+            void room.messages.get(event.result.assistantMessageId).then((msg) => {
+                if (msg)
+                    this.syncMessageUpdate(msg);
+            });
+        }
+        else if (event.type === 'error') {
+            this.retirePlaceholder(room.id, getPendingPlaceholderId(), setPendingPlaceholderId);
+            setStreamingId(null);
+            if (event.messageId) {
+                void room.messages.get(event.messageId).then((msg) => {
+                    if (msg)
+                        this.syncMessageUpdate(msg);
+                });
+            }
+        }
+        else if (event.type === 'typing') {
+            // The stream wiring owns the authoritative typing set (add on `typing`,
+            // auto-expire after a few seconds); replace ours wholesale so the typing
+            // strip + participant list react. New Set() keeps $state reactive.
+            this.stores.chatRealtimeStore.typingUsers = new Set(event.userIds);
+        }
+        else if (event.type === 'presence') {
+            // Ditto for online presence — the wiring maintains lastActivity and drops
+            // users who went offline. Replace with a fresh Map so $derived views recompute.
+            const online = new SvelteMap();
+            for (const entry of event.online) {
+                online.set(entry.userId, { lastActivity: entry.lastActivity });
+            }
+            this.stores.chatRealtimeStore.onlineUsers = online;
+        }
+    }
+    /** Drop the optimistic assistant skeleton, if one is pending. */
+    retirePlaceholder(roomId, placeholderId, setPendingPlaceholderId) {
+        if (!placeholderId)
+            return;
+        this.syncMessageRemove(roomId, placeholderId);
+        setPendingPlaceholderId(null);
+    }
+    applyUiPreferences(ui) {
+        if (!ui)
+            return;
+        if (ui.sidebarLeftOpen !== undefined)
+            this.stores.chatUIStore.sidebarLeftOpen = ui.sidebarLeftOpen;
+        if (ui.sidebarRightOpen !== undefined)
+            this.stores.chatUIStore.sidebarRightOpen = ui.sidebarRightOpen;
+        if (ui.chatRoomListWidth !== undefined)
+            this.stores.chatUIStore.chatRoomListWidth = ui.chatRoomListWidth;
+        if (ui.messageInputHeight !== undefined)
+            this.stores.chatUIStore.messageInputHeight = ui.messageInputHeight;
+        if (ui.compactMode !== undefined)
+            this.stores.chatUIStore.compactMode = ui.compactMode;
+        if (ui.showTimestamps !== undefined)
+            this.stores.chatUIStore.showTimestamps = ui.showTimestamps;
+        if (ui.showAvatars !== undefined)
+            this.stores.chatUIStore.showAvatars = ui.showAvatars;
+    }
+}
+import { getChatSurfaceContext } from "../../../surface-context.js";
+export const applyRoomsSnapshot = (...args) => getChatSurfaceContext().sync.applyRoomsSnapshot(...args);
+export const syncRoom = (...args) => getChatSurfaceContext().sync.syncRoom(...args);
+export const syncMessages = (...args) => getChatSurfaceContext().sync.syncMessages(...args);
+export const syncParticipants = (...args) => getChatSurfaceContext().sync.syncParticipants(...args);
+export const syncMessageAdd = (...args) => getChatSurfaceContext().sync.syncMessageAdd(...args);
+export const syncMessageRemove = (...args) => getChatSurfaceContext().sync.syncMessageRemove(...args);
+export const syncMessageChunk = (...args) => getChatSurfaceContext().sync.syncMessageChunk(...args);
+export const syncMessageUpdate = (...args) => getChatSurfaceContext().sync.syncMessageUpdate(...args);
+export const clearActiveRoomState = (...args) => getChatSurfaceContext().sync.clearActiveRoomState(...args);
+export const resetRoomRealtimeState = (...args) => getChatSurfaceContext().sync.resetRoomRealtimeState(...args);
+export const handleChatRunEvent = (...args) => getChatSurfaceContext().sync.handleChatRunEvent(...args);
+export const applyUiPreferences = (...args) => getChatSurfaceContext().sync.applyUiPreferences(...args);

package/dist/svelte/stores/chatFoldersStore.svelte.d.ts

@@ -0,0 +1,25 @@
+import { SvelteMap, SvelteSet } from 'svelte/reactivity';
+/**
+ * Store for managing chat folders and their organization
+ */
+export declare class ChatFoldersStore {
+    folders: SvelteMap<string, {
+        id: string;
+        userId: string;
+        title: string;
+        visibility: "public" | "private" | "hidden";
+        parentFolderId?: string | undefined;
+        description?: string | undefined;
+        icon?: string | undefined;
+        color?: string | undefined;
+        archivedAt?: string | undefined;
+        archivedBy?: string | undefined;
+        archivedReason?: string | undefined;
+        createdAt?: string | undefined;
+        updatedAt?: string | undefined;
+    }>;
+    folderRooms: SvelteMap<string, SvelteSet<string>>;
+    expandedFolders: SvelteSet<string>;
+}
+export declare const chatFoldersStore: ChatFoldersStore;
+//# sourceMappingURL=chatFoldersStore.svelte.d.ts.map

package/dist/svelte/stores/chatFoldersStore.svelte.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chatFoldersStore.svelte.d.ts","sourceRoot":"","sources":["../../../src/svelte/stores/chatFoldersStore.svelte.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AAGzD;;GAEG;AACH,qBAAa,gBAAgB;IAE5B,OAAO;;;;;;;;;;;;;;OAAmD;IAC1D,WAAW,uCAAsD;IAGjE,eAAe,oBAAmC;CAClD;AAGD,eAAO,MAAM,gBAAgB,kBAA0C,CAAC"}

package/dist/svelte/stores/chatFoldersStore.svelte.js

@@ -0,0 +1,14 @@
+import { contextualChatStore } from "../surface-context.js";
+import { SvelteMap, SvelteSet } from 'svelte/reactivity';
+/**
+ * Store for managing chat folders and their organization
+ */
+export class ChatFoldersStore {
+    // Core data from database
+    folders = $state(new SvelteMap());
+    folderRooms = $state(new SvelteMap()); // folderId -> set of conversationIds
+    // UI state
+    expandedFolders = $state(new SvelteSet());
+}
+// Compatibility access selects the mounted runtime.
+export const chatFoldersStore = contextualChatStore('chatFoldersStore');

package/dist/svelte/stores/chatMessagesStore.svelte.d.ts

@@ -0,0 +1,99 @@
+import type { ChatMessage } from '@vibesdotdev/chat/schemas/common';
+import { SvelteMap } from 'svelte/reactivity';
+import type { RoomIndex } from './schemas/index.ts';
+export interface ChatMessageCacheEntry {
+    data?: ChatMessage;
+    status: 'idle' | 'loaded' | 'error';
+    updatedAt?: number;
+    error?: string;
+}
+/**
+ * Chat messages state store
+ * Per R-STORES-001, this store contains ONLY state - no methods, async logic, or side effects.
+ * All business logic lives in ChatMessagesService.
+ */
+export declare class ChatMessagesStore {
+    data: SvelteMap<string, {
+        id: string;
+        chatRoomId: string;
+        status: "failed" | "queued" | "streaming" | "sending" | "sent" | "pending" | "declined" | "processing" | "completed";
+        messageType: "error" | "text" | "image" | "image_url" | "video_url" | "tool_request" | "tool_response" | "knowledge_result";
+        senderType: "user" | "agent" | "system";
+        userId?: string | undefined;
+        agentId?: string | undefined;
+        replyToId?: string | undefined;
+        content?: string | undefined;
+        attachments?: {
+            id: string;
+            fileName: string;
+            contentType: string;
+            size: number;
+            url: string;
+            createdAt: string;
+        }[] | undefined;
+        metadata?: {
+            [x: string]: unknown;
+            contentBlocks?: {
+                thinking: string;
+                message: string;
+            } | undefined;
+            segments?: ({
+                kind: "text";
+                text: string;
+            } | {
+                kind: "thinking";
+                text: string;
+                startedAt?: string | undefined;
+                durationMs?: number | undefined;
+            } | {
+                kind: "tool";
+                toolCallId: string;
+            })[] | undefined;
+            toolCalls?: {
+                [x: string]: unknown;
+                toolId: string;
+                toolName: string;
+                input: unknown;
+                timestamp: string;
+                output?: unknown;
+                error?: string | undefined;
+                status?: "denied" | "cancelled" | "failed" | "pending" | "completed" | "awaiting_approval" | "running" | "interrupted" | undefined;
+                toolCallId?: string | undefined;
+                approval?: {
+                    [x: string]: unknown;
+                    required?: boolean | undefined;
+                    requestId?: string | undefined;
+                    expiresAt?: string | undefined;
+                    respondedAt?: string | undefined;
+                    decision?: "denied" | "timeout" | "pending" | "approved" | undefined;
+                    reason?: string | undefined;
+                    approverId?: string | undefined;
+                } | undefined;
+            }[] | undefined;
+            reasoningSteps?: {
+                thought: string;
+                timestamp: string;
+                action?: string | undefined;
+                observation?: string | undefined;
+            }[] | undefined;
+            error?: string | undefined;
+        } | undefined;
+        createdAt?: string | undefined;
+        updatedAt?: string | undefined;
+    }>;
+    refs: SvelteMap<string, {
+        id: string;
+        chatRoomId: string;
+        senderType: "user" | "agent" | "system";
+        messageType: "error" | "text" | "image" | "image_url" | "video_url" | "tool_request" | "tool_response" | "knowledge_result";
+        createdAt: string;
+        excerpt: string;
+        userId?: string | undefined;
+        agentId?: string | undefined;
+    }>;
+    roomRefs: SvelteMap<string, string[]>;
+    roomIndex: SvelteMap<string, RoomIndex>;
+    get(id: string): ChatMessageCacheEntry;
+}
+export declare const chatMessagesStore: ChatMessagesStore;
+//# sourceMappingURL=chatMessagesStore.svelte.d.ts.map

package/dist/svelte/stores/chatMessagesStore.svelte.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chatMessagesStore.svelte.d.ts","sourceRoot":"","sources":["../../../src/svelte/stores/chatMessagesStore.svelte.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kCAAkC,CAAC;AAEpE,OAAO,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AAC9C,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAEpD,MAAM,WAAW,qBAAqB;IACrC,IAAI,CAAC,EAAE,WAAW,CAAC;IACnB,MAAM,EAAE,MAAM,GAAG,QAAQ,GAAG,OAAO,CAAC;IACpC,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,KAAK,CAAC,EAAE,MAAM,CAAC;CACf;AAED;;;;GAIG;AACH,qBAAa,iBAAiB;IAE7B,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAAgD;IAEpD,IAAI;;;;;;;;;OAAuD;IAE3D,QAAQ,8BAA6C;IAErD,SAAS,+BAA8C;IAGvD,GAAG,CAAC,EAAE,EAAE,MAAM,GAAG,qBAAqB;CAItC;AAED,eAAO,MAAM,iBAAiB,mBAA2C,CAAC"}

package/dist/svelte/stores/chatMessagesStore.svelte.js

@@ -0,0 +1,23 @@
+import { contextualChatStore } from "../surface-context.js";
+import { SvelteMap } from 'svelte/reactivity';
+/**
+ * Chat messages state store
+ * Per R-STORES-001, this store contains ONLY state - no methods, async logic, or side effects.
+ * All business logic lives in ChatMessagesService.
+ */
+export class ChatMessagesStore {
+    // Full message data (expanded on-demand)
+    data = $state(new SvelteMap());
+    // Message references (lightweight, loaded first)
+    refs = $state(new SvelteMap());
+    // Room-ordered ref IDs (roomId → ref IDs in order)
+    roomRefs = $state(new SvelteMap());
+    // Legacy room index for pagination metadata
+    roomIndex = $state(new SvelteMap());
+    // Lightweight cache accessor used by CachedLoader
+    get(id) {
+        const m = this.data.get(id);
+        return { data: m, status: m ? 'loaded' : 'idle' };
+    }
+}
+export const chatMessagesStore = contextualChatStore('chatMessagesStore');

package/dist/svelte/stores/chatParticipantsStore.svelte.d.ts

@@ -0,0 +1,34 @@
+import { SvelteMap } from 'svelte/reactivity';
+/**
+ * Store for managing chat participants (users and agents)
+ */
+export declare class ChatParticipantsStore {
+    users: SvelteMap<string, {
+        id: string;
+        email: string | null;
+        displayName: string;
+        avatarUrl: string | null;
+        role: "owner" | "member" | "admin" | "moderator" | "guest" | "banned";
+    }>;
+    agents: SvelteMap<string, {
+        chatRoomId: string;
+        agentId: string;
+        alias: string;
+        responseMode: "always" | "tagged" | "auto";
+    }>;
+    participants: ({
+        id: string;
+        email: string | null;
+        displayName: string;
+        avatarUrl: string | null;
+        role: "owner" | "member" | "admin" | "moderator" | "guest" | "banned";
+    } | {
+        chatRoomId: string;
+        agentId: string;
+        alias: string;
+        responseMode: "always" | "tagged" | "auto";
+    })[];
+    currentUserId: string | null;
+}
+export declare const chatParticipantsStore: ChatParticipantsStore;
+//# sourceMappingURL=chatParticipantsStore.svelte.d.ts.map

package/dist/svelte/stores/chatParticipantsStore.svelte.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chatParticipantsStore.svelte.d.ts","sourceRoot":"","sources":["../../../src/svelte/stores/chatParticipantsStore.svelte.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AAG9C;;GAEG;AACH,qBAAa,qBAAqB;IACjC,KAAK;;;;;;OAAwD;IAC7D,MAAM;;;;;OAAyD;IAE/D,YAAY;;;;;;;;;;;SAA+D;IAG3E,aAAa,gBAA+B;CAC5C;AAGD,eAAO,MAAM,qBAAqB,uBAA+C,CAAC"}

package/dist/svelte/stores/chatParticipantsStore.svelte.js

@@ -0,0 +1,14 @@
+import { contextualChatStore } from "../surface-context.js";
+import { SvelteMap } from 'svelte/reactivity';
+/**
+ * Store for managing chat participants (users and agents)
+ */
+export class ChatParticipantsStore {
+    users = $state(new SvelteMap());
+    agents = $state(new SvelteMap());
+    participants = $derived([...this.agents.values(), ...this.users.values()]);
+    // Current user (for identifying own messages)
+    currentUserId = $state(null);
+}
+// Compatibility access selects the mounted runtime.
+export const chatParticipantsStore = contextualChatStore('chatParticipantsStore');