@beeuni/sdk 0.1.0

package/dist/browser/stores/sync-store.js

@@ -0,0 +1,1336 @@
+"use client";
+import { create } from "zustand";
+import { commitSessionRewind, isWithinRewindWindow, stageSessionRewind, } from "../../core/session/rewind.js";
+import { isRetryableTurnError } from "../../core/turns/open-turn.js";
+import { ascendingId } from "./sync-store/ascending-id.js";
+import { Binary } from "./sync-store/binary.js";
+import { DELTA_EVENT_TAIL_LIMIT } from "./sync-store/delta-event-window.js";
+import { reconcileHydratedParts } from "./sync-store/reconcile-parts.js";
+export { ascendingId, Binary };
+export function sameSessionStatus(a, b) {
+    if (a === b)
+        return true;
+    if (!a || !b)
+        return false;
+    if (a.type !== b.type)
+        return false;
+    if (a.type !== "retry" || b.type !== "retry")
+        return true;
+    return a.attempt === b.attempt && a.message === b.message && a.next === b.next;
+}
+function syntheticEventOrigin(event) {
+    return event?.synthetic === true
+        ? "local"
+        : "wire";
+}
+function isTextLikePart(part) {
+    return part.type === "text" || part.type === "reasoning";
+}
+const ACTIVITY_STAMP_RESOLUTION_MS = 1_000;
+function isOpenMessage(info) {
+    if (info?.role !== "assistant")
+        return false;
+    const { time, error } = info;
+    return !time?.completed && !error;
+}
+function isOpenPart(part) {
+    if (part.type === "step-finish" || part.type === "patch")
+        return false;
+    if (part.type === "tool") {
+        const status = part.state?.status;
+        return status !== "completed" && status !== "error";
+    }
+    return !part.time?.end;
+}
+function indexOfId(list, id, idOf) {
+    const result = Binary.search(list, id, idOf);
+    if (result.found && list[result.index] !== undefined && idOf(list[result.index]) === id) {
+        return result.index;
+    }
+    return list.findIndex((item) => idOf(item) === id);
+}
+function insertIndexByTime(list, message) {
+    const created = message.time?.created;
+    if (created === undefined)
+        return list.length;
+    for (let index = 0; index < list.length; index++) {
+        const other = list[index].time?.created;
+        if (other === undefined)
+            continue;
+        if (other > created)
+            return index;
+        if (other === created && list[index].id > message.id)
+            return index;
+    }
+    return list.length;
+}
+const optimisticIds = new Map();
+const dispatchedOptimisticIds = new Map();
+const inboxBackedOptimisticIds = new Map();
+const optimisticEchoes = new Map();
+const optimisticOrigins = new Map();
+const controlPlaneOwnedIds = new Map();
+const cancelledMessageIds = new Map();
+const cacheSourcedIds = new Map();
+export function hasOnlyCacheSourcedMessages(sessionID) {
+    const messages = useSyncStore.getState().messages[sessionID];
+    if (!messages || messages.length === 0)
+        return false;
+    const cached = cacheSourcedIds.get(sessionID);
+    if (!cached)
+        return false;
+    return messages.every((message) => cached.has(message.id));
+}
+function recordOptimisticEcho(sessionID, optimisticID, echoID) {
+    if (optimisticID === echoID)
+        return;
+    const origin = optimisticOrigins.get(sessionID)?.get(optimisticID) ?? optimisticID;
+    let fwd = optimisticEchoes.get(sessionID);
+    if (!fwd)
+        optimisticEchoes.set(sessionID, (fwd = new Map()));
+    fwd.set(origin, echoID);
+    if (origin !== optimisticID)
+        fwd.set(optimisticID, echoID);
+    let rev = optimisticOrigins.get(sessionID);
+    if (!rev)
+        optimisticOrigins.set(sessionID, (rev = new Map()));
+    rev.set(echoID, origin);
+}
+function releaseOptimisticId(sessionID, id) {
+    untrackId(optimisticIds, sessionID, id);
+    untrackId(dispatchedOptimisticIds, sessionID, id);
+    untrackId(inboxBackedOptimisticIds, sessionID, id);
+}
+function releaseConfirmedOptimisticId(sessionID, optimisticID, echoID) {
+    if (hasTrackedId(inboxBackedOptimisticIds, sessionID, optimisticID)) {
+        trackId(controlPlaneOwnedIds, sessionID, echoID);
+    }
+    releaseOptimisticId(sessionID, optimisticID);
+}
+function trackId(store, sessionID, id) {
+    const bucket = store.get(sessionID);
+    if (bucket)
+        bucket.add(id);
+    else
+        store.set(sessionID, new Set([id]));
+}
+function untrackId(store, sessionID, id) {
+    const bucket = store.get(sessionID);
+    if (!bucket)
+        return;
+    bucket.delete(id);
+    if (bucket.size === 0)
+        store.delete(sessionID);
+}
+function hasTrackedId(store, sessionID, id) {
+    return store.get(sessionID)?.has(id) ?? false;
+}
+function forgetSessionIds(sessionID) {
+    optimisticIds.delete(sessionID);
+    dispatchedOptimisticIds.delete(sessionID);
+    inboxBackedOptimisticIds.delete(sessionID);
+    optimisticEchoes.delete(sessionID);
+    optimisticOrigins.delete(sessionID);
+    controlPlaneOwnedIds.delete(sessionID);
+    cacheSourcedIds.delete(sessionID);
+    cancelledMessageIds.delete(sessionID);
+    sessionMessageRows.delete(sessionID);
+    deltaActiveParts.delete(sessionID);
+    bridgedPartIds.delete(sessionID);
+    deltaEventTails.delete(sessionID);
+    stubAssistantIds.delete(sessionID);
+}
+const isOptimistic = (sessionID, messageID) => hasTrackedId(optimisticIds, sessionID, messageID);
+const isDispatched = (sessionID, messageID) => hasTrackedId(dispatchedOptimisticIds, sessionID, messageID);
+const awaitsUserEcho = (sessionID, messageID) => {
+    if (optimisticOrigins.get(sessionID)?.has(messageID))
+        return true;
+    const pending = optimisticIds.get(sessionID);
+    if (!pending)
+        return false;
+    for (const id of pending) {
+        if (!isDispatched(sessionID, id))
+            continue;
+        if (optimisticEchoes.get(sessionID)?.get(id))
+            continue;
+        return true;
+    }
+    return false;
+};
+const bridgedPartIds = new Map();
+const deltaActiveParts = new Map();
+const deltaEventTails = new Map();
+const stubAssistantIds = new Map();
+function trackStub(sessionID, stubId, parentId) {
+    const bucket = stubAssistantIds.get(sessionID);
+    if (bucket)
+        bucket.set(stubId, parentId);
+    else
+        stubAssistantIds.set(sessionID, new Map([[stubId, parentId]]));
+}
+function untrackStub(sessionID, stubId) {
+    const bucket = stubAssistantIds.get(sessionID);
+    if (!bucket)
+        return;
+    bucket.delete(stubId);
+    if (bucket.size === 0)
+        stubAssistantIds.delete(sessionID);
+}
+const stubIdFor = (userId) => `${userId}_error`;
+const isStubShaped = (id) => id.endsWith("_error");
+function findAssistantForTurn(messages, parentId) {
+    const parentCreated = parentId
+        ? messages.find((m) => m.id === parentId)?.time?.created
+        : undefined;
+    return messages.findIndex((m) => m.role === "assistant" &&
+        !isStubShaped(m.id) &&
+        (!parentId ||
+            m.parentID === parentId ||
+            (!m.parentID &&
+                parentCreated !== undefined &&
+                m.time?.created !== undefined &&
+                m.time.created >= parentCreated)));
+}
+function hasAssistantForTurn(messages, parentId) {
+    return findAssistantForTurn(messages, parentId) !== -1;
+}
+function rekeyStubParent(sessionID, list, fromId, toId) {
+    const bucket = stubAssistantIds.get(sessionID);
+    if (!bucket)
+        return list;
+    const moved = [...bucket.entries()].filter(([, parentId]) => parentId === fromId);
+    if (moved.length === 0)
+        return list;
+    let next = [...list];
+    for (const [stubId] of moved) {
+        untrackStub(sessionID, stubId);
+        const idx = next.findIndex((m) => m.id === stubId);
+        if (idx === -1)
+            continue;
+        const nextId = stubIdFor(toId);
+        trackStub(sessionID, nextId, toId);
+        const rekeyed = { ...next[idx], id: nextId, parentID: toId };
+        next.splice(idx, 1);
+        const parentIdx = next.findIndex((m) => m.id === toId);
+        if (parentIdx === -1)
+            next = [...next, rekeyed];
+        else
+            next.splice(parentIdx + 1, 0, rekeyed);
+    }
+    return next;
+}
+const DETACHED_SESSION_LIMIT = 8;
+const MESSAGE_ROWS_LIMIT = 20;
+const sessionMessageRows = new Map();
+const EMPTY_MESSAGE_ROWS = [];
+function touchSessionMessageRows(sessionID, entry) {
+    sessionMessageRows.delete(sessionID);
+    sessionMessageRows.set(sessionID, entry);
+    if (sessionMessageRows.size > MESSAGE_ROWS_LIMIT) {
+        const leastRecentlyUsed = sessionMessageRows.keys().next().value;
+        if (leastRecentlyUsed)
+            sessionMessageRows.delete(leastRecentlyUsed);
+    }
+}
+const sessionConsumers = new Map();
+const detachedSessions = new Set();
+const evictedSessions = new Set();
+function deleteOrphanPartBuckets(parts, sessionIDs) {
+    const dropped = new Set(sessionIDs);
+    for (const messageID of Object.keys(parts)) {
+        const bucket = parts[messageID];
+        if (!bucket || bucket.length === 0)
+            continue;
+        const owner = bucket[0].sessionID;
+        if (!owner || !dropped.has(owner))
+            continue;
+        if (bucket.every((part) => part.sessionID === owner))
+            delete parts[messageID];
+    }
+}
+function dropSessionData(state, sessionIDs) {
+    const messages = { ...state.messages };
+    const parts = { ...state.parts };
+    const diffs = { ...state.diffs };
+    const todos = { ...state.todos };
+    for (const sessionID of sessionIDs) {
+        for (const message of messages[sessionID] ?? [])
+            delete parts[message.id];
+        delete messages[sessionID];
+        delete diffs[sessionID];
+        delete todos[sessionID];
+    }
+    deleteOrphanPartBuckets(parts, sessionIDs);
+    return { messages, parts, sessionStatus: state.sessionStatus, diffs, todos };
+}
+function pruneDetachedSessions(messages) {
+    const evicted = [];
+    while (detachedSessions.size > DETACHED_SESSION_LIMIT) {
+        const oldest = detachedSessions.values().next().value;
+        if (oldest === undefined)
+            break;
+        detachedSessions.delete(oldest);
+        evicted.push(oldest);
+    }
+    for (const sessionID of evictedSessions) {
+        if (sessionConsumers.has(sessionID) || detachedSessions.has(sessionID))
+            continue;
+        if (sessionID in messages)
+            evicted.push(sessionID);
+    }
+    return evicted;
+}
+function appendPartDeltas(sessionID, messageID, partID, field, pieces) {
+    trackId(deltaActiveParts, sessionID, partID);
+    let applied = false;
+    useSyncStore.setState((s) => {
+        const list = s.parts[messageID];
+        if (!list)
+            return s;
+        const result = Binary.search(list, partID, (p) => p.id);
+        if (!result.found)
+            return s;
+        let delta = "";
+        for (const piece of pieces) {
+            if (piece.id) {
+                const tailKey = `${messageID}:${partID}:${field}`;
+                let sessionTails = deltaEventTails.get(sessionID);
+                if (!sessionTails) {
+                    sessionTails = new Map();
+                    deltaEventTails.set(sessionID, sessionTails);
+                }
+                let appliedIds = sessionTails.get(tailKey);
+                if (appliedIds?.has(piece.id))
+                    continue;
+                if (!appliedIds) {
+                    appliedIds = new Set();
+                    sessionTails.set(tailKey, appliedIds);
+                }
+                appliedIds.add(piece.id);
+                if (appliedIds.size > DELTA_EVENT_TAIL_LIMIT) {
+                    const oldest = appliedIds.values().next().value;
+                    if (oldest !== undefined)
+                        appliedIds.delete(oldest);
+                }
+            }
+            delta += piece.delta;
+            applied = true;
+        }
+        if (!applied)
+            return s;
+        const next = [...list];
+        const part = { ...next[result.index] };
+        const existing = part[field];
+        part[field] = (existing ?? "") + delta;
+        next[result.index] = part;
+        return { parts: { ...s.parts, [messageID]: next } };
+    });
+    if (applied)
+        useSyncStore.getState().noteSessionActivity(sessionID);
+}
+export const useSyncStore = create()((set, get) => ({
+    messages: {},
+    parts: {},
+    sessionStatus: {},
+    sessionStatusOrigin: {},
+    sessionStatusAt: {},
+    sessionActivityAt: {},
+    diffs: {},
+    todos: {},
+    sessionRevert: {},
+    sessionRevertNeedsTailReconcile: {},
+    get statuses() {
+        return get().sessionStatus;
+    },
+    upsertMessage: (sessionID, message) => set((s) => {
+        const list = s.messages[sessionID] ?? [];
+        const result = Binary.search(list, message.id, (m) => m.id);
+        const bsValid = result.found && list[result.index]?.id === message.id;
+        if (bsValid) {
+            const next = [...list];
+            next[result.index] = message;
+            return { messages: { ...s.messages, [sessionID]: next } };
+        }
+        const linearIdx = list.findIndex((m) => m.id === message.id);
+        if (linearIdx !== -1) {
+            const next = [...list];
+            next[linearIdx] = message;
+            return { messages: { ...s.messages, [sessionID]: next } };
+        }
+        const next = [...list];
+        next.splice(insertIndexByTime(next, message), 0, message);
+        return { messages: { ...s.messages, [sessionID]: next } };
+    }),
+    removeMessage: (sessionID, messageID) => set((s) => {
+        const list = s.messages[sessionID];
+        if (!list)
+            return s;
+        const result = Binary.search(list, messageID, (m) => m.id);
+        const idx = (result.found && list[result.index]?.id === messageID)
+            ? result.index
+            : list.findIndex((m) => m.id === messageID);
+        if (idx === -1)
+            return s;
+        const next = [...list];
+        next.splice(idx, 1);
+        const { [messageID]: _, ...restParts } = s.parts;
+        return {
+            messages: { ...s.messages, [sessionID]: next },
+            parts: restParts,
+        };
+    }),
+    upsertPart: (messageID, part, sessionID) => set((s) => {
+        const partSessionID = sessionID ?? part.sessionID;
+        let list;
+        let bridgeCleared = false;
+        if (hasTrackedId(bridgedPartIds, partSessionID, messageID)) {
+            untrackId(bridgedPartIds, partSessionID, messageID);
+            list = [];
+            bridgeCleared = true;
+        }
+        else {
+            list = s.parts[messageID] ?? [];
+        }
+        const result = Binary.search(list, part.id, (p) => p.id);
+        if (result.found) {
+            const prev = list[result.index];
+            const prevIsTextLike = isTextLikePart(prev);
+            const incomingIsTextLike = isTextLikePart(part);
+            const tracksStreamingText = prevIsTextLike && incomingIsTextLike;
+            const prevText = prevIsTextLike ? prev.text : null;
+            const incomingText = incomingIsTextLike ? part.text : null;
+            if (tracksStreamingText &&
+                prevText !== null &&
+                incomingText !== null &&
+                prevText.length > 0) {
+                const isPrefixGrowth = incomingText.startsWith(prevText);
+                if (!isPrefixGrowth) {
+                    if (!bridgeCleared)
+                        return s;
+                    const next = [...list];
+                    next[result.index] = prev;
+                    return { parts: { ...s.parts, [messageID]: next } };
+                }
+            }
+        }
+        const next = [...list];
+        if (result.found) {
+            next[result.index] = part;
+        }
+        else {
+            if (hasTrackedId(deltaActiveParts, partSessionID, part.id) && isTextLikePart(part)) {
+                const allParts = Object.values(s.parts);
+                for (const pl of allParts) {
+                    if (pl && pl.some((p) => p.id === part.id)) {
+                        return s;
+                    }
+                }
+            }
+            next.splice(result.index, 0, part);
+        }
+        return { parts: { ...s.parts, [messageID]: next } };
+    }),
+    removePart: (messageID, partID) => set((s) => {
+        const list = s.parts[messageID];
+        if (!list)
+            return s;
+        const result = Binary.search(list, partID, (p) => p.id);
+        if (!result.found)
+            return s;
+        const next = [...list];
+        next.splice(result.index, 1);
+        if (next.length === 0) {
+            const { [messageID]: _, ...restParts } = s.parts;
+            return { parts: restParts };
+        }
+        return { parts: { ...s.parts, [messageID]: next } };
+    }),
+    applyPartDelta: (sessionID, messageID, partID, field, delta, eventID) => appendPartDeltas(sessionID, messageID, partID, field, [{ id: eventID, delta }]),
+    setStatus: (sessionID, status, origin = "wire") => set((s) => {
+        if (sameSessionStatus(s.sessionStatus[sessionID], status)) {
+            if ((s.sessionStatusOrigin[sessionID] ?? "wire") === origin)
+                return s;
+            return {
+                sessionStatusOrigin: { ...s.sessionStatusOrigin, [sessionID]: origin },
+                sessionStatusAt: { ...s.sessionStatusAt, [sessionID]: Date.now() },
+            };
+        }
+        return {
+            sessionStatus: { ...s.sessionStatus, [sessionID]: status },
+            sessionStatusOrigin: { ...s.sessionStatusOrigin, [sessionID]: origin },
+            sessionStatusAt: { ...s.sessionStatusAt, [sessionID]: Date.now() },
+        };
+    }),
+    setDiff: (sessionID, diffs) => set((s) => ({
+        diffs: { ...s.diffs, [sessionID]: diffs },
+    })),
+    setTodo: (sessionID, todos) => set((s) => ({
+        todos: { ...s.todos, [sessionID]: todos },
+    })),
+    stageSessionRevert: (sessionId, messageId) => set((s) => {
+        const current = s.sessionRevert[sessionId];
+        if (current?.staged && current.messageId === messageId)
+            return s;
+        return {
+            sessionRevert: {
+                ...s.sessionRevert,
+                [sessionId]: stageSessionRewind(get().getMessages(sessionId), messageId),
+            },
+        };
+    }),
+    commitSessionRevert: (sessionId) => set((s) => {
+        const current = s.sessionRevert[sessionId] ?? null;
+        const next = commitSessionRewind(current);
+        if (next === current)
+            return s;
+        return { sessionRevert: { ...s.sessionRevert, [sessionId]: next } };
+    }),
+    clearSessionRevert: (sessionId) => set((s) => {
+        if (!s.sessionRevert[sessionId])
+            return s;
+        return { sessionRevert: { ...s.sessionRevert, [sessionId]: null } };
+    }),
+    applyCommittedRevert: (sessionId, boundaryId, watermark, hiddenIds) => set((s) => {
+        const list = s.messages[sessionId];
+        if (!list || list.length === 0) {
+            return { sessionRevert: { ...s.sessionRevert, [sessionId]: null } };
+        }
+        const rewind = {
+            messageId: boundaryId,
+            watermark,
+            ...(hiddenIds ? { hiddenIds } : {}),
+            staged: false,
+        };
+        const removedIds = [];
+        const kept = list.filter((m) => {
+            if (isWithinRewindWindow(m.id, rewind)) {
+                removedIds.push(m.id);
+                return false;
+            }
+            return true;
+        });
+        const nextParts = { ...s.parts };
+        for (const id of removedIds)
+            delete nextParts[id];
+        return {
+            messages: { ...s.messages, [sessionId]: kept },
+            parts: nextParts,
+            sessionRevert: { ...s.sessionRevert, [sessionId]: null },
+        };
+    }),
+    markSessionRevertNeedsTailReconcile: (sessionId) => set((s) => {
+        if (s.sessionRevertNeedsTailReconcile[sessionId])
+            return s;
+        return {
+            sessionRevertNeedsTailReconcile: {
+                ...s.sessionRevertNeedsTailReconcile,
+                [sessionId]: true,
+            },
+        };
+    }),
+    clearSessionRevertNeedsTailReconcile: (sessionId) => set((s) => {
+        if (!s.sessionRevertNeedsTailReconcile[sessionId])
+            return s;
+        const { [sessionId]: _, ...rest } = s.sessionRevertNeedsTailReconcile;
+        return { sessionRevertNeedsTailReconcile: rest };
+    }),
+    syncSessionRevertFromInfo: (sessionId, revert) => {
+        if (!revert?.messageID)
+            return;
+        const current = get().sessionRevert[sessionId];
+        if (current === null)
+            return;
+        if (current?.messageId === revert.messageID)
+            return;
+        get().stageSessionRevert(sessionId, revert.messageID);
+    },
+    optimisticAdd: (sessionID, message, messageParts) => {
+        trackId(optimisticIds, sessionID, message.id);
+        evictedSessions.delete(sessionID);
+        set((s) => {
+            const list = s.messages[sessionID] ?? [];
+            const nextMsgs = [...list.filter((m) => m.id !== message.id), message];
+            const sorted = messageParts
+                .filter((p) => !!p?.id)
+                .sort((a, b) => (a.id < b.id ? -1 : a.id > b.id ? 1 : 0));
+            return {
+                messages: { ...s.messages, [sessionID]: nextMsgs },
+                parts: { ...s.parts, [message.id]: sorted },
+            };
+        });
+    },
+    markOptimisticDispatched: (sessionID, messageID) => {
+        if (isOptimistic(sessionID, messageID))
+            trackId(dispatchedOptimisticIds, sessionID, messageID);
+    },
+    markOptimisticInboxBacked: (sessionID, messageID) => {
+        if (isOptimistic(sessionID, messageID))
+            trackId(inboxBackedOptimisticIds, sessionID, messageID);
+    },
+    optimisticEchoOf: (sessionID, optimisticID) => optimisticEchoes.get(sessionID)?.get(optimisticID),
+    optimisticOriginOf: (sessionID, echoID) => optimisticOrigins.get(sessionID)?.get(echoID),
+    isOptimisticMessage: (sessionID, messageID) => isOptimistic(sessionID, messageID),
+    forgetControlPlaneMessage: (sessionID, messageID) => {
+        untrackId(controlPlaneOwnedIds, sessionID, messageID);
+        releaseOptimisticId(sessionID, messageID);
+        trackId(cancelledMessageIds, sessionID, messageID);
+        get().removeMessage(sessionID, messageID);
+    },
+    registerOptimisticEcho: (sessionID, optimisticID, echoID) => {
+        if (optimisticID === echoID)
+            return;
+        const live = isOptimistic(sessionID, optimisticID)
+            ? optimisticID
+            : optimisticEchoes.get(sessionID)?.get(optimisticID);
+        if (!live || live === echoID || !isOptimistic(sessionID, live))
+            return;
+        recordOptimisticEcho(sessionID, live, echoID);
+        if (!get().messages[sessionID]?.some((m) => m.id === echoID))
+            return;
+        releaseConfirmedOptimisticId(sessionID, live, echoID);
+        set((s) => {
+            const list = s.messages[sessionID] ?? [];
+            if (!list.some((m) => m.id === live))
+                return s;
+            let next = list.filter((m) => m.id !== live);
+            next = rekeyStubParent(sessionID, next, live, echoID);
+            const newParts = { ...s.parts };
+            const bridge = newParts[live];
+            delete newParts[live];
+            if (bridge?.length && !newParts[echoID]?.length) {
+                newParts[echoID] = bridge;
+                trackId(bridgedPartIds, sessionID, echoID);
+            }
+            return { messages: { ...s.messages, [sessionID]: next }, parts: newParts };
+        });
+    },
+    reclaimRemovedMessage: (sessionID, messageID) => {
+        if (!hasTrackedId(controlPlaneOwnedIds, sessionID, messageID))
+            return false;
+        const list = get().messages[sessionID];
+        const message = list?.find((m) => m.id === messageID);
+        if (!message || message.role !== "user")
+            return false;
+        untrackId(controlPlaneOwnedIds, sessionID, messageID);
+        trackId(optimisticIds, sessionID, messageID);
+        trackId(dispatchedOptimisticIds, sessionID, messageID);
+        trackId(inboxBackedOptimisticIds, sessionID, messageID);
+        return true;
+    },
+    optimisticRemove: (sessionID, messageID) => {
+        if (!isOptimistic(sessionID, messageID))
+            return;
+        releaseOptimisticId(sessionID, messageID);
+        set((s) => {
+            const list = s.messages[sessionID];
+            if (!list)
+                return s;
+            const idx = list.findIndex((m) => m.id === messageID);
+            if (idx === -1)
+                return s;
+            const nextMsgs = [...list];
+            nextMsgs.splice(idx, 1);
+            const { [messageID]: _, ...restParts } = s.parts;
+            return {
+                messages: { ...s.messages, [sessionID]: nextMsgs },
+                parts: restParts,
+            };
+        });
+    },
+    noteSessionActivity: (sessionID, atMs) => {
+        if (!sessionID)
+            return;
+        const now = atMs ?? Date.now();
+        const previous = get().sessionActivityAt[sessionID];
+        if (previous !== undefined && now - previous < ACTIVITY_STAMP_RESOLUTION_MS)
+            return;
+        set((s) => ({ sessionActivityAt: { ...s.sessionActivityAt, [sessionID]: now } }));
+    },
+    clearOptimisticMessages: (sessionID) => {
+        set((s) => {
+            const list = s.messages[sessionID];
+            if (!list)
+                return s;
+            const optIds = list
+                .filter((m) => isOptimistic(sessionID, m.id) &&
+                !hasTrackedId(inboxBackedOptimisticIds, sessionID, m.id))
+                .map((m) => m.id);
+            if (optIds.length === 0)
+                return s;
+            for (const id of optIds)
+                releaseOptimisticId(sessionID, id);
+            const filtered = list.filter((m) => !optIds.includes(m.id));
+            const newParts = { ...s.parts };
+            for (const id of optIds)
+                delete newParts[id];
+            return {
+                messages: { ...s.messages, [sessionID]: filtered },
+                parts: newParts,
+            };
+        });
+    },
+    clearSession: (sessionID) => set((s) => {
+        forgetSessionIds(sessionID);
+        evictedSessions.delete(sessionID);
+        const existingMessages = s.messages[sessionID] ?? [];
+        const nextParts = { ...s.parts };
+        for (const message of existingMessages)
+            delete nextParts[message.id];
+        deleteOrphanPartBuckets(nextParts, [sessionID]);
+        const nextActivity = { ...s.sessionActivityAt };
+        delete nextActivity[sessionID];
+        return {
+            messages: { ...s.messages, [sessionID]: [] },
+            parts: nextParts,
+            sessionActivityAt: nextActivity,
+            sessionStatus: { ...s.sessionStatus, [sessionID]: { type: "idle" } },
+            sessionStatusOrigin: { ...s.sessionStatusOrigin, [sessionID]: "local" },
+            sessionStatusAt: { ...s.sessionStatusAt, [sessionID]: Date.now() },
+            diffs: { ...s.diffs, [sessionID]: [] },
+            todos: { ...s.todos, [sessionID]: [] },
+            sessionRevert: { ...s.sessionRevert, [sessionID]: null },
+            sessionRevertNeedsTailReconcile: (() => {
+                const { [sessionID]: _, ...rest } = s.sessionRevertNeedsTailReconcile;
+                return rest;
+            })(),
+        };
+    }),
+    retainSession: (sessionID) => {
+        if (!sessionID)
+            return () => { };
+        detachedSessions.delete(sessionID);
+        sessionConsumers.set(sessionID, (sessionConsumers.get(sessionID) ?? 0) + 1);
+        const evicted = pruneDetachedSessions(get().messages);
+        if (evicted.length > 0) {
+            for (const id of evicted) {
+                forgetSessionIds(id);
+                evictedSessions.add(id);
+            }
+            set((s) => dropSessionData(s, evicted));
+        }
+        let released = false;
+        return () => {
+            if (released)
+                return;
+            released = true;
+            const held = sessionConsumers.get(sessionID);
+            if (held === undefined)
+                return;
+            if (held > 1) {
+                sessionConsumers.set(sessionID, held - 1);
+                return;
+            }
+            sessionConsumers.delete(sessionID);
+            detachedSessions.delete(sessionID);
+            detachedSessions.add(sessionID);
+        };
+    },
+    wasTranscriptEvicted: (sessionID) => evictedSessions.has(sessionID),
+    buildSessionMessages: (sessionID, msgs, parts) => {
+        if (!msgs || msgs.length === 0)
+            return EMPTY_MESSAGE_ROWS;
+        const cached = sessionMessageRows.get(sessionID);
+        if (cached && cached.msgs === msgs) {
+            let same = cached.partRefs.length === msgs.length;
+            if (same) {
+                for (let i = 0; i < msgs.length; i++) {
+                    if (parts[msgs[i].id] !== cached.partRefs[i]) {
+                        same = false;
+                        break;
+                    }
+                }
+            }
+            if (same) {
+                touchSessionMessageRows(sessionID, cached);
+                return cached.result;
+            }
+        }
+        let previousById = null;
+        const partRefs = [];
+        const result = [];
+        for (let i = 0; i < msgs.length; i++) {
+            const info = msgs[i];
+            const messageParts = parts[info.id];
+            partRefs.push(messageParts);
+            let reuse;
+            const aligned = cached?.result[i];
+            if (aligned && aligned.info === info) {
+                if (cached.partRefs[i] === messageParts)
+                    reuse = aligned;
+            }
+            else if (cached) {
+                if (!previousById) {
+                    previousById = new Map();
+                    for (let j = 0; j < cached.result.length; j++) {
+                        previousById.set(cached.result[j].info.id, {
+                            row: cached.result[j],
+                            partRef: cached.partRefs[j],
+                        });
+                    }
+                }
+                const previous = previousById.get(info.id);
+                if (previous && previous.row.info === info && previous.partRef === messageParts) {
+                    reuse = previous.row;
+                }
+            }
+            result.push(reuse ?? { info, parts: messageParts ?? [] });
+        }
+        touchSessionMessageRows(sessionID, { msgs, partRefs, result });
+        return result;
+    },
+    hydrate: (sessionID, msgs, opts) => {
+        let stampRuntimeActivity = false;
+        set((s) => {
+            evictedSessions.delete(sessionID);
+            const tombstones = cancelledMessageIds.get(sessionID);
+            const incoming = msgs
+                .filter((m) => !!m?.info?.id && !tombstones?.has(m.info.id))
+                .map((m) => m.info);
+            const fromCache = opts?.source === "cache";
+            if (fromCache) {
+                for (const m of incoming)
+                    trackId(cacheSourcedIds, sessionID, m.id);
+            }
+            let droppedPhantoms = null;
+            const provisional = fromCache ? undefined : cacheSourcedIds.get(sessionID);
+            if (provisional && provisional.size > 0 && incoming.length > 0) {
+                let oldestIncoming = incoming[0].id;
+                for (const m of incoming)
+                    if (m.id < oldestIncoming)
+                        oldestIncoming = m.id;
+                const incomingIds = new Set(incoming.map((m) => m.id));
+                for (const id of [...provisional]) {
+                    if (incomingIds.has(id)) {
+                        untrackId(cacheSourcedIds, sessionID, id);
+                        continue;
+                    }
+                    if (id >= oldestIncoming && !isOptimistic(sessionID, id)) {
+                        untrackId(cacheSourcedIds, sessionID, id);
+                        (droppedPhantoms ??= new Set()).add(id);
+                    }
+                }
+            }
+            for (const info of incoming) {
+                if (info.role !== "assistant" || !isStubShaped(info.id))
+                    continue;
+                if (!info.error)
+                    continue;
+                if (stubAssistantIds.get(sessionID)?.has(info.id))
+                    continue;
+                trackStub(sessionID, info.id, info.parentID ?? null);
+            }
+            const trackedStubIds = stubAssistantIds.get(sessionID);
+            const pendingStubs = [];
+            const existingAll = s.messages[sessionID] ?? [];
+            const existing = droppedPhantoms
+                ? existingAll.filter((m) => !droppedPhantoms.has(m.id))
+                : existingAll;
+            const merged = [];
+            const seen = new Set();
+            const existingIds = new Set(existing.map((m) => m.id));
+            if (!fromCache && existingAll.length > 0) {
+                const tail = incoming[incoming.length - 1];
+                const tailOpen = !!tail &&
+                    tail.role === "assistant" &&
+                    !tail.time?.completed &&
+                    !tail.error;
+                if (tailOpen) {
+                    stampRuntimeActivity =
+                        incoming.some((m) => !existingIds.has(m.id)) ||
+                            msgs.some((entry) => {
+                                const mid = entry?.info?.id;
+                                if (!mid || isOptimistic(sessionID, mid) || !existingIds.has(mid)) {
+                                    return false;
+                                }
+                                const prev = s.parts[mid];
+                                if (!prev || prev.length === 0)
+                                    return (entry.parts?.length ?? 0) > 0;
+                                const prevById = new Map(prev.map((p) => [p.id, p]));
+                                return (entry.parts ?? []).some((p) => {
+                                    if (!p?.id)
+                                        return false;
+                                    const prevPart = prevById.get(p.id);
+                                    if (!prevPart)
+                                        return true;
+                                    return (isTextLikePart(p) &&
+                                        isTextLikePart(prevPart) &&
+                                        (p.text?.length ?? 0) > (prevPart.text?.length ?? 0));
+                                });
+                            });
+                }
+            }
+            for (const m of incoming) {
+                if (m.role !== "user" || !isOptimistic(sessionID, m.id))
+                    continue;
+                releaseConfirmedOptimisticId(sessionID, m.id, m.id);
+                const optimisticParts = s.parts[m.id];
+                const entry = msgs.find((x) => x.info.id === m.id);
+                if ((entry?.parts?.length ?? 0) === 0 && optimisticParts?.length) {
+                    trackId(bridgedPartIds, sessionID, m.id);
+                }
+            }
+            const candidateEchoes = incoming.filter((m) => m.role === "user" &&
+                !isOptimistic(sessionID, m.id) &&
+                !existingIds.has(m.id));
+            const unclaimedEchoes = new Set(candidateEchoes.map((m) => m.id));
+            const echoByPartId = new Map();
+            for (const echo of candidateEchoes) {
+                const entry = msgs.find((m) => m.info.id === echo.id);
+                for (const p of entry?.parts ?? []) {
+                    if (p?.id)
+                        echoByPartId.set(p.id, echo.id);
+                }
+            }
+            for (const m of incoming) {
+                merged.push(m);
+                seen.add(m.id);
+            }
+            const deferredOptimistic = [];
+            const supersededOptimistic = [];
+            const supersededBy = new Map();
+            const unmatchedOptimisticUsers = [];
+            for (const m of existing) {
+                if (!seen.has(m.id)) {
+                    if (trackedStubIds?.has(m.id)) {
+                        pendingStubs.push(m);
+                        continue;
+                    }
+                    if (isOptimistic(sessionID, m.id)) {
+                        if (m.role !== "user") {
+                            deferredOptimistic.push(m);
+                            continue;
+                        }
+                        const echoId = (s.parts[m.id] ?? [])
+                            .map((p) => echoByPartId.get(p.id))
+                            .find((id) => !!id);
+                        if (echoId) {
+                            supersededOptimistic.push(m.id);
+                            supersededBy.set(m.id, echoId);
+                            unclaimedEchoes.delete(echoId);
+                        }
+                        else {
+                            unmatchedOptimisticUsers.push(m);
+                        }
+                    }
+                    else {
+                        merged.splice(insertIndexByTime(merged, m), 0, m);
+                    }
+                }
+            }
+            const claimed = new Set();
+            for (const m of unmatchedOptimisticUsers) {
+                const alias = optimisticEchoes.get(sessionID)?.get(m.id);
+                if (alias && unclaimedEchoes.has(alias) && !claimed.has(alias)) {
+                    claimed.add(alias);
+                    supersededOptimistic.push(m.id);
+                    supersededBy.set(m.id, alias);
+                }
+            }
+            const claimable = candidateEchoes.filter((m) => unclaimedEchoes.has(m.id) && !claimed.has(m.id));
+            let next = 0;
+            for (const m of unmatchedOptimisticUsers) {
+                if (supersededBy.has(m.id))
+                    continue;
+                const echo = isDispatched(sessionID, m.id) &&
+                    !hasTrackedId(inboxBackedOptimisticIds, sessionID, m.id) &&
+                    !optimisticEchoes.get(sessionID)?.get(m.id)
+                    ? claimable[next]
+                    : undefined;
+                if (echo) {
+                    next += 1;
+                    supersededOptimistic.push(m.id);
+                    supersededBy.set(m.id, echo.id);
+                }
+                else {
+                    deferredOptimistic.push(m);
+                }
+            }
+            for (const id of supersededOptimistic) {
+                const echoId = supersededBy.get(id);
+                if (echoId) {
+                    releaseConfirmedOptimisticId(sessionID, id, echoId);
+                    recordOptimisticEcho(sessionID, id, echoId);
+                }
+                else {
+                    releaseOptimisticId(sessionID, id);
+                }
+            }
+            for (const m of deferredOptimistic) {
+                merged.push(m);
+            }
+            for (const stub of pendingStubs) {
+                const trackedParent = trackedStubIds?.get(stub.id) ?? null;
+                const parentId = (trackedParent && supersededBy.get(trackedParent)) || trackedParent;
+                untrackStub(sessionID, stub.id);
+                if (hasAssistantForTurn(incoming, parentId)) {
+                    const replyIdx = findAssistantForTurn(merged, parentId);
+                    const reply = replyIdx === -1 ? undefined : merged[replyIdx];
+                    const stubError = stub.error;
+                    if (reply && !reply.error && stubError) {
+                        merged[replyIdx] = { ...reply, error: stubError };
+                    }
+                    continue;
+                }
+                const stubId = parentId ? stubIdFor(parentId) : stub.id;
+                const placed = stubId === stub.id && stub.parentID === (parentId ?? undefined)
+                    ? stub
+                    : { ...stub, id: stubId, ...(parentId ? { parentID: parentId } : {}) };
+                trackStub(sessionID, stubId, parentId);
+                const parentIdx = parentId ? merged.findIndex((m) => m.id === parentId) : -1;
+                if (parentIdx !== -1) {
+                    merged.splice(parentIdx + 1, 0, placed);
+                    continue;
+                }
+                if (indexOfId(merged, placed.id, (x) => x.id) === -1) {
+                    merged.splice(insertIndexByTime(merged, placed), 0, placed);
+                }
+            }
+            const newParts = { ...s.parts };
+            if (droppedPhantoms)
+                for (const id of droppedPhantoms)
+                    delete newParts[id];
+            for (const id of supersededOptimistic) {
+                const echoId = supersededBy.get(id);
+                const bridge = newParts[id];
+                delete newParts[id];
+                if (!echoId || !bridge?.length)
+                    continue;
+                const echoEntry = msgs.find((m) => m.info.id === echoId);
+                const serverHasParts = (echoEntry?.parts?.length ?? 0) > 0;
+                if (serverHasParts || newParts[echoId]?.length)
+                    continue;
+                newParts[echoId] = bridge;
+                trackId(bridgedPartIds, sessionID, echoId);
+            }
+            reconcileHydratedParts(msgs, newParts, {
+                isOptimistic: (id) => isOptimistic(sessionID, id),
+                isBridged: (id) => hasTrackedId(bridgedPartIds, sessionID, id),
+                clearBridge: (id) => untrackId(bridgedPartIds, sessionID, id),
+                isDeltaActive: (id) => hasTrackedId(deltaActiveParts, sessionID, id),
+            });
+            return {
+                messages: { ...s.messages, [sessionID]: merged },
+                parts: newParts,
+            };
+        });
+        if (stampRuntimeActivity)
+            get().noteSessionActivity(sessionID);
+    },
+    reset: () => {
+        optimisticIds.clear();
+        dispatchedOptimisticIds.clear();
+        inboxBackedOptimisticIds.clear();
+        optimisticEchoes.clear();
+        optimisticOrigins.clear();
+        bridgedPartIds.clear();
+        deltaActiveParts.clear();
+        deltaEventTails.clear();
+        stubAssistantIds.clear();
+        sessionConsumers.clear();
+        detachedSessions.clear();
+        evictedSessions.clear();
+        sessionMessageRows.clear();
+        set({
+            messages: {},
+            parts: {},
+            sessionStatus: {},
+            sessionStatusOrigin: {},
+            sessionStatusAt: {},
+            sessionActivityAt: {},
+            diffs: {},
+            todos: {},
+            sessionRevert: {},
+            sessionRevertNeedsTailReconcile: {},
+        });
+    },
+    hasOptimisticMessages: (sessionID) => {
+        const list = get().messages[sessionID];
+        if (!list || list.length === 0)
+            return false;
+        return list.some((m) => isOptimistic(sessionID, m.id));
+    },
+    getMessages: (sessionID) => {
+        const s = get();
+        const msgs = s.messages[sessionID];
+        if (!msgs)
+            return [];
+        return msgs.map((info) => ({
+            info,
+            parts: s.parts[info.id] ?? [],
+        }));
+    },
+    applyEvent: (event) => {
+        const store = get();
+        switch (event.type) {
+            case "message.updated": {
+                {
+                    const info = event.properties?.info;
+                    const sid = info?.sessionID ?? event.properties?.sessionID;
+                    if (sid && isOpenMessage(info))
+                        get().noteSessionActivity(sid);
+                }
+                const info = event.properties.info;
+                if (!info?.sessionID)
+                    return;
+                if (cancelledMessageIds.get(info.sessionID)?.has(info.id))
+                    return;
+                if (info.role === "user" && isOptimistic(info.sessionID, info.id)) {
+                    releaseOptimisticId(info.sessionID, info.id);
+                    if (get().parts[info.id]?.length) {
+                        trackId(bridgedPartIds, info.sessionID, info.id);
+                    }
+                    store.upsertMessage(info.sessionID, info);
+                    return;
+                }
+                if (info.role === "user" && !isOptimistic(info.sessionID, info.id)) {
+                    const msgs = get().messages[info.sessionID];
+                    if (msgs) {
+                        if (msgs.some((message) => message.id === info.id)) {
+                            store.upsertMessage(info.sessionID, info);
+                            return;
+                        }
+                        const state = get();
+                        const optimisticUsers = msgs.filter((m) => m.role === "user" && isOptimistic(info.sessionID, m.id));
+                        const incomingPartIds = new Set((state.parts[info.id] ?? []).map((p) => p.id));
+                        const byPartId = optimisticUsers.find((m) => (state.parts[m.id] ?? []).some((p) => incomingPartIds.has(p.id)));
+                        const byAlias = optimisticUsers.find((m) => optimisticEchoes.get(info.sessionID)?.get(m.id) === info.id);
+                        const eligible = optimisticUsers.filter((m) => isDispatched(info.sessionID, m.id) &&
+                            !hasTrackedId(inboxBackedOptimisticIds, info.sessionID, m.id) &&
+                            !optimisticEchoes.get(info.sessionID)?.get(m.id));
+                        const matched = byPartId ?? byAlias ?? (eligible.length === 1 ? eligible[0] : undefined);
+                        const optIds = matched ? [matched.id] : [];
+                        if (optIds.length > 0) {
+                            for (const id of optIds) {
+                                releaseConfirmedOptimisticId(info.sessionID, id, info.id);
+                                recordOptimisticEcho(info.sessionID, id, info.id);
+                            }
+                            set((s) => {
+                                const list = s.messages[info.sessionID] ?? [];
+                                const without = list.filter((m) => !optIds.includes(m.id));
+                                const at = indexOfId(without, info.id, (m) => m.id);
+                                let next = [...without];
+                                if (at !== -1) {
+                                    next[at] = info;
+                                }
+                                else {
+                                    next.splice(insertIndexByTime(next, info), 0, info);
+                                }
+                                for (const id of optIds) {
+                                    next = rekeyStubParent(info.sessionID, next, id, info.id);
+                                }
+                                const newParts = { ...s.parts };
+                                let bridge;
+                                for (const id of optIds) {
+                                    if (!bridge && newParts[id]?.length) {
+                                        bridge = newParts[id];
+                                    }
+                                    delete newParts[id];
+                                }
+                                if (bridge && !newParts[info.id]?.length) {
+                                    newParts[info.id] = bridge;
+                                    trackId(bridgedPartIds, info.sessionID, info.id);
+                                }
+                                return {
+                                    messages: { ...s.messages, [info.sessionID]: next },
+                                    parts: newParts,
+                                };
+                            });
+                            return;
+                        }
+                    }
+                }
+                store.upsertMessage(info.sessionID, info);
+                return;
+            }
+            case "message.removed": {
+                const props = event.properties;
+                if (!props.sessionID || !props.messageID)
+                    return;
+                if (store.reclaimRemovedMessage(props.sessionID, props.messageID))
+                    return;
+                store.removeMessage(props.sessionID, props.messageID);
+                return;
+            }
+            case "message.part.updated": {
+                const part = event.properties.part;
+                if (!part?.messageID)
+                    return;
+                const eventSessionID = event.properties?.sessionID;
+                let resolvedSessionID = part.sessionID ?? eventSessionID;
+                if (!resolvedSessionID) {
+                    const sessionsById = get().messages;
+                    for (const [sid, msgs] of Object.entries(sessionsById)) {
+                        if (msgs?.some((m) => m.id === part.messageID)) {
+                            resolvedSessionID = sid;
+                            break;
+                        }
+                    }
+                }
+                if (resolvedSessionID && isOpenPart(part))
+                    get().noteSessionActivity(resolvedSessionID);
+                const existingMsgs = resolvedSessionID
+                    ? get().messages[resolvedSessionID]
+                    : undefined;
+                const exists = existingMsgs?.some((m) => m.id === part.messageID);
+                const sessionHasUserMessage = existingMsgs?.some((m) => m.role === "user") ?? false;
+                if (!exists &&
+                    resolvedSessionID &&
+                    sessionHasUserMessage &&
+                    !awaitsUserEcho(resolvedSessionID, part.messageID)) {
+                    store.upsertMessage(resolvedSessionID, {
+                        id: part.messageID,
+                        sessionID: resolvedSessionID,
+                        role: "assistant",
+                    });
+                }
+                store.upsertPart(part.messageID, part, resolvedSessionID);
+                return;
+            }
+            case "message.part.removed": {
+                const props = event.properties;
+                if (!props.messageID || !props.partID)
+                    return;
+                store.removePart(props.messageID, props.partID);
+                return;
+            }
+            case "message.part.delta": {
+                const props = event.properties;
+                if (!props.messageID || !props.partID || !props.field)
+                    return;
+                const partList = get().parts[props.messageID];
+                const partExists = partList && partList.some((p) => p.id === props.partID);
+                if (!partExists) {
+                    if (props.sessionID) {
+                        const existingMsgs = get().messages[props.sessionID];
+                        const hasUserMsg = existingMsgs?.some((m) => m.role === "user");
+                        const msgExists = existingMsgs?.some((m) => m.id === props.messageID);
+                        if (!msgExists && hasUserMsg) {
+                            store.upsertMessage(props.sessionID, {
+                                id: props.messageID,
+                                sessionID: props.sessionID,
+                                role: "assistant",
+                            });
+                        }
+                    }
+                    store.upsertPart(props.messageID, {
+                        id: props.partID,
+                        sessionID: props.sessionID,
+                        messageID: props.messageID,
+                        type: "text",
+                        [props.field]: "",
+                    });
+                }
+                const wire = event.coalesced ?? [event];
+                appendPartDeltas(props.sessionID, props.messageID, props.partID, props.field, wire.map((e) => ({
+                    id: e.id,
+                    delta: e.properties.delta,
+                })));
+                return;
+            }
+            case "session.status": {
+                const props = event.properties;
+                if (props.sessionID && props.status)
+                    store.setStatus(props.sessionID, props.status, syntheticEventOrigin(event));
+                return;
+            }
+            case "session.idle": {
+                const sessionID = event.properties.sessionID;
+                if (sessionID)
+                    store.setStatus(sessionID, { type: "idle" }, syntheticEventOrigin(event));
+                if (sessionID)
+                    deltaActiveParts.delete(sessionID);
+                return;
+            }
+            case "session.error": {
+                const props = event.properties;
+                if (!props.sessionID || !props.error)
+                    return;
+                const sid = props.sessionID;
+                const error = props.error;
+                if (!isRetryableTurnError(error)) {
+                    store.setStatus(sid, { type: "idle" }, syntheticEventOrigin(event));
+                }
+                deltaActiveParts.delete(sid);
+                deltaEventTails.delete(sid);
+                set((s) => {
+                    const msgs = s.messages[sid] ?? [];
+                    let userIdx = -1;
+                    for (let i = msgs.length - 1; i >= 0; i--) {
+                        if (msgs[i].role === "user") {
+                            userIdx = i;
+                            break;
+                        }
+                    }
+                    const userId = userIdx === -1 ? null : msgs[userIdx].id;
+                    for (let i = msgs.length - 1; i > userIdx; i--) {
+                        const msg = msgs[i];
+                        if (msg.role !== "assistant")
+                            continue;
+                        if (userId && msg.parentID && msg.parentID !== userId)
+                            continue;
+                        if (msg.error)
+                            return s;
+                        const next = [...msgs];
+                        next[i] = { ...msg, error };
+                        return { messages: { ...s.messages, [sid]: next } };
+                    }
+                    const stubId = userId ? stubIdFor(userId) : ascendingId("msg");
+                    if (msgs.some((m) => m.id === stubId))
+                        return s;
+                    trackStub(sid, stubId, userId);
+                    const stubMsg = {
+                        id: stubId,
+                        sessionID: sid,
+                        role: "assistant",
+                        ...(userId ? { parentID: userId } : {}),
+                        error,
+                    };
+                    const next = [...msgs];
+                    next.splice(userIdx === -1 ? next.length : userIdx + 1, 0, stubMsg);
+                    return { messages: { ...s.messages, [sid]: next } };
+                });
+                return;
+            }
+            case "session.next.revert.staged": {
+                const props = event.properties;
+                if (props.sessionID && props.revert?.messageID) {
+                    store.stageSessionRevert(props.sessionID, props.revert.messageID);
+                }
+                return;
+            }
+            case "session.next.revert.cleared": {
+                const props = event.properties;
+                if (props.sessionID)
+                    store.clearSessionRevert(props.sessionID);
+                return;
+            }
+            case "session.next.revert.committed": {
+                const props = event.properties;
+                if (props.sessionID && props.messageID) {
+                    const tracked = get().sessionRevert[props.sessionID];
+                    if (tracked) {
+                        store.applyCommittedRevert(props.sessionID, props.messageID, tracked.watermark, tracked.messageId === props.messageID ? tracked.hiddenIds : undefined);
+                    }
+                    else {
+                        store.markSessionRevertNeedsTailReconcile(props.sessionID);
+                    }
+                }
+                return;
+            }
+            case "session.diff": {
+                const props = event.properties;
+                if (props.sessionID)
+                    store.setDiff(props.sessionID, props.diff);
+                return;
+            }
+            case "todo.updated": {
+                const props = event.properties;
+                if (props.sessionID)
+                    store.setTodo(props.sessionID, props.todos);
+                return;
+            }
+            default:
+                return;
+        }
+    },
+}));