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

package/dist/svelte/state.svelte.js

@@ -0,0 +1,759 @@
+import { contextualChatStore } from "./surface-context.js";
+import * as z from 'zod/v4';
+import { CapabilityError, CaughtFailureSchema, valueFreeFailure } from '@vibesdotdev/kernel';
+import { getVibesChatClient } from '@vibesdotdev/chat/client';
+import { ChatRoomWatch } from "./room-watch.js";
+import { mergeInboxItems } from "./inbox.js";
+import { mergeInboxRoom } from "../client/inbox-room.js";
+const toolCallRecordCandidateSchema = z.looseObject({
+    toolCallId: z.string().min(1).optional(),
+    id: z.string().min(1).optional()
+});
+const configurableHttpClientSchema = z.looseObject({
+    configureHttp: z.custom((fn) => fn instanceof Function)
+});
+const toolHistoryMetadataSchema = z.looseObject({
+    toolCalls: z.array(z.custom((v) => v instanceof Object)).optional(),
+    toolCallHistory: z
+        .looseObject({
+        total: z.number().optional(),
+        omitted: z.number().optional()
+    })
+        .optional()
+});
+function toolCallRecordId(record) {
+    const parsed = toolCallRecordCandidateSchema.safeParse(record);
+    if (!parsed.success)
+        return undefined;
+    return parsed.data.toolCallId ?? parsed.data.id;
+}
+export class ChatState {
+    /** Last recovery failure, retained for the surface owner even after room navigation. */
+    toolHistoryFailure = $state(null);
+    rooms = $state([]);
+    activeRoom = $state(null);
+    messages = $state([]);
+    /** Live snapshots for multi-room surfaces such as a unified Inbox. */
+    roomMessageSnapshots = $state({});
+    roomMessageErrors = $state({});
+    /** One owner-authorized chronological feed; avoids one transport per room. */
+    inboxItems = $state([]);
+    inboxNextCursor = $state(null);
+    inboxLoading = $state(false);
+    inboxError = $state(null);
+    participants = $state([]);
+    toolPolicy = $state(null);
+    initialized = $state(false);
+    loading = $state(false);
+    error = $state(null);
+    client = null;
+    inflight = null;
+    roomsUnsub = null;
+    messagesUnsub = null;
+    participantsUnsub = null;
+    activeRoomHandle = null;
+    transcriptWindowIds = null;
+    transcriptTailLive = true;
+    transcriptEpoch = 0;
+    roomRequestEpoch = 0;
+    historyHasNewer = $state(false);
+    /** An older-history page is in flight (scroll sentinel guard). */
+    historyLoadingOlder = $state(false);
+    /** The oldest page came back short: no older history remains. */
+    historyOlderExhausted = $state(false);
+    /** Per-message tool-history recovery state, keyed by message id. */
+    toolHistoryLoading = $state({});
+    toolHistoryError = $state({});
+    /** Background processes behind the active room (consumer runtimes). */
+    backgroundProcesses = $state([]);
+    backgroundProcessesErrors = $state([]);
+    backgroundProcessesLoading = $state(false);
+    backgroundProcessesError = $state(null);
+    /** Null until the first load probes runtime support. */
+    backgroundProcessesSupported = $state(null);
+    roomWatch = null;
+    inboxUnsub = null;
+    inboxRefreshTimer = null;
+    inboxRequestEpoch = 0;
+    initEpoch = 0;
+    inboxScope = {};
+    inboxScopeLoaded = false;
+    get activeRoomId() {
+        return this.activeRoom?.id ?? null;
+    }
+    get activeRoomTitle() {
+        return this.activeRoom?.title ?? null;
+    }
+    get participantCount() {
+        return this.participants.length;
+    }
+    get messageCount() {
+        return this.messages.length;
+    }
+    get hasActiveRoom() {
+        return this.activeRoom !== null;
+    }
+    /**
+     * Idempotent init. Called by `<ChatLoader />`. Concurrent callers share the
+     * in-flight promise so init runs exactly once per logical load.
+     */
+    async init(options = {}) {
+        if (this.initialized) {
+            this.seedInitial(options);
+            return;
+        }
+        if (this.inflight) {
+            await this.inflight;
+            return;
+        }
+        this.seedInitial(options);
+        const epoch = this.initEpoch;
+        this.loading = true;
+        this.error = null;
+        this.inflight = (async () => {
+            try {
+                let client = options.client;
+                if (!client) {
+                    if (!options.runtime) {
+                        throw new CapabilityError('chatState.init requires options.runtime when no client is given', 'UNAVAILABLE', { reason: 'runtime-unavailable' });
+                    }
+                    const runtimeClient = await getVibesChatClient(options.runtime);
+                    if (options.origin) {
+                        const configurable = configurableHttpClientSchema.safeParse(runtimeClient);
+                        if (configurable.success) {
+                            configurable.data.configureHttp({ origin: options.origin });
+                        }
+                    }
+                    client = runtimeClient;
+                }
+                await client.load();
+                if (epoch !== this.initEpoch)
+                    return;
+                this.client = client;
+                // Sync the rooms snapshot + active room id from the runtime.
+                this.roomsUnsub = this.client.rooms.subscribe((snapshot) => {
+                    const existing = new Map(this.rooms.map((room) => [room.id, room]));
+                    this.rooms = Object.values(snapshot.rooms).map((room) => mergeInboxRoom(existing.get(room.id), room));
+                    if (snapshot.activeRoomId) {
+                        const next = snapshot.rooms[snapshot.activeRoomId];
+                        if (next)
+                            this.activeRoom = next;
+                    }
+                    else if (this.activeRoom && !snapshot.rooms[this.activeRoom.id]) {
+                        this.activeRoom = null;
+                    }
+                });
+                const list = await this.client.rooms.list();
+                if (epoch !== this.initEpoch)
+                    return;
+                if (list.length > 0) {
+                    this.rooms = list.map((r) => r.data);
+                }
+                const activeId = options.initialActiveRoomId ?? (await this.client.rooms.getActiveId());
+                if (activeId) {
+                    await this.activateRoom(activeId);
+                }
+                this.initialized = true;
+            }
+            catch (err) {
+                if (epoch !== this.initEpoch)
+                    throw err;
+                this.recordInitFailure(CaughtFailureSchema.parse(err));
+            }
+            finally {
+                if (epoch === this.initEpoch) {
+                    this.loading = false;
+                    this.inflight = null;
+                }
+            }
+        })();
+        await this.inflight;
+    }
+    recordInitFailure(error) {
+        this.error = error instanceof Error ? error.message : String(error);
+        // Mark initialized so the UI can render the error banner without
+        // hammering the runtime on every effect re-run.
+        this.initialized = true;
+    }
+    /**
+     * Seed reactive state from a SvelteKit `+layout.server.ts` payload. Safe to
+     * call before or after `init()`.
+     */
+    seedInitial(options) {
+        if (options.initialRooms) {
+            this.rooms = options.initialRooms;
+        }
+        if (options.initialActiveRoomId !== undefined) {
+            const next = options.initialActiveRoomId;
+            this.activeRoom = next ? this.rooms.find((r) => r.id === next) ?? null : null;
+        }
+        if (options.initialMessages) {
+            this.messages = options.initialMessages;
+        }
+        if (options.initialParticipants) {
+            this.participants = options.initialParticipants;
+        }
+        if (options.initialToolPolicy !== undefined) {
+            this.toolPolicy = options.initialToolPolicy;
+        }
+    }
+    /**
+     * Switch the active room. Updates local state immediately for snappy UI;
+     * fails visibly without ever showing another room's transcript on failure.
+     */
+    async setActiveRoom(roomId) {
+        const client = this.requireClient();
+        const epoch = ++this.roomRequestEpoch;
+        this.transcriptEpoch += 1;
+        this.disposeRoomSubs();
+        this.activeRoom = roomId ? this.rooms.find((r) => r.id === roomId) ?? null : null;
+        this.messages = [];
+        this.participants = [];
+        this.error = null;
+        this.resetRoomScopedPaging();
+        try {
+            await client.rooms.setActiveId(roomId);
+            if (epoch !== this.roomRequestEpoch)
+                return;
+            if (roomId) {
+                await this.activateRoom(roomId, epoch);
+            }
+            else {
+                this.disposeRoomSubs();
+            }
+        }
+        catch (err) {
+            if (epoch !== this.roomRequestEpoch)
+                return;
+            this.disposeRoomSubs();
+            this.activeRoom = null;
+            this.messages = [];
+            this.participants = [];
+            this.error = err instanceof Error ? err.message : String(err);
+            throw err;
+        }
+    }
+    /**
+     * Create a room through the runtime chat client and make it active.
+     * Embedded app surfaces use this instead of redirecting users through
+     * chat-web's `/new` route.
+     */
+    async createRoom(input = {}) {
+        const client = this.requireClient();
+        this.loading = true;
+        this.error = null;
+        try {
+            const room = await client.rooms.create(input);
+            const existingIndex = this.rooms.findIndex((candidate) => candidate.id === room.id);
+            if (existingIndex >= 0) {
+                const next = [...this.rooms];
+                next[existingIndex] = room.data;
+                this.rooms = next;
+            }
+            else {
+                this.rooms = [room.data, ...this.rooms];
+            }
+            await this.setActiveRoom(room.id);
+            return room.data;
+        }
+        catch (err) {
+            this.error = err instanceof Error ? err.message : String(err);
+            throw err;
+        }
+        finally {
+            this.loading = false;
+        }
+    }
+    /**
+     * Send a message to the active room with optimistic insertion.
+     * Rolls back the optimistic entry on failure.
+     */
+    async sendMessage(input) {
+        const client = this.requireClient();
+        if (!this.activeRoom) {
+            throw new Error('chatState.sendMessage requires an active room');
+        }
+        const roomId = this.activeRoom.id;
+        const epoch = this.roomRequestEpoch;
+        const room = this.activeRoomHandle ?? (await client.rooms.get(roomId));
+        if (!room)
+            throw new Error(`Room ${roomId} not found`);
+        if (epoch !== this.roomRequestEpoch)
+            throw new Error('Conversation changed before send.');
+        const optimisticId = `optimistic-${Date.now()}`;
+        const optimistic = {
+            id: optimisticId,
+            roomId,
+            senderType: 'user',
+            role: 'user',
+            content: input.content,
+            status: 'sending',
+            createdAt: new Date().toISOString()
+        };
+        const previous = this.messages;
+        this.messages = [...this.messages, optimistic];
+        try {
+            const result = await room.send(input);
+            // Subscribe-driven update will replace messages; if not, replace inline.
+            if (epoch === this.roomRequestEpoch)
+                this.messages = this.messages.map((m) => (m.id === optimisticId ? { ...m, id: result.userMessageId, status: 'sent' } : m));
+            return result;
+        }
+        catch (err) {
+            if (epoch === this.roomRequestEpoch)
+                this.messages = previous;
+            throw err;
+        }
+    }
+    /**
+     * Subscribe to several rooms at once through the runtime client.
+     *
+     * The active-room API intentionally remains singular. Unified inboxes need a
+     * different projection: bounded message snapshots for a caller-selected set
+     * of rooms, each kept current by that room's real realtime transport. Calling
+     * this again replaces the watched set and tears down obsolete subscriptions.
+     */
+    async watchRooms(roomIds, options = {}) {
+        const client = this.requireClient();
+        this.roomWatch ??= new ChatRoomWatch(client, (value) => { this.roomMessageSnapshots = value; }, (value) => { this.roomMessageErrors = value; });
+        await this.roomWatch.watch(roomIds, options.limit ?? 100);
+    }
+    stopWatchingRooms() {
+        this.roomWatch?.stop();
+        this.roomWatch = null;
+    }
+    /** Load or extend the durable owner Inbox page. */
+    async loadInbox(input = {}, options = {}) {
+        const client = this.requireClient();
+        if (!client.inbox)
+            throw new Error('The selected Chat runtime does not expose an Inbox feed.');
+        const epoch = ++this.inboxRequestEpoch;
+        this.inboxLoading = true;
+        this.inboxError = null;
+        if (!input.cursor) {
+            const nextScope = {};
+            if (input.query?.trim())
+                nextScope.query = input.query.trim();
+            if (input.sourceKind)
+                nextScope.sourceKind = input.sourceKind;
+            if (input.sourceId?.trim())
+                nextScope.sourceId = input.sourceId.trim();
+            if (input.bindingId?.trim())
+                nextScope.bindingId = input.bindingId.trim();
+            if (input.connection)
+                nextScope.connection = input.connection;
+            if (input.account)
+                nextScope.account = input.account;
+            if (input.roomId?.trim())
+                nextScope.roomId = input.roomId.trim();
+            if (input.agentId?.trim())
+                nextScope.agentId = input.agentId.trim();
+            if (JSON.stringify(nextScope) !== JSON.stringify(this.inboxScope)) {
+                this.inboxItems = [];
+                this.inboxNextCursor = null;
+                this.inboxScopeLoaded = false;
+            }
+            this.inboxScope = nextScope;
+        }
+        const preserveTail = options.preserveTail && this.inboxScopeLoaded;
+        try {
+            const page = await client.inbox.list({ ...this.inboxScope, ...input });
+            if (epoch !== this.inboxRequestEpoch)
+                return;
+            const roomsById = new Map(this.rooms.map((room) => [room.id, room]));
+            for (const item of page.items) {
+                roomsById.set(item.room.id, mergeInboxRoom(roomsById.get(item.room.id), item.room));
+            }
+            this.rooms = [...roomsById.values()];
+            if (options.append) {
+                this.inboxItems = mergeInboxItems(this.inboxItems, page.items);
+            }
+            else if (preserveTail) {
+                this.inboxItems = mergeInboxItems(page.items, this.inboxItems);
+            }
+            else {
+                this.inboxItems = page.items;
+            }
+            if (!preserveTail)
+                this.inboxNextCursor = page.nextCursor;
+            this.inboxScopeLoaded = true;
+        }
+        catch (error) {
+            if (epoch !== this.inboxRequestEpoch)
+                return;
+            this.inboxError = error instanceof Error ? error.message : String(error);
+            throw error;
+        }
+        finally {
+            if (epoch === this.inboxRequestEpoch)
+                this.inboxLoading = false;
+        }
+    }
+    /** Read older history through the selected runtime, not a bounded browser cache. */
+    async loadRoomHistory(cursor, direction = 'before') {
+        const room = this.activeRoomHandle;
+        if (!room)
+            return 0;
+        const epoch = ++this.transcriptEpoch;
+        const visible = this.messages;
+        const rows = await room.messages.list({ cursor, direction, limit: 50 });
+        if (this.activeRoomHandle !== room || epoch !== this.transcriptEpoch)
+            return 0;
+        const snapshot = await room.messages.list();
+        if (this.activeRoomHandle !== room || epoch !== this.transcriptEpoch)
+            return 0;
+        this.transcriptWindowIds = new Set([...visible, ...rows].map((message) => message.id));
+        if (direction === 'after' && rows.length < 50) {
+            this.historyHasNewer = false;
+            this.transcriptTailLive = true;
+        }
+        this.messages = this.projectTranscript(snapshot);
+        return rows.length;
+    }
+    /** Recover the exact selected search result, plus its neighboring context. */
+    async revealMessage(messageId) {
+        const room = this.activeRoomHandle;
+        if (!room)
+            return;
+        const epoch = ++this.transcriptEpoch;
+        const message = await room.messages.get(messageId);
+        if (this.activeRoomHandle !== room || epoch !== this.transcriptEpoch)
+            return;
+        if (!message)
+            throw new Error('This message is no longer available.');
+        const [before, after] = await Promise.all([
+            room.messages.list({ cursor: messageId, direction: 'before', limit: 25 }),
+            room.messages.list({ cursor: messageId, direction: 'after', limit: 25 })
+        ]);
+        if (this.activeRoomHandle !== room || epoch !== this.transcriptEpoch)
+            return;
+        const snapshot = await room.messages.list();
+        if (this.activeRoomHandle !== room || epoch !== this.transcriptEpoch)
+            return;
+        this.transcriptWindowIds = new Set([...before, message, ...after].map((entry) => entry.id));
+        this.historyHasNewer = after.length === 25;
+        this.transcriptTailLive = !this.historyHasNewer;
+        this.historyOlderExhausted = false;
+        this.messages = this.projectTranscript(snapshot);
+    }
+    async showLatestMessages() {
+        const room = this.activeRoomHandle;
+        if (!room)
+            return;
+        const epoch = ++this.transcriptEpoch;
+        const messages = await room.messages.list({ limit: 50 });
+        if (this.activeRoomHandle !== room || epoch !== this.transcriptEpoch)
+            return;
+        // Keep the latest page's lower bound: an obsolete history lookup can
+        // still fill the shared room cache, but cannot expand this selected window.
+        this.transcriptWindowIds = new Set(messages.map((message) => message.id));
+        this.transcriptTailLive = true;
+        this.historyHasNewer = false;
+        this.historyOlderExhausted = false;
+        this.messages = messages;
+    }
+    /**
+     * Prepend one older-history page ahead of the visible window. The scroll
+     * sentinel's entrypoint: guarded against overlap, tracks exhaustion so the
+     * observer can stand down. Returns the rows prepended.
+     */
+    async loadOlderMessages() {
+        if (this.historyLoadingOlder || this.historyOlderExhausted)
+            return 0;
+        const first = this.messages[0];
+        if (!first)
+            return 0;
+        this.historyLoadingOlder = true;
+        try {
+            const rows = await this.loadRoomHistory(first.id, 'before');
+            if (rows < 50)
+                this.historyOlderExhausted = true;
+            return rows;
+        }
+        finally {
+            this.historyLoadingOlder = false;
+        }
+    }
+    /**
+     * Recover a message's omitted tool-call history (consumer tail-marker
+     * projections) and merge it ahead of the visible tail. Returns the calls
+     * recovered; 0 when the runtime has no recovery verb or nothing was cut.
+     */
+    async loadMessageToolHistory(messageId) {
+        const room = this.activeRoomHandle;
+        if (!room)
+            return 0;
+        const recover = room.messages.listToolCalls;
+        if (!recover) {
+            this.toolHistoryError = {
+                ...this.toolHistoryError,
+                [messageId]: 'This runtime does not support tool history recovery.'
+            };
+            return 0;
+        }
+        const message = this.messages.find((entry) => entry.id === messageId);
+        const parsedMetadata = toolHistoryMetadataSchema.safeParse(message?.metadata);
+        const tail = parsedMetadata.success && parsedMetadata.data.toolCalls ? parsedMetadata.data.toolCalls : [];
+        const omitted = parsedMetadata.success && parsedMetadata.data.toolCallHistory?.omitted
+            ? parsedMetadata.data.toolCallHistory.omitted
+            : 0;
+        if (omitted <= 0)
+            return 0;
+        this.toolHistoryLoading = { ...this.toolHistoryLoading, [messageId]: true };
+        this.toolHistoryError = { ...this.toolHistoryError, [messageId]: null };
+        try {
+            const recovered = [];
+            let cursor = toolCallRecordId(tail[0]);
+            // Progress-guaranteed pages, but cap the loop: a confused server
+            // must not spin the UI forever.
+            for (let page = 0; page < 40; page++) {
+                if (this.activeRoomHandle !== room)
+                    return 0;
+                const result = await recover.call(room.messages, messageId, cursor ? { cursor, direction: 'before', limit: 50 } : { limit: 50 });
+                if (result.toolCalls.length === 0)
+                    break;
+                recovered.unshift(...result.toolCalls);
+                if (!result.hasMore)
+                    break;
+                const next = toolCallRecordId(result.toolCalls[0]);
+                if (!next || next === cursor)
+                    break;
+                cursor = next;
+                if (recovered.length >= omitted)
+                    break;
+            }
+            if (this.activeRoomHandle !== room)
+                return 0;
+            const current = this.messages.find((entry) => entry.id === messageId);
+            const parsedCurrent = toolHistoryMetadataSchema.safeParse(current?.metadata);
+            const currentTail = parsedCurrent.success && parsedCurrent.data.toolCalls ? parsedCurrent.data.toolCalls : tail;
+            const currentMetadata = current?.metadata;
+            const restMetadata = currentMetadata ? { ...currentMetadata } : {};
+            if ('toolCallHistory' in restMetadata) {
+                delete restMetadata.toolCallHistory;
+            }
+            const merged = {
+                ...(current ?? message),
+                metadata: { ...restMetadata, toolCalls: [...recovered, ...currentTail] }
+            };
+            this.messages = this.messages.map((entry) => (entry.id === messageId ? merged : entry));
+            return recovered.length;
+        }
+        catch (error) {
+            this.toolHistoryFailure = CaughtFailureSchema.parse(error);
+            if (this.activeRoomHandle !== room)
+                return 0;
+            this.recordToolHistoryError(messageId, CaughtFailureSchema.parse(error));
+            return 0;
+        }
+        finally {
+            if (this.activeRoomHandle === room) {
+                this.toolHistoryLoading = { ...this.toolHistoryLoading, [messageId]: false };
+            }
+        }
+    }
+    recordToolHistoryError(messageId, error) {
+        const failure = valueFreeFailure(error);
+        this.toolHistoryError = {
+            ...this.toolHistoryError,
+            [messageId]: failure.reason ?? failure.name ?? 'Tool history error'
+        };
+    }
+    recordBackgroundProcessesFailure(error) {
+        const failure = valueFreeFailure(error);
+        this.backgroundProcessesError = failure.reason ?? failure.name ?? 'Background processes error';
+    }
+    recordInboxWatchFailure(error) {
+        const failure = valueFreeFailure(error);
+        this.inboxError = failure.reason ?? failure.name ?? 'Inbox watch error';
+    }
+    /** Load the active room's background processes, probing runtime support. */
+    async loadBackgroundProcesses() {
+        const client = this.requireClient();
+        const roomId = this.activeRoomId;
+        if (!roomId) {
+            this.backgroundProcesses = [];
+            this.backgroundProcessesErrors = [];
+            return;
+        }
+        if (!client.listRoomBackgroundProcesses) {
+            this.backgroundProcessesSupported = false;
+            this.backgroundProcesses = [];
+            this.backgroundProcessesErrors = [];
+            return;
+        }
+        this.backgroundProcessesSupported = true;
+        this.backgroundProcessesLoading = true;
+        this.backgroundProcessesError = null;
+        try {
+            const view = await client.listRoomBackgroundProcesses(roomId);
+            if (this.activeRoomId !== roomId)
+                return;
+            this.backgroundProcesses = view.processes;
+            this.backgroundProcessesErrors = view.errors;
+        }
+        catch (error) {
+            if (this.activeRoomId !== roomId)
+                return;
+            this.recordBackgroundProcessesFailure(CaughtFailureSchema.parse(error));
+        }
+        finally {
+            if (this.activeRoomId === roomId)
+                this.backgroundProcessesLoading = false;
+        }
+    }
+    /**
+     * Stop one background process and refresh the panel. False when the
+     * runtime cannot stop or the proc is already gone.
+     */
+    async stopBackgroundProcess(procId, signal) {
+        const client = this.requireClient();
+        const proc = this.backgroundProcesses.find((entry) => entry.procId === procId);
+        if (!client.stopBackgroundProcess || !proc) {
+            this.backgroundProcessesError = 'This runtime does not support stopping background processes.';
+            return false;
+        }
+        if (proc.running !== true) {
+            this.backgroundProcessesError = proc.running === null
+                ? 'Process liveness is unknown. Refresh before requesting a signal.'
+                : 'This process has already exited.';
+            return false;
+        }
+        try {
+            const stopped = await client.stopBackgroundProcess(proc.sessionId, procId, signal);
+            await this.loadBackgroundProcesses();
+            return stopped;
+        }
+        catch (error) {
+            this.recordBackgroundProcessesFailure(CaughtFailureSchema.parse(error));
+            return false;
+        }
+    }
+    projectTranscript(messages) {
+        if (!this.transcriptWindowIds)
+            return messages.slice(-50);
+        if (this.transcriptTailLive) {
+            const start = messages.findIndex((message) => this.transcriptWindowIds.has(message.id));
+            return start < 0 ? [] : messages.slice(start);
+        }
+        return messages.filter((message) => this.transcriptWindowIds.has(message.id));
+    }
+    /** Keep the mixed feed current through one owner-level transport. */
+    watchInbox() {
+        const client = this.requireClient();
+        if (this.inboxUnsub || !client.inbox)
+            return;
+        this.inboxUnsub = client.inbox.subscribe(() => {
+            if (this.inboxRefreshTimer)
+                clearTimeout(this.inboxRefreshTimer);
+            this.inboxRefreshTimer = setTimeout(() => {
+                this.inboxRefreshTimer = null;
+                void this.loadInbox({ limit: Math.min(100, Math.max(50, this.inboxItems.length)), ...this.inboxScope }, { preserveTail: true }).catch((error) => {
+                    this.recordInboxWatchFailure(CaughtFailureSchema.parse(error));
+                });
+            }, 150);
+        });
+    }
+    stopWatchingInbox() {
+        this.inboxUnsub?.();
+        this.inboxUnsub = null;
+        if (this.inboxRefreshTimer)
+            clearTimeout(this.inboxRefreshTimer);
+        this.inboxRefreshTimer = null;
+    }
+    /**
+     * Update the tool policy snapshot. Useful when the room's policy changes
+     * out-of-band (e.g. via a settings dialog in the home app).
+     */
+    setToolPolicy(policy) {
+        this.toolPolicy = policy;
+    }
+    dispose() {
+        this.initEpoch += 1;
+        this.roomRequestEpoch += 1;
+        this.transcriptEpoch += 1;
+        // Any list request that resolves after disposal belongs to the previous
+        // client/owner scope and must not repopulate this projection.
+        this.inboxRequestEpoch += 1;
+        this.disposeRoomSubs();
+        this.stopWatchingRooms();
+        this.stopWatchingInbox();
+        this.roomsUnsub?.();
+        this.roomsUnsub = null;
+        this.client = null;
+        this.roomWatch = null;
+        this.activeRoomHandle = null;
+        this.inflight = null;
+        this.initialized = false;
+        this.rooms = [];
+        this.activeRoom = null;
+        this.messages = [];
+        this.participants = [];
+        this.inboxItems = [];
+        this.inboxNextCursor = null;
+        this.inboxLoading = false;
+        this.inboxError = null;
+        this.inboxScope = {};
+        this.inboxScopeLoaded = false;
+        this.toolPolicy = null;
+        this.error = null;
+        this.resetRoomScopedPaging();
+    }
+    /** Room-scoped paging/recovery/panel state; cleared on room switch. */
+    resetRoomScopedPaging() {
+        this.historyLoadingOlder = false;
+        this.historyOlderExhausted = false;
+        this.toolHistoryLoading = {};
+        this.toolHistoryError = {};
+        this.backgroundProcesses = [];
+        this.backgroundProcessesErrors = [];
+        this.backgroundProcessesLoading = false;
+        this.backgroundProcessesError = null;
+        this.backgroundProcessesSupported = null;
+    }
+    async activateRoom(roomId, epoch = ++this.roomRequestEpoch) {
+        const client = this.requireClient();
+        this.disposeRoomSubs();
+        const room = await client.rooms.get(roomId);
+        if (epoch !== this.roomRequestEpoch)
+            return;
+        if (!room)
+            throw new Error('This conversation could not be loaded.');
+        const messages = await room.messages.list();
+        if (epoch !== this.roomRequestEpoch)
+            return;
+        const participants = await room.participants.list();
+        if (epoch !== this.roomRequestEpoch)
+            return;
+        this.activeRoomHandle = room;
+        this.transcriptWindowIds = null;
+        this.transcriptTailLive = true;
+        this.historyHasNewer = false;
+        this.resetRoomScopedPaging();
+        this.activeRoom = room.data;
+        this.messages = this.projectTranscript(messages);
+        this.participants = participants;
+        this.messagesUnsub = room.messages.subscribe((messages) => {
+            if (epoch === this.roomRequestEpoch)
+                this.messages = this.projectTranscript(messages);
+        });
+        this.participantsUnsub = room.participants.subscribe((participants) => {
+            if (epoch === this.roomRequestEpoch)
+                this.participants = participants;
+        });
+    }
+    disposeRoomSubs() {
+        this.messagesUnsub?.();
+        this.messagesUnsub = null;
+        this.participantsUnsub?.();
+        this.participantsUnsub = null;
+        this.activeRoomHandle = null;
+    }
+    requireClient() {
+        if (!this.client) {
+            throw new Error('chatState client is not initialized. Mount <ChatLoader /> at the layout level.');
+        }
+        return this.client;
+    }
+}
+export const chatState = contextualChatStore('chatState');