@burtson-labs/bandit-engine 2.1.4 → 2.1.7

package/dist/chunk-SQJ4OKWM.mjs

@@ -0,0 +1,3567 @@
+import {
+  indexedDBService_default,
+  useModelStore,
+  usePreferencesStore
+} from "./chunk-KWOUXBSF.mjs";
+import {
+  Archive,
+  Braces,
+  Check,
+  Edit,
+  File,
+  FileCode,
+  FileImage,
+  FilePdf,
+  FileText,
+  Folder,
+  GripVertical,
+  Home,
+  Inbox,
+  LogOut,
+  MailOpen,
+  MessageSquarePlus,
+  MoreVertical,
+  Plus,
+  Search,
+  Settings,
+  Sheet,
+  Trash
+} from "./chunk-5URP2E5V.mjs";
+import {
+  usePackageSettingsStore
+} from "./chunk-K7SQWDNF.mjs";
+import {
+  AUTH_TOKEN_CHANGED_EVENT,
+  TOKEN_KEY,
+  authenticationService,
+  readPersistedToken,
+  useAuthenticationStore
+} from "./chunk-S3DWWUBD.mjs";
+import {
+  debugLogger
+} from "./chunk-NI7BKLC7.mjs";
+
+// src/store/aiQueryStore.ts
+import { create } from "zustand";
+var DB_NAME = "ai-query-db";
+var STORE_NAME = "ai-query";
+var DB_VERSION = 1;
+var STORAGE_KEY = "singleton";
+var storeConfigs = [{ name: STORE_NAME }];
+async function saveStateToDB(state) {
+  await indexedDBService_default.put(
+    DB_NAME,
+    DB_VERSION,
+    STORE_NAME,
+    state,
+    storeConfigs,
+    STORAGE_KEY
+  );
+}
+async function loadStateFromDB() {
+  let timeoutId;
+  const timeoutPromise = new Promise((resolve) => {
+    timeoutId = window.setTimeout(() => resolve(void 0), 1200);
+  });
+  try {
+    const getPromise = indexedDBService_default.get(DB_NAME, DB_VERSION, STORE_NAME, STORAGE_KEY, storeConfigs).catch(() => void 0);
+    return await Promise.race([getPromise, timeoutPromise]);
+  } finally {
+    if (timeoutId !== void 0) {
+      window.clearTimeout(timeoutId);
+    }
+  }
+}
+var useAIQueryStore = create((set, get) => ({
+  inputValue: "",
+  response: "",
+  previousQuestion: "",
+  position: { x: window.innerWidth / 2 - 300, y: window.innerHeight - 350 },
+  componentStatus: "Idle",
+  history: [],
+  apiKey: "",
+  hydrated: false,
+  setInputValue: (value) => {
+    set({ inputValue: value });
+    saveStateToDB({ inputValue: value });
+  },
+  setResponse: (response) => {
+    set({ response });
+    saveStateToDB({ response });
+  },
+  setPreviousQuestion: (question) => {
+    set({ previousQuestion: question });
+    saveStateToDB({ previousQuestion: question });
+  },
+  setPosition: (position) => {
+    set({ position });
+    saveStateToDB({ position });
+  },
+  setComponentStatus: (status) => set({ componentStatus: status }),
+  addHistory: (entry) => {
+    const newHistory = [...get().history, entry];
+    set({ history: newHistory });
+    saveStateToDB({ history: newHistory });
+  },
+  clearHistory: () => {
+    set({ history: [] });
+    saveStateToDB({ history: [] });
+  },
+  setApiKey: (key) => {
+    set({ apiKey: key });
+    saveStateToDB({ apiKey: key });
+  },
+  setHydrated: () => set({ hydrated: true }),
+  reset: () => {
+    const resetState = {
+      inputValue: "",
+      response: "",
+      previousQuestion: "",
+      position: { x: window.innerWidth / 2 - 300, y: window.innerHeight - 350 },
+      componentStatus: "Idle",
+      history: [],
+      apiKey: ""
+    };
+    set(resetState);
+    saveStateToDB(resetState);
+  },
+  hydrate: async () => {
+    try {
+      const storedState = await loadStateFromDB();
+      if (storedState) {
+        set({
+          inputValue: storedState.inputValue ?? "",
+          response: storedState.response ?? "",
+          previousQuestion: storedState.previousQuestion ?? "",
+          position: storedState.position ?? {
+            x: window.innerWidth / 2 - 300,
+            y: window.innerHeight - 350
+          },
+          componentStatus: "Idle",
+          history: storedState.history ?? [],
+          apiKey: storedState.apiKey ?? "",
+          hydrated: true
+        });
+      } else {
+        set({ hydrated: true });
+      }
+    } catch {
+      set({ hydrated: true });
+    }
+  }
+}));
+
+// src/store/conversationStore.ts
+import { create as create2 } from "zustand";
+
+// src/utils/id.ts
+var cryptoOf = () => globalThis.crypto;
+function newId() {
+  const c = cryptoOf();
+  if (typeof c?.randomUUID === "function") return c.randomUUID();
+  const bytes = new Uint8Array(16);
+  if (typeof c?.getRandomValues === "function") {
+    c.getRandomValues(bytes);
+  } else {
+    for (let i = 0; i < bytes.length; i += 1) bytes[i] = Math.floor(Math.random() * 256);
+  }
+  bytes[6] = bytes[6] & 15 | 64;
+  bytes[8] = bytes[8] & 63 | 128;
+  const hex = Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
+  return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+}
+
+// src/util/conversationMigration.ts
+var DB_NAME2 = "bandit-conversations";
+var STORE_NAME2 = "conversations";
+var DB_VERSION2 = 1;
+var storeConfigs2 = [{ name: STORE_NAME2, keyPath: "id" }];
+async function migrateConversationsToV2() {
+  try {
+    debugLogger.info("Starting conversation migration to V2 format");
+    const conversations = await indexedDBService_default.getAll(
+      DB_NAME2,
+      DB_VERSION2,
+      STORE_NAME2,
+      storeConfigs2
+    );
+    if (!conversations || conversations.length === 0) {
+      debugLogger.info("No conversations found, migration not needed");
+      return true;
+    }
+    let migratedCount = 0;
+    const now = /* @__PURE__ */ new Date();
+    for (const conversation of conversations) {
+      const needsMigration = !conversation.hasOwnProperty("createdAt") || !conversation.hasOwnProperty("updatedAt");
+      if (needsMigration) {
+        const migratedConversation = {
+          ...conversation,
+          // projectId remains undefined (ungrouped)
+          createdAt: now,
+          // We can't know the real creation date
+          updatedAt: now
+        };
+        await indexedDBService_default.put(
+          DB_NAME2,
+          DB_VERSION2,
+          STORE_NAME2,
+          migratedConversation,
+          storeConfigs2
+        );
+        migratedCount++;
+        debugLogger.debug("Migrated conversation", {
+          id: conversation.id,
+          name: conversation.name
+        });
+      } else if ("createdAt" in conversation && conversation.createdAt && typeof conversation.createdAt === "string") {
+        const fixedConversation = {
+          ...conversation,
+          createdAt: new Date(conversation.createdAt),
+          updatedAt: new Date(
+            conversation.updatedAt || conversation.createdAt
+          )
+        };
+        await indexedDBService_default.put(
+          DB_NAME2,
+          DB_VERSION2,
+          STORE_NAME2,
+          fixedConversation,
+          storeConfigs2
+        );
+        migratedCount++;
+        debugLogger.debug("Fixed date format for conversation", {
+          id: conversation.id,
+          name: conversation.name
+        });
+      }
+    }
+    if (migratedCount > 0) {
+      debugLogger.info("Conversation migration completed", {
+        totalConversations: conversations.length,
+        migratedCount
+      });
+    } else {
+      debugLogger.info("All conversations already up to date");
+    }
+    return true;
+  } catch (error) {
+    debugLogger.error("Failed to migrate conversations", { error });
+    return false;
+  }
+}
+async function validateConversationStructure() {
+  try {
+    const conversations = await indexedDBService_default.getAll(
+      DB_NAME2,
+      DB_VERSION2,
+      STORE_NAME2,
+      storeConfigs2
+    );
+    if (!conversations) {
+      return true;
+    }
+    for (const conversation of conversations) {
+      const isValid = typeof conversation.id === "string" && typeof conversation.name === "string" && typeof conversation.model === "string" && Array.isArray(conversation.history) && (conversation.projectId === void 0 || typeof conversation.projectId === "string") && (conversation.createdAt === void 0 || conversation.createdAt instanceof Date) && (conversation.updatedAt === void 0 || conversation.updatedAt instanceof Date);
+      if (!isValid) {
+        debugLogger.warn("Invalid conversation structure detected", {
+          conversationId: conversation.id,
+          structure: {
+            hasId: typeof conversation.id === "string",
+            hasName: typeof conversation.name === "string",
+            hasModel: typeof conversation.model === "string",
+            hasHistory: Array.isArray(conversation.history),
+            projectIdValid: conversation.projectId === void 0 || typeof conversation.projectId === "string",
+            createdAtValid: conversation.createdAt === void 0 || conversation.createdAt instanceof Date,
+            updatedAtValid: conversation.updatedAt === void 0 || conversation.updatedAt instanceof Date
+          }
+        });
+        return false;
+      }
+    }
+    debugLogger.info("All conversations have valid structure", {
+      count: conversations.length
+    });
+    return true;
+  } catch (error) {
+    debugLogger.error("Failed to validate conversation structure", { error });
+    return false;
+  }
+}
+async function runConversationMigrations() {
+  try {
+    debugLogger.info("Running conversation migrations");
+    const migrationSuccess = await migrateConversationsToV2();
+    if (!migrationSuccess) {
+      debugLogger.error("Conversation migration failed");
+      return false;
+    }
+    const validationSuccess = await validateConversationStructure();
+    if (!validationSuccess) {
+      debugLogger.warn("Conversation validation failed, but continuing");
+    }
+    debugLogger.info("Conversation migrations completed successfully");
+    return true;
+  } catch (error) {
+    debugLogger.error("Migration process failed", { error });
+    return false;
+  }
+}
+
+// src/store/conversationSyncEvents.ts
+var CONVERSATION_UPSERT_EVENT = "bandit-conversation-upsert";
+var CONVERSATION_DELETE_EVENT = "bandit-conversation-delete";
+var PROJECT_UPSERT_EVENT = "bandit-project-upsert";
+var PROJECT_DELETE_EVENT = "bandit-project-delete";
+
+// src/store/conversationStore.ts
+var DB_NAME3 = "bandit-conversations";
+var STORE_NAME3 = "conversations";
+var DB_VERSION3 = 1;
+var storeConfigs3 = [{ name: STORE_NAME3, keyPath: "id" }];
+var EMOJI_REGEX = /\p{Extended_Pictographic}/gu;
+var VARIATION_SELECTORS_REGEX = /[\uFE0F\uFE0E]/g;
+var ZERO_WIDTH_JOINER_REGEX = /\u200D/g;
+function sanitizeConversationName(input, maxLength = 60) {
+  if (!input) return "Untitled Conversation";
+  const withoutEmoji = input.replace(EMOJI_REGEX, "").replace(VARIATION_SELECTORS_REGEX, "").replace(ZERO_WIDTH_JOINER_REGEX, "");
+  const normalized = withoutEmoji.normalize("NFC").trim().replace(/\s+/g, " ");
+  if (!normalized) {
+    return "Untitled Conversation";
+  }
+  const limited = Array.from(normalized).slice(0, maxLength).join("");
+  return limited || "Untitled Conversation";
+}
+async function loadConversations() {
+  const raw = await indexedDBService_default.getAll(
+    DB_NAME3,
+    DB_VERSION3,
+    STORE_NAME3,
+    storeConfigs3
+  );
+  return (raw || []).map(normalizeConversation);
+}
+async function saveConversation(conversation) {
+  if (conversation.incognito) return;
+  await indexedDBService_default.put(DB_NAME3, DB_VERSION3, STORE_NAME3, conversation, storeConfigs3);
+}
+async function deleteConversationFromDB(id) {
+  await indexedDBService_default.delete(DB_NAME3, DB_VERSION3, STORE_NAME3, id, storeConfigs3);
+}
+var useConversationStore = create2((set, get) => ({
+  conversations: [],
+  currentId: null,
+  _hasHydrated: false,
+  hydrate: async () => {
+    try {
+      await runConversationMigrations();
+      const conversations = await loadConversations();
+      set({ conversations, _hasHydrated: true });
+    } catch (error) {
+      console.error("Failed to hydrate conversations:", error);
+      set({ conversations: [], _hasHydrated: true });
+    }
+  },
+  createConversation: (firstMessage, projectId) => {
+    const id = newId();
+    const { selectedModel } = useModelStore.getState();
+    const sanitizedFirstMessage = sanitizeConversationName(firstMessage, 60);
+    const name = sanitizedFirstMessage;
+    const now = /* @__PURE__ */ new Date();
+    const newConv = normalizeConversation({
+      id,
+      name,
+      history: [],
+      model: selectedModel,
+      projectId,
+      createdAt: now,
+      updatedAt: now,
+      version: 0
+    });
+    set((state) => {
+      const updatedConversations = [...state.conversations, newConv];
+      saveConversation(newConv);
+      emitConversationUpsert(id);
+      return {
+        conversations: updatedConversations,
+        currentId: id
+      };
+    });
+  },
+  createNewConversation: (projectId) => {
+    const { selectedModel } = useModelStore.getState();
+    const id = newId();
+    const now = /* @__PURE__ */ new Date();
+    const newConv = normalizeConversation({
+      id,
+      name: "New Conversation",
+      history: [],
+      model: selectedModel,
+      projectId,
+      createdAt: now,
+      updatedAt: now,
+      version: 0
+    });
+    set((state) => {
+      const updatedConversations = [...state.conversations, newConv];
+      saveConversation(newConv);
+      emitConversationUpsert(id);
+      return {
+        conversations: updatedConversations,
+        currentId: id
+      };
+    });
+  },
+  toggleIncognito: () => {
+    const { conversations, currentId } = get();
+    const current = conversations.find((c) => c.id === currentId);
+    if (current?.incognito) {
+      useAIQueryStore.getState().reset();
+      set((state) => ({
+        conversations: state.conversations.filter((c) => !c.incognito),
+        currentId: null
+      }));
+      return;
+    }
+    const { selectedModel } = useModelStore.getState();
+    const now = /* @__PURE__ */ new Date();
+    const newConv = normalizeConversation({
+      id: newId(),
+      name: "Temporary chat",
+      history: [],
+      model: selectedModel,
+      createdAt: now,
+      updatedAt: now,
+      version: 0,
+      incognito: true
+    });
+    set((state) => ({
+      conversations: [...state.conversations, newConv],
+      currentId: newConv.id
+    }));
+  },
+  deleteConversation: (id) => {
+    const runHydrate = async () => {
+      try {
+        await get().hydrate();
+      } catch (error) {
+        debugLogger.warn("conversationStore: rehydrate after delete failed", {
+          error: error instanceof Error ? error.message : String(error)
+        });
+      }
+    };
+    set((state) => {
+      const filtered = state.conversations.filter((c) => c.id !== id);
+      const isDeletingCurrent = state.currentId === id;
+      if (isDeletingCurrent) {
+        useAIQueryStore.getState().reset();
+      }
+      deleteConversationFromDB(id).then(runHydrate).catch((error) => {
+        debugLogger.error("Failed to delete conversation from DB", {
+          error,
+          conversationId: id
+        });
+      });
+      emitConversationDelete(id);
+      return {
+        conversations: filtered,
+        currentId: isDeletingCurrent ? null : state.currentId
+      };
+    });
+  },
+  switchConversation: (id) => {
+    const { conversations } = get();
+    const { setSelectedModel } = useModelStore.getState();
+    const selectedModel = conversations.find((c) => c.id === id)?.model;
+    selectedModel && setSelectedModel(selectedModel);
+    set({ currentId: id });
+  },
+  addToCurrent: (entry) => {
+    const { currentId, conversations } = get();
+    if (!currentId) return;
+    set(() => {
+      const updatedConversations = conversations.map(
+        (c) => c.id === currentId ? normalizeConversation({
+          ...c,
+          history: [...c.history, entry],
+          updatedAt: /* @__PURE__ */ new Date()
+        }) : c
+      );
+      const updatedConv = updatedConversations.find((c) => c.id === currentId);
+      if (updatedConv) {
+        saveConversation(updatedConv);
+        emitConversationUpsert(updatedConv.id);
+      }
+      return { conversations: updatedConversations };
+    });
+  },
+  renameConversation: (id, newName) => {
+    set((state) => {
+      const sanitized = sanitizeConversationName(newName);
+      const updatedConversations = state.conversations.map(
+        (c) => c.id === id ? normalizeConversation({ ...c, name: sanitized, updatedAt: /* @__PURE__ */ new Date() }) : c
+      );
+      const updatedConv = updatedConversations.find((c) => c.id === id);
+      if (updatedConv) {
+        saveConversation(updatedConv);
+        emitConversationUpsert(updatedConv.id);
+      }
+      return { conversations: updatedConversations };
+    });
+  },
+  replaceLastAnswer: (answer, images, memoryUpdated, sourceFiles, cancelled) => {
+    const { currentId, conversations } = get();
+    if (!currentId) return;
+    set(() => {
+      const updatedConversations = conversations.map((c) => {
+        if (c.id === currentId && c.history.length > 0) {
+          const updatedHistory = [...c.history];
+          const existingImages = updatedHistory[updatedHistory.length - 1].images;
+          const nextImages = Array.isArray(images) && images.length > 0 ? [...images] : Array.isArray(existingImages) && existingImages.length > 0 ? [...existingImages] : existingImages;
+          updatedHistory[updatedHistory.length - 1] = {
+            ...updatedHistory[updatedHistory.length - 1],
+            answer,
+            memoryUpdated,
+            images: nextImages,
+            sourceFiles: sourceFiles ?? updatedHistory[updatedHistory.length - 1].sourceFiles,
+            cancelled: cancelled ?? updatedHistory[updatedHistory.length - 1].cancelled,
+            placeholder: false,
+            rawQuestion: void 0
+          };
+          return normalizeConversation({
+            ...c,
+            history: updatedHistory,
+            updatedAt: /* @__PURE__ */ new Date()
+          });
+        }
+        return c;
+      });
+      const updatedConv = updatedConversations.find((c) => c.id === currentId);
+      if (updatedConv) {
+        saveConversation(updatedConv);
+        emitConversationUpsert(updatedConv.id);
+      }
+      return { conversations: updatedConversations };
+    });
+  },
+  setLastToolTrail: (toolsUsed) => {
+    const { currentId } = get();
+    if (!currentId) return;
+    set((state) => ({
+      conversations: state.conversations.map((c) => {
+        if (c.id !== currentId || c.history.length === 0) return c;
+        const history = [...c.history];
+        history[history.length - 1] = {
+          ...history[history.length - 1],
+          toolsUsed: [...toolsUsed]
+        };
+        return { ...c, history };
+      })
+    }));
+  },
+  markEntryMemoryUpdated: (conversationId, entryIndex) => {
+    set((state) => {
+      let updatedConv;
+      const updatedConversations = state.conversations.map((c) => {
+        const entry = c.id === conversationId ? c.history[entryIndex] : void 0;
+        if (!entry || entry.placeholder || entry.memoryUpdated) return c;
+        const history = [...c.history];
+        history[entryIndex] = { ...entry, memoryUpdated: true };
+        updatedConv = normalizeConversation({ ...c, history, updatedAt: /* @__PURE__ */ new Date() });
+        return updatedConv;
+      });
+      if (!updatedConv) return state;
+      saveConversation(updatedConv);
+      emitConversationUpsert(updatedConv.id);
+      return { conversations: updatedConversations };
+    });
+  },
+  setCurrent: (id) => set({ currentId: id }),
+  moveConversationToProject: (conversationId, projectId) => {
+    set((state) => {
+      const updatedConversations = state.conversations.map(
+        (c) => c.id === conversationId ? normalizeConversation({
+          ...c,
+          projectId: projectId || void 0,
+          updatedAt: /* @__PURE__ */ new Date()
+        }) : c
+      );
+      const updatedConv = updatedConversations.find((c) => c.id === conversationId);
+      if (updatedConv) {
+        saveConversation(updatedConv);
+      }
+      return { conversations: updatedConversations };
+    });
+  },
+  clearAllConversations: async () => {
+    try {
+      await indexedDBService_default.clear(DB_NAME3, DB_VERSION3, STORE_NAME3, storeConfigs3);
+      set({
+        conversations: [],
+        currentId: null
+      });
+      debugLogger.info("All conversations cleared successfully");
+    } catch (error) {
+      debugLogger.error("Failed to clear all conversations", { error });
+      throw error;
+    }
+  },
+  getConversationsByProject: (projectId) => {
+    const { conversations } = get();
+    if (projectId === null) {
+      return conversations.filter((c) => !c.projectId);
+    }
+    return conversations.filter((c) => c.projectId === projectId);
+  },
+  applyRemoteConversations: async (incoming) => {
+    const normalized = incoming.map(normalizeConversation);
+    const toPersist = [];
+    set((state) => {
+      const next = new Map(state.conversations.map((c) => [c.id, c]));
+      for (const conversation of normalized) {
+        const existing = next.get(conversation.id);
+        if (existing) {
+          const existingUpdatedAt = existing.updatedAt ? existing.updatedAt.getTime() : 0;
+          const incomingUpdatedAt = conversation.updatedAt ? conversation.updatedAt.getTime() : 0;
+          const existingHistoryLength = existing.history?.length ?? 0;
+          const incomingHistoryLength = conversation.history?.length ?? 0;
+          const incomingHasMoreHistory = incomingHistoryLength > existingHistoryLength;
+          const incomingIsNewer = incomingUpdatedAt > existingUpdatedAt;
+          if (incomingIsNewer && incomingHistoryLength < existingHistoryLength) {
+            debugLogger.info(
+              "applyRemoteConversations: preserving local history over shorter incoming",
+              {
+                conversationId: conversation.id,
+                existingHistoryLength,
+                incomingHistoryLength,
+                existingUpdatedAt,
+                incomingUpdatedAt
+              }
+            );
+            conversation.history = existing.history;
+          }
+          if (!incomingHasMoreHistory && !incomingIsNewer) {
+            debugLogger.info("applyRemoteConversations: skipping stale conversation", {
+              conversationId: conversation.id,
+              existingHistoryLength,
+              incomingHistoryLength,
+              existingUpdatedAt,
+              incomingUpdatedAt
+            });
+            continue;
+          }
+          if (Array.isArray(existing.history) && Array.isArray(conversation.history)) {
+            const mergedHistory = conversation.history.map((incomingEntry, index) => {
+              const existingEntry = existing.history[index];
+              if (!existingEntry) {
+                return incomingEntry;
+              }
+              const mergedImagesSource = Array.isArray(incomingEntry.images) && incomingEntry.images.length > 0 ? incomingEntry.images : existingEntry.images;
+              const mergedImages = Array.isArray(mergedImagesSource) && mergedImagesSource.length > 0 ? [...mergedImagesSource] : mergedImagesSource;
+              return {
+                ...existingEntry,
+                ...incomingEntry,
+                images: mergedImages,
+                placeholder: incomingEntry.placeholder ?? existingEntry.placeholder,
+                rawQuestion: incomingEntry.rawQuestion ?? existingEntry.rawQuestion
+              };
+            });
+            conversation.history = mergedHistory;
+          }
+        }
+        next.set(conversation.id, conversation);
+        toPersist.push(conversation);
+      }
+      return { conversations: Array.from(next.values()) };
+    });
+    if (toPersist.length > 0) {
+      try {
+        await Promise.all(
+          toPersist.map((conversation) => saveConversation(conversation))
+        );
+      } catch (error) {
+        debugLogger.error("Failed to persist remote conversations", {
+          error,
+          conversationIds: toPersist.map((c) => c.id)
+        });
+      }
+    }
+  },
+  removeConversationsByIds: async (ids) => {
+    if (!ids.length) {
+      return;
+    }
+    try {
+      await Promise.all(ids.map((id) => deleteConversationFromDB(id)));
+    } catch (error) {
+      debugLogger.error("Failed to remove conversations from IndexedDB", { error, ids });
+    }
+    set((state) => {
+      const filtered = state.conversations.filter((c) => !ids.includes(c.id));
+      const isCurrentDeleted = state.currentId ? ids.includes(state.currentId) : false;
+      ids.forEach((id) => emitConversationDelete(id));
+      return {
+        conversations: filtered,
+        currentId: isCurrentDeleted ? null : state.currentId
+      };
+    });
+    try {
+      await get().hydrate();
+    } catch (error) {
+      debugLogger.warn("conversationStore: hydrate failed after remote delete", {
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
+}));
+function normalizeConversation(conversation) {
+  const ensureDate = (value) => {
+    if (!value) return void 0;
+    if (value instanceof Date) return value;
+    const parsed = new Date(value);
+    return Number.isNaN(parsed.getTime()) ? void 0 : parsed;
+  };
+  return {
+    ...conversation,
+    name: sanitizeConversationName(conversation.name),
+    createdAt: ensureDate(conversation.createdAt) ?? /* @__PURE__ */ new Date(),
+    updatedAt: ensureDate(conversation.updatedAt) ?? /* @__PURE__ */ new Date(),
+    summaryGeneratedAt: ensureDate(conversation.summaryGeneratedAt),
+    history: Array.isArray(conversation.history) ? conversation.history.map((turn) => ({
+      ...turn
+    })) : []
+  };
+}
+function emitConversationUpsert(id) {
+  if (typeof window === "undefined") return;
+  window.dispatchEvent(new CustomEvent(CONVERSATION_UPSERT_EVENT, { detail: id }));
+}
+function emitConversationDelete(id) {
+  if (typeof window === "undefined") return;
+  window.dispatchEvent(new CustomEvent(CONVERSATION_DELETE_EVENT, { detail: id }));
+}
+
+// src/store/projectStore.ts
+import { create as create3 } from "zustand";
+var DB_NAME4 = "bandit-projects";
+var STORE_NAME4 = "projects";
+var DB_VERSION4 = 1;
+var storeConfigs4 = [{ name: STORE_NAME4, keyPath: "id" }];
+var DEFAULT_COLORS = [
+  "#2196F3",
+  // Blue
+  "#4CAF50",
+  // Green
+  "#FF9800",
+  // Orange
+  "#9C27B0",
+  // Purple
+  "#F44336",
+  // Red
+  "#00BCD4",
+  // Cyan
+  "#FFEB3B",
+  // Yellow
+  "#795548",
+  // Brown
+  "#607D8B",
+  // Blue Grey
+  "#E91E63"
+  // Pink
+];
+async function loadProjects() {
+  try {
+    const projects = await indexedDBService_default.getAll(
+      DB_NAME4,
+      DB_VERSION4,
+      STORE_NAME4,
+      storeConfigs4
+    );
+    return (projects || []).map(normalizeProject).sort((a, b) => a.order - b.order);
+  } catch (error) {
+    debugLogger.error("Failed to load projects", { error });
+    return [];
+  }
+}
+async function saveProject(project) {
+  try {
+    await indexedDBService_default.put(DB_NAME4, DB_VERSION4, STORE_NAME4, project, storeConfigs4);
+    debugLogger.info("Project saved", {
+      projectId: project.id,
+      projectName: project.name
+    });
+  } catch (error) {
+    debugLogger.error("Failed to save project", { projectId: project.id, error });
+    throw error;
+  }
+}
+async function deleteProjectFromDB(id) {
+  try {
+    await indexedDBService_default.delete(DB_NAME4, DB_VERSION4, STORE_NAME4, id, storeConfigs4);
+    debugLogger.info("Project deleted from DB", { projectId: id });
+  } catch (error) {
+    debugLogger.error("Failed to delete project from DB", { projectId: id, error });
+    throw error;
+  }
+}
+var useProjectStore = create3((set, get) => ({
+  projects: [],
+  _hasHydrated: false,
+  hydrate: async () => {
+    try {
+      const projects = await loadProjects();
+      set({ projects, _hasHydrated: true });
+      debugLogger.info("Project store hydrated", { projectCount: projects.length });
+    } catch (error) {
+      debugLogger.error("Failed to hydrate project store", { error });
+      set({ projects: [], _hasHydrated: true });
+    }
+  },
+  createProject: async (name, description, color) => {
+    const { projects } = get();
+    const id = newId();
+    const now = /* @__PURE__ */ new Date();
+    const projectColor = color || DEFAULT_COLORS[projects.length % DEFAULT_COLORS.length];
+    const newProject = normalizeProject({
+      id,
+      name: name.trim(),
+      description: description?.trim(),
+      color: projectColor,
+      createdAt: now,
+      updatedAt: now,
+      order: projects.length,
+      version: 0
+    });
+    await saveProject(newProject);
+    set((state) => ({
+      projects: [...state.projects, newProject]
+    }));
+    emitProjectUpsert(id);
+    debugLogger.info("Project created", { projectId: id, projectName: name });
+    return newProject;
+  },
+  deleteProject: async (id) => {
+    await deleteProjectFromDB(id);
+    set((state) => ({
+      projects: state.projects.filter((p) => p.id !== id)
+    }));
+    debugLogger.info("Project deleted", { projectId: id });
+    emitProjectDelete(id);
+  },
+  renameProject: async (id, newName, description) => {
+    const { projects } = get();
+    const project = projects.find((p) => p.id === id);
+    if (!project) {
+      throw new Error(`Project with id ${id} not found`);
+    }
+    const updatedProject = normalizeProject({
+      ...project,
+      name: newName.trim(),
+      description: description?.trim(),
+      updatedAt: /* @__PURE__ */ new Date()
+    });
+    await saveProject(updatedProject);
+    set((state) => ({
+      projects: state.projects.map((p) => p.id === id ? updatedProject : p)
+    }));
+    debugLogger.info("Project renamed", { projectId: id, newName });
+    emitProjectUpsert(id);
+  },
+  updateProjectColor: async (id, color) => {
+    const { projects } = get();
+    const project = projects.find((p) => p.id === id);
+    if (!project) {
+      throw new Error(`Project with id ${id} not found`);
+    }
+    const updatedProject = normalizeProject({
+      ...project,
+      color,
+      updatedAt: /* @__PURE__ */ new Date()
+    });
+    await saveProject(updatedProject);
+    set((state) => ({
+      projects: state.projects.map((p) => p.id === id ? updatedProject : p)
+    }));
+    debugLogger.info("Project color updated", { projectId: id, color });
+    emitProjectUpsert(id);
+  },
+  updateProjectInstructions: async (id, instructions) => {
+    const { projects } = get();
+    const project = projects.find((p) => p.id === id);
+    if (!project) {
+      throw new Error(`Project with id ${id} not found`);
+    }
+    const updatedProject = normalizeProject({
+      ...project,
+      instructions: instructions.trim() || void 0,
+      updatedAt: /* @__PURE__ */ new Date()
+    });
+    await saveProject(updatedProject);
+    set((state) => ({
+      projects: state.projects.map((p) => p.id === id ? updatedProject : p)
+    }));
+    debugLogger.info("Project instructions updated", { projectId: id });
+    emitProjectUpsert(id);
+  },
+  reorderProjects: async (projectIds) => {
+    const { projects } = get();
+    const reorderedProjects = projectIds.map((id, index) => {
+      const project = projects.find((p) => p.id === id);
+      if (!project) return null;
+      return normalizeProject({ ...project, order: index, updatedAt: /* @__PURE__ */ new Date() });
+    }).filter(Boolean);
+    await Promise.all(reorderedProjects.map(saveProject));
+    set({ projects: reorderedProjects });
+    debugLogger.info("Projects reordered", { projectCount: reorderedProjects.length });
+    reorderedProjects.forEach((project) => emitProjectUpsert(project.id));
+  },
+  applyRemoteProjects: async (incoming) => {
+    const normalized = incoming.map(normalizeProject);
+    try {
+      await Promise.all(normalized.map((project) => saveProject(project)));
+    } catch (error) {
+      debugLogger.error("Failed to persist remote projects", { error });
+    }
+    set((state) => {
+      const next = new Map(state.projects.map((p) => [p.id, p]));
+      for (const project of normalized) {
+        next.set(project.id, project);
+      }
+      return { projects: Array.from(next.values()).sort((a, b) => a.order - b.order) };
+    });
+  },
+  removeProjectsByIds: async (ids) => {
+    if (!ids.length) {
+      return;
+    }
+    try {
+      await Promise.all(ids.map((id) => deleteProjectFromDB(id)));
+    } catch (error) {
+      debugLogger.error("Failed to delete projects from IndexedDB", { error, ids });
+    }
+    set((state) => ({
+      projects: state.projects.filter((p) => !ids.includes(p.id))
+    }));
+    ids.forEach((id) => emitProjectDelete(id));
+  }
+}));
+function normalizeProject(project) {
+  const ensureDate = (value) => {
+    if (!value) return /* @__PURE__ */ new Date();
+    if (value instanceof Date) return value;
+    const parsed = new Date(value);
+    return Number.isNaN(parsed.getTime()) ? /* @__PURE__ */ new Date() : parsed;
+  };
+  return {
+    ...project,
+    createdAt: ensureDate(project.createdAt),
+    updatedAt: ensureDate(project.updatedAt),
+    lastActivityAt: project.lastActivityAt ? ensureDate(project.lastActivityAt) : void 0
+  };
+}
+function emitProjectUpsert(id) {
+  if (typeof window === "undefined") return;
+  window.dispatchEvent(new CustomEvent(PROJECT_UPSERT_EVENT, { detail: id }));
+}
+function emitProjectDelete(id) {
+  if (typeof window === "undefined") return;
+  window.dispatchEvent(new CustomEvent(PROJECT_DELETE_EVENT, { detail: id }));
+}
+var PROJECT_COLORS = DEFAULT_COLORS;
+
+// src/types/featureFlags.ts
+var DEFAULT_TIER_FEATURES = {
+  basic: {
+    memory: true,
+    documentKnowledge: false,
+    moodAdaptation: false,
+    chatSuggestions: true,
+    tts: false,
+    stt: false,
+    adminDashboardEnabled: false,
+    limitedAdminDashboard: false,
+    semanticSearchSimple: true,
+    semanticSearchPremium: false,
+    advancedSearch: false,
+    // No advanced features for basic
+    advancedMemories: false
+    // No advanced features for basic
+  },
+  premium: {
+    memory: true,
+    documentKnowledge: true,
+    moodAdaptation: true,
+    chatSuggestions: true,
+    tts: true,
+    stt: true,
+    adminDashboardEnabled: false,
+    limitedAdminDashboard: true,
+    // Premium gets limited admin access
+    semanticSearchSimple: true,
+    semanticSearchPremium: false,
+    // No premium search for limited admin
+    advancedSearch: false,
+    // No vector DB search yet
+    advancedMemories: false
+    // No vector DB memories yet
+  },
+  pro: {
+    memory: true,
+    documentKnowledge: true,
+    moodAdaptation: true,
+    chatSuggestions: true,
+    tts: true,
+    stt: true,
+    adminDashboardEnabled: false,
+    limitedAdminDashboard: true,
+    semanticSearchSimple: true,
+    semanticSearchPremium: true,
+    advancedSearch: true,
+    // Pro gets vector DB search
+    advancedMemories: true
+    // Pro gets vector DB memories
+  },
+  team: {
+    memory: true,
+    documentKnowledge: true,
+    moodAdaptation: true,
+    chatSuggestions: true,
+    tts: true,
+    stt: true,
+    adminDashboardEnabled: true,
+    // Full admin access
+    limitedAdminDashboard: true,
+    semanticSearchSimple: true,
+    semanticSearchPremium: true,
+    advancedSearch: true,
+    // Team gets vector DB search
+    advancedMemories: true
+    // Team gets vector DB memories
+  },
+  trial: {
+    memory: true,
+    documentKnowledge: true,
+    moodAdaptation: true,
+    chatSuggestions: true,
+    tts: true,
+    stt: true,
+    adminDashboardEnabled: false,
+    limitedAdminDashboard: true,
+    // Trial gets limited admin like pro
+    semanticSearchSimple: true,
+    semanticSearchPremium: true,
+    // Trial gets pro-level search
+    advancedSearch: true,
+    // Trial gets pro-level features
+    advancedMemories: true
+    // Trial gets pro-level features
+  },
+  expired: {
+    memory: false,
+    documentKnowledge: false,
+    moodAdaptation: false,
+    chatSuggestions: false,
+    tts: false,
+    stt: false,
+    adminDashboardEnabled: false,
+    limitedAdminDashboard: false,
+    semanticSearchSimple: false,
+    semanticSearchPremium: false,
+    // Expired users get no features
+    advancedSearch: false,
+    // No advanced features
+    advancedMemories: false
+    // No advanced features
+  }
+};
+var OSS_DEFAULT_FEATURES = {
+  memory: true,
+  documentKnowledge: true,
+  moodAdaptation: true,
+  chatSuggestions: true,
+  tts: true,
+  stt: true,
+  adminDashboardEnabled: true,
+  limitedAdminDashboard: true,
+  semanticSearchSimple: true,
+  semanticSearchPremium: true,
+  advancedSearch: true,
+  // OSS gets all features
+  advancedMemories: true
+  // OSS gets all features
+};
+
+// src/contexts/FeatureFlagContext.tsx
+import {
+  createContext,
+  useContext,
+  useEffect,
+  useState,
+  useCallback
+} from "react";
+import { jsx } from "react/jsx-runtime";
+var readSessionToken = (jwtStorageKey) => {
+  const fromStorage = () => {
+    try {
+      return localStorage.getItem(jwtStorageKey);
+    } catch {
+      return null;
+    }
+  };
+  if (jwtStorageKey && jwtStorageKey !== TOKEN_KEY) {
+    return fromStorage() ?? authenticationService.getToken();
+  }
+  return authenticationService.getToken() ?? fromStorage();
+};
+var FeatureFlagContext = createContext(
+  void 0
+);
+function decodeJWT(token) {
+  try {
+    const parts = token.split(".");
+    if (parts.length !== 3) return null;
+    const payload = parts[1];
+    const decoded = atob(payload.replace(/-/g, "+").replace(/_/g, "/"));
+    return JSON.parse(decoded);
+  } catch (error) {
+    debugLogger.error("Failed to decode JWT:", { error });
+    return null;
+  }
+}
+function isJWTExpired(payload) {
+  if (!payload.exp) return false;
+  return Date.now() >= payload.exp * 1e3;
+}
+var coerceNumber = (value, fallback) => {
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return value;
+  }
+  if (typeof value === "string") {
+    const parsed = Number(value);
+    if (Number.isFinite(parsed)) {
+      return parsed;
+    }
+  }
+  return fallback;
+};
+var coerceBoolean = (value, fallback) => {
+  if (typeof value === "boolean") {
+    return value;
+  }
+  if (typeof value === "string") {
+    return value.toLowerCase() === "true";
+  }
+  if (typeof value === "number") {
+    return value !== 0;
+  }
+  return fallback;
+};
+var FeatureFlagProvider = ({
+  config,
+  children
+}) => {
+  const [evaluation, setEvaluation] = useState(null);
+  const [currentTier, setCurrentTier] = useState(
+    config.subscriptionType
+  );
+  const evaluateFeatures = useCallback(() => {
+    const {
+      subscriptionType,
+      rolesClaimKey = "roles",
+      subscriptionTypeClaimKey = "subscriptionType",
+      isSubscribedClaimKey = "isSubscribed",
+      jwtStorageKey = "bandit-jwt",
+      featureMatrix = {},
+      adminRole = "admin",
+      debug = false
+    } = config;
+    let jwtFound = false;
+    let jwtValid = false;
+    let rolesExtracted = [];
+    let isAdmin = false;
+    let jwtSubscriptionType;
+    let jwtIsSubscribed = true;
+    let jwtTrialUsage;
+    let effectiveTier = currentTier || subscriptionType || "oss";
+    if (typeof window !== "undefined") {
+      try {
+        const token = readSessionToken(jwtStorageKey);
+        if (token) {
+          jwtFound = true;
+          const payload = decodeJWT(token);
+          if (payload && !isJWTExpired(payload)) {
+            jwtValid = true;
+            const roles = payload[rolesClaimKey];
+            if (Array.isArray(roles)) {
+              rolesExtracted = roles.filter(
+                (role) => typeof role === "string"
+              );
+              isAdmin = rolesExtracted.includes(adminRole);
+            }
+            const jwtSubType = payload[subscriptionTypeClaimKey];
+            if (typeof jwtSubType === "string" && ["basic", "premium", "pro", "team", "trial", "expired"].includes(jwtSubType)) {
+              jwtSubscriptionType = jwtSubType;
+              effectiveTier = jwtSubscriptionType;
+            }
+            if (Object.prototype.hasOwnProperty.call(payload, isSubscribedClaimKey)) {
+              jwtIsSubscribed = coerceBoolean(
+                payload[isSubscribedClaimKey],
+                jwtIsSubscribed
+              );
+            }
+            if (jwtSubscriptionType === "trial") {
+              const chatRequestsUsedRaw = payload.chatRequestsUsed ?? payload.ChatRequestsUsed;
+              const chatRequestsLimitRaw = payload.chatRequestsLimit ?? payload.ChatRequestsLimit;
+              const generateRequestsUsedRaw = payload.generateRequestsUsed ?? payload.GenerateRequestsUsed;
+              const generateRequestsLimitRaw = payload.generateRequestsLimit ?? payload.GenerateRequestsLimit;
+              jwtTrialUsage = {
+                chatRequestsUsed: coerceNumber(chatRequestsUsedRaw, 0),
+                chatRequestsLimit: coerceNumber(chatRequestsLimitRaw, 40),
+                generateRequestsUsed: coerceNumber(generateRequestsUsedRaw, 0),
+                generateRequestsLimit: coerceNumber(generateRequestsLimitRaw, 1e3)
+              };
+            }
+          }
+        }
+      } catch (error) {
+        if (debug) {
+          debugLogger.error("Error processing JWT for feature flags:", { error });
+        }
+      }
+    }
+    let finalFeatures;
+    if (!subscriptionType && !currentTier && !jwtSubscriptionType) {
+      finalFeatures = { ...OSS_DEFAULT_FEATURES, ...featureMatrix };
+      effectiveTier = "oss";
+    } else if (isAdmin) {
+      finalFeatures = { ...OSS_DEFAULT_FEATURES };
+    } else {
+      const tierFeatures = effectiveTier !== "oss" ? DEFAULT_TIER_FEATURES[effectiveTier] : OSS_DEFAULT_FEATURES;
+      finalFeatures = { ...tierFeatures, ...featureMatrix };
+    }
+    const result = {
+      tier: effectiveTier,
+      isAdmin,
+      isSubscribed: jwtIsSubscribed,
+      trialUsage: jwtTrialUsage,
+      features: finalFeatures,
+      metadata: {
+        jwtFound,
+        jwtValid,
+        rolesExtracted,
+        subscriptionTypeFromJWT: jwtSubscriptionType,
+        isSubscribedFromJWT: jwtIsSubscribed,
+        trialUsageFromJWT: jwtTrialUsage,
+        evaluatedAt: Date.now()
+      }
+    };
+    if (debug) {
+      debugLogger.info("Feature flag evaluation:", result);
+    }
+    return result;
+  }, [config, currentTier]);
+  const refreshEvaluation = useCallback(() => {
+    const newEvaluation = evaluateFeatures();
+    setEvaluation(newEvaluation);
+  }, [evaluateFeatures]);
+  useEffect(() => {
+    refreshEvaluation();
+    const handleStorageChange = (e) => {
+      if (e.key === config.jwtStorageKey || e.key === null) {
+        refreshEvaluation();
+      }
+    };
+    const handleTierUpdate = (e) => {
+      if (e.detail?.tier) {
+        setCurrentTier(e.detail.tier);
+      }
+    };
+    const handleSessionChange = () => refreshEvaluation();
+    window.addEventListener("storage", handleStorageChange);
+    window.addEventListener(AUTH_TOKEN_CHANGED_EVENT, handleSessionChange);
+    window.addEventListener("bandit:tier-updated", handleTierUpdate);
+    return () => {
+      window.removeEventListener("storage", handleStorageChange);
+      window.removeEventListener(AUTH_TOKEN_CHANGED_EVENT, handleSessionChange);
+      window.removeEventListener(
+        "bandit:tier-updated",
+        handleTierUpdate
+      );
+    };
+  }, [refreshEvaluation, config.jwtStorageKey]);
+  const contextValue = {
+    hasFeature: (feature) => {
+      return evaluation?.features[feature] ?? false;
+    },
+    getEvaluation: () => evaluation,
+    refreshEvaluation,
+    isAdmin: () => evaluation?.isAdmin ?? false,
+    getCurrentTier: () => evaluation?.tier ?? "oss",
+    updateTier: (tier) => {
+      setCurrentTier(tier);
+    },
+    isOSSMode: () => {
+      if (!evaluation) {
+        return true;
+      }
+      return evaluation.tier === "oss";
+    }
+  };
+  return /* @__PURE__ */ jsx(FeatureFlagContext.Provider, { value: contextValue, children });
+};
+var useFeatureFlag = () => {
+  const context = useContext(FeatureFlagContext);
+  if (context === void 0) {
+    throw new Error("useFeatureFlag must be used within a FeatureFlagProvider");
+  }
+  return context;
+};
+
+// src/hooks/useFeatures.ts
+import { useContext as useContext2 } from "react";
+var useFeatures = () => {
+  const featureFlag = useContext2(FeatureFlagContext);
+  if (!featureFlag) {
+    return {
+      hasFeature: () => true,
+      hasMemory: () => true,
+      hasDocumentKnowledge: () => true,
+      hasMoodAdaptation: () => true,
+      hasChatSuggestions: () => true,
+      hasTTS: () => true,
+      hasSTT: () => true,
+      hasAdminDashboard: () => true,
+      hasLimitedAdminDashboard: () => true,
+      hasSimpleSearch: () => true,
+      hasPremiumSearch: () => true,
+      hasAdvancedSearch: () => true,
+      hasAdvancedMemories: () => true,
+      isAdmin: () => false,
+      getCurrentTier: () => "oss",
+      isOSSMode: () => true,
+      isSubscribed: () => true,
+      isPremiumTier: () => false,
+      isProTier: () => false,
+      isTrialTier: () => false,
+      isTeamTier: () => false,
+      isExpiredTier: () => false,
+      needsUpgrade: () => false,
+      getTrialUsage: () => void 0,
+      isTrialLimitReached: () => false,
+      getTrialRemainingRequests: () => null,
+      updateTier: () => void 0,
+      refreshFeatures: () => void 0,
+      getFullEvaluation: () => null
+    };
+  }
+  return {
+    // Core feature checking
+    hasFeature: (feature) => featureFlag.hasFeature(feature),
+    // Convenience methods for common features
+    hasMemory: () => featureFlag.hasFeature("memory"),
+    hasDocumentKnowledge: () => featureFlag.hasFeature("documentKnowledge"),
+    hasMoodAdaptation: () => featureFlag.hasFeature("moodAdaptation"),
+    hasChatSuggestions: () => featureFlag.hasFeature("chatSuggestions"),
+    hasTTS: () => featureFlag.hasFeature("tts"),
+    hasSTT: () => featureFlag.hasFeature("stt"),
+    hasAdminDashboard: () => featureFlag.hasFeature("adminDashboardEnabled"),
+    hasLimitedAdminDashboard: () => featureFlag.hasFeature("limitedAdminDashboard"),
+    hasSimpleSearch: () => featureFlag.hasFeature("semanticSearchSimple"),
+    hasPremiumSearch: () => featureFlag.hasFeature("semanticSearchPremium"),
+    hasAdvancedSearch: () => featureFlag.hasFeature("advancedSearch"),
+    hasAdvancedMemories: () => featureFlag.hasFeature("advancedMemories"),
+    // Admin and tier checking
+    isAdmin: () => featureFlag.isAdmin(),
+    getCurrentTier: () => featureFlag.getCurrentTier(),
+    isOSSMode: () => featureFlag.isOSSMode(),
+    isSubscribed: () => featureFlag.getEvaluation()?.isSubscribed ?? true,
+    // Tier comparison helpers
+    isPremiumTier: () => {
+      const tier = featureFlag.getCurrentTier();
+      return tier === "premium" || tier === "pro" || tier === "team" || tier === "trial";
+    },
+    isProTier: () => {
+      const tier = featureFlag.getCurrentTier();
+      return tier === "pro" || tier === "team" || tier === "trial";
+    },
+    isTrialTier: () => featureFlag.getCurrentTier() === "trial",
+    isTeamTier: () => featureFlag.getCurrentTier() === "team",
+    isExpiredTier: () => featureFlag.getCurrentTier() === "expired",
+    // Upgrade checking
+    needsUpgrade: (feature, requiredTier) => {
+      if (featureFlag.isAdmin() || featureFlag.isOSSMode()) {
+        return false;
+      }
+      if (!featureFlag.hasFeature(feature)) {
+        return requiredTier || "premium";
+      }
+      return false;
+    },
+    // Trial usage tracking
+    getTrialUsage: () => featureFlag.getEvaluation()?.trialUsage,
+    isTrialLimitReached: (type) => {
+      const usage = featureFlag.getEvaluation()?.trialUsage;
+      if (!usage) return false;
+      if (type === "chat") {
+        return usage.chatRequestsUsed >= usage.chatRequestsLimit;
+      } else {
+        return usage.generateRequestsUsed >= usage.generateRequestsLimit;
+      }
+    },
+    getTrialRemainingRequests: (type) => {
+      const usage = featureFlag.getEvaluation()?.trialUsage;
+      if (!usage) return null;
+      if (type === "chat") {
+        return Math.max(0, usage.chatRequestsLimit - usage.chatRequestsUsed);
+      } else {
+        return Math.max(0, usage.generateRequestsLimit - usage.generateRequestsUsed);
+      }
+    },
+    // Management
+    updateTier: (tier) => featureFlag.updateTier(tier),
+    refreshFeatures: () => featureFlag.refreshEvaluation(),
+    // Full evaluation access
+    getFullEvaluation: () => featureFlag.getEvaluation()
+  };
+};
+var useFeatureVisibility = () => {
+  const features = useFeatures();
+  return {
+    // UI visibility helpers
+    showMemoryToggle: () => features.hasMemory() || features.isOSSMode(),
+    showDocumentUpload: () => features.hasDocumentKnowledge() || features.isOSSMode(),
+    showMoodSettings: () => features.hasMoodAdaptation() || features.isOSSMode(),
+    showSuggestions: () => features.hasChatSuggestions() || features.isOSSMode(),
+    showVoiceControls: () => features.hasTTS() || features.hasSTT() || features.isOSSMode(),
+    showAdminPanel: () => features.hasAdminDashboard() || features.isAdmin(),
+    showLimitedAdminPanel: () => features.hasLimitedAdminDashboard() || features.isOSSMode(),
+    showAdvancedSearch: () => features.hasPremiumSearch() || features.isOSSMode(),
+    // Upgrade prompts
+    shouldShowUpgradePrompt: (feature) => {
+      return !features.isOSSMode() && !features.isAdmin() && !features.hasFeature(feature);
+    },
+    getUpgradeMessage: (feature) => {
+      const tier = features.needsUpgrade(feature);
+      if (!tier) return null;
+      const featureNames = {
+        memory: "Conversation Memory",
+        documentKnowledge: "Document Knowledge",
+        moodAdaptation: "Mood Adaptation",
+        chatSuggestions: "Chat Suggestions",
+        tts: "Text-to-Speech",
+        stt: "Speech-to-Text",
+        adminDashboardEnabled: "Admin Dashboard",
+        limitedAdminDashboard: "Limited Admin Dashboard",
+        semanticSearchSimple: "Simple Search",
+        semanticSearchPremium: "Premium Search",
+        advancedSearch: "Advanced Vector Search",
+        advancedMemories: "Advanced Vector Memories"
+      };
+      return `${featureNames[feature]} requires ${tier} subscription`;
+    }
+  };
+};
+
+// src/chat/chat-tokens.tsx
+import React2 from "react";
+import { Box, IconButton } from "@mui/material";
+import { alpha } from "@mui/material/styles";
+
+// ../../node_modules/@burtson-labs/ui/dist/tokens.js
+var light = {
+  background: "#fbfafc",
+  foreground: "#17131c",
+  surface: "#ffffff",
+  "surface-raised": "#ffffff",
+  "surface-muted": "#f7f4f9",
+  card: "#ffffff",
+  "card-foreground": "#17131c",
+  popover: "#ffffff",
+  "popover-foreground": "#17131c",
+  primary: "#8f0bc7",
+  "primary-foreground": "#ffffff",
+  secondary: "#f1edf4",
+  "secondary-foreground": "#29212f",
+  muted: "#f4f1f6",
+  "muted-foreground": "#6c6472",
+  accent: "#f3e7fb",
+  "accent-foreground": "#561071",
+  destructive: "#c92d3f",
+  "destructive-foreground": "#ffffff",
+  success: "#0e7a56",
+  "success-foreground": "#ffffff",
+  warning: "#9b5c08",
+  "warning-foreground": "#ffffff",
+  info: "#2563eb",
+  "info-foreground": "#ffffff",
+  recording: "#d6293e",
+  "recording-foreground": "#ffffff",
+  border: "#e5dfe8",
+  "border-strong": "#cfc5d5",
+  input: "#d8cfdd",
+  ring: "#a60ee5",
+  brand: "#a60ee5",
+  "brand-hover": "#8f0bc7",
+  "brand-soft": "#f5e8fc",
+  "brand-soft-foreground": "#5b1476",
+  code: "#18141d",
+  "code-foreground": "#f5f0f7"
+};
+var dark = {
+  background: "#0d0d12",
+  foreground: "#f2eef5",
+  surface: "#121218",
+  "surface-raised": "#18171f",
+  "surface-muted": "#17151c",
+  card: "#14131a",
+  "card-foreground": "#f2eef5",
+  popover: "#18171f",
+  "popover-foreground": "#f2eef5",
+  primary: "#8f0bc7",
+  "primary-foreground": "#ffffff",
+  secondary: "#211e28",
+  "secondary-foreground": "#e7e0eb",
+  muted: "#1b1921",
+  "muted-foreground": "#a49ca9",
+  accent: "#291734",
+  "accent-foreground": "#efd7fa",
+  destructive: "#ef5b65",
+  "destructive-foreground": "#1b090b",
+  success: "#36c58d",
+  "success-foreground": "#07160f",
+  warning: "#f3b24c",
+  "warning-foreground": "#201304",
+  info: "#6ea8ff",
+  "info-foreground": "#071226",
+  recording: "#f2616d",
+  "recording-foreground": "#1b090b",
+  border: "#2a2732",
+  "border-strong": "#403a49",
+  input: "#34303d",
+  ring: "#c65ef1",
+  brand: "#c65ef1",
+  "brand-hover": "#d384f3",
+  "brand-soft": "#291734",
+  "brand-soft-foreground": "#efd7fa",
+  code: "#09090d",
+  "code-foreground": "#f5f0f7"
+};
+var radius = {
+  xs: "0.375rem",
+  sm: "0.5rem",
+  md: "0.625rem",
+  lg: "0.75rem",
+  xl: "1rem",
+  full: "9999px"
+};
+var shadow = {
+  xs: "0 1px 2px rgb(10 8 14 / 0.05)",
+  sm: "0 1px 3px rgb(10 8 14 / 0.08), 0 1px 2px rgb(10 8 14 / 0.05)",
+  md: "0 10px 30px rgb(10 8 14 / 0.10), 0 2px 8px rgb(10 8 14 / 0.06)",
+  focus: "0 0 0 3px color-mix(in srgb, var(--ring) 22%, transparent)"
+};
+var fontSans = 'Inter, ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif';
+var fontMono = '"JetBrains Mono", "SFMono-Regular", Consolas, "Liberation Mono", monospace';
+var duration = {
+  fast: 120,
+  standard: 180,
+  emphasis: 240,
+  exit: 140
+};
+var easing = {
+  standard: "cubic-bezier(0.2, 0, 0, 1)",
+  emphasized: "cubic-bezier(0.16, 1, 0.3, 1)",
+  exit: "cubic-bezier(0.4, 0, 1, 1)"
+};
+var elevation = {
+  0: "none",
+  1: shadow.xs,
+  2: shadow.sm,
+  3: shadow.md
+};
+function parseHex(hex) {
+  const h = hex.replace("#", "").trim();
+  const full = h.length === 3 ? [...h].map((c) => c + c).join("") : h.slice(0, 6);
+  if (!/^[0-9a-f]{6}$/i.test(full)) throw new Error(`Not a hex colour: ${hex}`);
+  return [
+    0,
+    2,
+    4
+  ].map((i) => parseInt(full.slice(i, i + 2), 16));
+}
+var toHex = (rgb) => "#" + rgb.map((v) => Math.round(Math.max(0, Math.min(255, v))).toString(16).padStart(2, "0")).join("");
+function mix(a, b, t) {
+  const x = parseHex(a);
+  const y = parseHex(b);
+  return toHex([
+    0,
+    1,
+    2
+  ].map((i) => x[i] + (y[i] - x[i]) * t));
+}
+function luminance(hex) {
+  const c = parseHex(hex).map((v) => {
+    const s = v / 255;
+    return s <= 0.03928 ? s / 12.92 : ((s + 0.055) / 1.055) ** 2.4;
+  });
+  return 0.2126 * c[0] + 0.7152 * c[1] + 0.0722 * c[2];
+}
+function contrast(a, b) {
+  const [hi, lo] = [luminance(a), luminance(b)].sort((m, n) => n - m);
+  return (hi + 0.05) / (lo + 0.05);
+}
+function ensureContrast(color, against, ratio, target) {
+  let c = color;
+  for (let i = 0; i < 20 && contrast(c, against) < ratio; i++) c = mix(c, target, 0.1);
+  return c;
+}
+function accentTokens(accent, mode) {
+  const p = mode === "dark" ? dark : light;
+  const white = "#ffffff";
+  const onFill = contrast(accent, white) >= 2.6 ? white : "#111111";
+  const primary = onFill === white ? ensureContrast(accent, white, 4.5, "#000000") : ensureContrast(accent, "#111111", 4.5, white);
+  const brand = mode === "dark" ? ensureContrast(mix(accent, white, 0.12), p.background, 4.5, white) : ensureContrast(accent, p.background, 4.5, "#000000");
+  const brandHover = mode === "dark" ? mix(brand, white, 0.18) : mix(brand, "#000000", 0.14);
+  const soft = mode === "dark" ? mix(p.background, accent, 0.16) : mix(white, accent, 0.1);
+  const softFg = mode === "dark" ? mix(accent, white, 0.72) : mix(accent, "#000000", 0.55);
+  return {
+    primary,
+    "primary-foreground": onFill,
+    brand,
+    "brand-hover": brandHover,
+    "brand-soft": soft,
+    "brand-soft-foreground": ensureContrast(softFg, soft, 4.5, mode === "dark" ? white : "#000000"),
+    accent: soft,
+    "accent-foreground": ensureContrast(softFg, soft, 4.5, mode === "dark" ? white : "#000000"),
+    ring: brand
+  };
+}
+
+// src/chat/chat-tokens.tsx
+import { jsx as jsx2 } from "react/jsx-runtime";
+function chatTokens(theme) {
+  const own = theme.palette.bandit;
+  if (own) return own;
+  const p = theme.palette;
+  const chat = p.chat;
+  const bg = chat?.shell ?? p.background.default;
+  const fg = chat?.fileText ?? p.text.primary;
+  const muted = chat?.badge ?? p.action.hover;
+  const border = p.divider;
+  const kit = p.mode === "dark" ? dark : light;
+  return {
+    surface: {
+      base: bg,
+      raised: chat?.input ?? p.background.paper,
+      subtle: chat?.file ?? p.background.paper,
+      interactive: muted,
+      interactiveHover: chat?.badgeHover ?? p.action.selected,
+      overlay: p.background.paper,
+      terminal: p.grey[900],
+      terminalForeground: p.grey[100]
+    },
+    composer: {
+      surface: chat?.input ?? p.background.paper,
+      border,
+      borderFocus: p.primary.main,
+      foreground: fg,
+      placeholder: p.text.secondary
+    },
+    control: {
+      surface: muted,
+      surfaceHover: chat?.badgeHover ?? p.action.selected,
+      foreground: fg,
+      foregroundMuted: p.text.secondary,
+      primarySurface: p.primary.main,
+      primaryForeground: p.primary.contrastText
+    },
+    attachment: {
+      surface: chat?.file ?? muted,
+      border,
+      foreground: fg,
+      icon: p.text.secondary
+    },
+    conversation: {
+      user: { surface: muted, foreground: fg, border },
+      assistant: { surface: "transparent", foreground: fg, border: "transparent" },
+      border,
+      divider: border,
+      meta: chat?.caption ?? p.text.secondary,
+      code: { surface: p.grey[900], foreground: p.grey[100] }
+    },
+    agent: {
+      active: p.primary.main,
+      idle: p.text.secondary,
+      surface: alpha(p.primary.main, 0.12)
+    },
+    engine: { accent: p.primary.main, surface: alpha(p.primary.main, 0.12) },
+    tool: { surface: muted, border, foreground: fg },
+    knowledge: { accent: p.info.main, surface: alpha(p.info.main, 0.1) },
+    workspace: { surface: p.background.paper, border },
+    status: {
+      recording: kit.recording,
+      transcribing: p.info.main,
+      thinking: p.primary.main,
+      streaming: p.primary.main,
+      syncing: p.info.main,
+      temporary: p.warning.main,
+      degraded: p.warning.main,
+      disconnected: p.text.secondary,
+      available: p.success.main,
+      premium: p.primary.main,
+      locked: p.text.secondary,
+      info: p.info.main,
+      success: p.success.main,
+      warning: p.warning.main,
+      error: p.error.main
+    }
+  };
+}
+var CODE_EXT = /* @__PURE__ */ new Set([
+  "js",
+  "jsx",
+  "ts",
+  "tsx",
+  "py",
+  "java",
+  "c",
+  "cpp",
+  "cs",
+  "go",
+  "rb",
+  "rs",
+  "php",
+  "sh",
+  "sql",
+  "html",
+  "css"
+]);
+function fileIconFor(filename) {
+  const ext = filename.split(".").pop()?.toLowerCase() ?? "";
+  if (ext === "json" || ext === "yaml" || ext === "yml" || ext === "toml") return Braces;
+  if (ext === "pdf") return FilePdf;
+  if (["png", "jpg", "jpeg", "gif", "webp", "svg", "heic"].includes(ext))
+    return FileImage;
+  if (["csv", "xlsx", "xls", "tsv"].includes(ext)) return Sheet;
+  if (["zip", "gz", "tar", "7z", "rar"].includes(ext)) return Archive;
+  if (CODE_EXT.has(ext)) return FileCode;
+  if (["md", "txt", "docx", "doc", "rtf"].includes(ext)) return FileText;
+  return File;
+}
+var monoFont = fontMono;
+function fileExtensionLabel(filename) {
+  const parts = filename.split(".");
+  return parts.length > 1 ? (parts.pop() ?? "").slice(0, 4).toUpperCase() : "";
+}
+var ComposerControl = React2.forwardRef(
+  function ComposerControl2({
+    visualSize,
+    hitSize,
+    surface,
+    surfaceHover,
+    foreground,
+    ring,
+    children,
+    sx,
+    ...rest
+  }, ref) {
+    const hit = Math.max(hitSize ?? visualSize, visualSize);
+    return /* @__PURE__ */ jsx2(
+      IconButton,
+      {
+        ref,
+        ...rest,
+        disableRipple: true,
+        sx: [
+          (t) => ({
+            width: hit,
+            height: hit,
+            p: 0,
+            borderRadius: "50%",
+            color: foreground,
+            bgcolor: "transparent",
+            "@media (pointer: coarse)": {
+              width: Math.max(hit, 44),
+              height: Math.max(hit, 44)
+            },
+            "& .bandit-control-circle": {
+              width: visualSize,
+              height: visualSize,
+              borderRadius: "50%",
+              display: "grid",
+              placeItems: "center",
+              bgcolor: surface,
+              boxShadow: ring ? `0 0 0 2px ${ring}` : "none",
+              transition: t.transitions.create(["background-color", "box-shadow"], {
+                duration: t.transitions.duration.shorter
+              })
+            },
+            "&:hover": { bgcolor: "transparent" },
+            "&:hover .bandit-control-circle": { bgcolor: surfaceHover },
+            "&.Mui-focusVisible .bandit-control-circle": {
+              boxShadow: `0 0 0 2px ${t.palette.background.default}, 0 0 0 4px ${t.palette.bandit?.composer.borderFocus ?? t.palette.primary.main}`
+            },
+            "&.Mui-disabled": { opacity: 0.5 }
+          }),
+          ...Array.isArray(sx) ? sx : sx ? [sx] : []
+        ],
+        children: /* @__PURE__ */ jsx2(Box, { component: "span", className: "bandit-control-circle", "aria-hidden": false, children })
+      }
+    );
+  }
+);
+function appBarTokens(theme) {
+  const s = chatTokens(theme);
+  return {
+    background: s.surface.base,
+    border: s.conversation.border,
+    icon: s.control.foreground,
+    iconHover: s.surface.interactive,
+    menuBackground: s.surface.overlay,
+    menuText: s.control.foreground
+  };
+}
+function responseTokens(theme) {
+  const s = chatTokens(theme);
+  return {
+    aiText: s.conversation.assistant.foreground,
+    userBubble: s.conversation.user.surface,
+    memoryText: s.status.success
+  };
+}
+
+// src/chat/sidebar/sidebarState.ts
+import { create as create4 } from "zustand";
+var SIDEBAR_WIDTH = 300;
+var SIDEBAR_COLLAPSED_KEY = "bandit.sidebar.collapsed";
+var SIDEBAR_DEFAULT_OPEN_MIN_WIDTH = 1024;
+var CHAT_VIEW = { kind: "chat" };
+var readPersistedCollapsed = () => {
+  try {
+    const raw = localStorage.getItem(SIDEBAR_COLLAPSED_KEY);
+    return raw === null ? null : raw === "1";
+  } catch {
+    return null;
+  }
+};
+var writePersistedCollapsed = (collapsed) => {
+  try {
+    localStorage.setItem(SIDEBAR_COLLAPSED_KEY, collapsed ? "1" : "0");
+  } catch {
+  }
+};
+var initialSidebarOpen = (viewportWidth = typeof window === "undefined" ? 0 : window.innerWidth) => {
+  const persisted = readPersistedCollapsed();
+  if (persisted !== null) return !persisted;
+  return viewportWidth >= SIDEBAR_DEFAULT_OPEN_MIN_WIDTH;
+};
+function viewFromSearch(search) {
+  const params = new URLSearchParams(search);
+  const projectId = params.get("project");
+  if (projectId) return { kind: "project", projectId };
+  if (params.get("view") === "projects") return { kind: "projects" };
+  return CHAT_VIEW;
+}
+function searchWithView(search, view) {
+  const params = new URLSearchParams(search);
+  params.delete("view");
+  params.delete("project");
+  if (view.kind === "projects") params.set("view", "projects");
+  if (view.kind === "project") params.set("project", view.projectId);
+  const next = params.toString();
+  return next ? `?${next}` : "";
+}
+var sameView = (a, b) => a.kind === b.kind && (a.kind !== "project" || b.kind !== "project" || a.projectId === b.projectId);
+var useSidebarStore = create4((set) => ({
+  view: CHAT_VIEW,
+  searchFocusRequest: 0,
+  setView: (view) => set({ view }),
+  showChat: () => set({ view: CHAT_VIEW }),
+  showProjects: () => set({ view: { kind: "projects" } }),
+  openProject: (projectId) => set({ view: { kind: "project", projectId } }),
+  requestSearchFocus: () => set((state) => ({ searchFocusRequest: state.searchFocusRequest + 1 }))
+}));
+function syncViewWithUrl() {
+  if (typeof window === "undefined") return () => {
+  };
+  const store = useSidebarStore;
+  store.getState().setView(viewFromSearch(window.location.search));
+  const onPop = () => store.getState().setView(viewFromSearch(window.location.search));
+  window.addEventListener("popstate", onPop);
+  const unsubscribe = store.subscribe((state, previous) => {
+    if (sameView(state.view, previous.view)) return;
+    const current = viewFromSearch(window.location.search);
+    if (sameView(current, state.view)) return;
+    const search = searchWithView(window.location.search, state.view);
+    const url = `${window.location.pathname}${search}${window.location.hash}`;
+    window.history.pushState(window.history.state, "", url);
+  });
+  return () => {
+    window.removeEventListener("popstate", onPop);
+    unsubscribe();
+  };
+}
+var useSidebarLayout = () => usePackageSettingsStore((state) => state.settings?.navigation?.sidebar ?? "classic");
+var useSectionsLayout = () => useSidebarLayout() === "sections";
+
+// src/services/branding/brandingService.ts
+var BrandingService = class {
+  DB_NAME = "banditConfig";
+  DB_VERSION = 1;
+  STORE_NAME = "config";
+  STORE_CONFIGS = [{ name: "config", keyPath: "id" }];
+  async getBranding() {
+    try {
+      const data = await indexedDBService_default.get(
+        this.DB_NAME,
+        this.DB_VERSION,
+        this.STORE_NAME,
+        "main",
+        this.STORE_CONFIGS
+      );
+      if (data?.branding && (data.branding.logoBase64 || data.branding.hasTransparentLogo !== void 0 || data.branding.brandingText)) {
+        return {
+          logoBase64: data.branding.logoBase64,
+          hasTransparentLogo: data.branding.hasTransparentLogo,
+          brandingText: data.branding.brandingText
+        };
+      }
+      return null;
+    } catch (error) {
+      throw error;
+    }
+  }
+  async setBrandingFromConfig(config) {
+    try {
+      const existing = await indexedDBService_default.get(
+        this.DB_NAME,
+        this.DB_VERSION,
+        this.STORE_NAME,
+        "main",
+        this.STORE_CONFIGS
+      ) || { id: "main" };
+      if (existing.branding?.userSaved) {
+        debugLogger.debug(
+          "\u{1F6E1}\uFE0F BrandingService: User branding detected, blocking CDN config override"
+        );
+        return;
+      }
+      const hasUserBranding = existing.branding && (existing.branding.logoBase64 || existing.branding.brandingText || existing.branding.theme || existing.branding.hasTransparentLogo !== void 0);
+      if (hasUserBranding) {
+        debugLogger.debug(
+          "\u{1F6E1}\uFE0F BrandingService: Detected user branding data, blocking CDN config override"
+        );
+        return;
+      }
+      debugLogger.debug(
+        "\u{1F527} BrandingService: No user branding detected, applying CDN config"
+      );
+      const branding = config.branding || {};
+      const updated = {
+        ...existing,
+        branding: {
+          ...existing.branding,
+          ...branding
+        }
+      };
+      await indexedDBService_default.put(
+        this.DB_NAME,
+        this.DB_VERSION,
+        this.STORE_NAME,
+        updated,
+        this.STORE_CONFIGS
+      );
+    } catch (error) {
+      throw error;
+    }
+  }
+};
+var brandingService = new BrandingService();
+var brandingService_default = brandingService;
+
+// src/hooks/useSafeNavigate.ts
+import { useRef } from "react";
+import { useNavigate } from "react-router-dom";
+var useSafeNavigate = () => {
+  const warned = useRef(false);
+  let navigate = null;
+  try {
+    navigate = useNavigate();
+  } catch (error) {
+    if (!warned.current) {
+      debugLogger.warn("useSafeNavigate: no Router context; falling back to location", {
+        error
+      });
+      warned.current = true;
+    }
+    navigate = null;
+  }
+  return (to) => {
+    if (typeof window !== "undefined" && /^[a-z]+:\/\//i.test(to)) {
+      window.location.href = to;
+      return;
+    }
+    if (navigate) {
+      navigate(to);
+      return;
+    }
+    if (typeof window !== "undefined") {
+      window.location.href = to;
+    }
+  };
+};
+
+// src/chat/move-conversation-modal.tsx
+import { useState as useState2, useEffect as useEffect2 } from "react";
+import {
+  Dialog,
+  DialogTitle,
+  DialogContent,
+  DialogActions,
+  Button,
+  List,
+  ListItem,
+  ListItemButton,
+  ListItemText,
+  ListItemIcon,
+  Typography,
+  Avatar,
+  Radio,
+  Box as Box2,
+  Divider
+} from "@mui/material";
+import { useTheme } from "@mui/material/styles";
+import { jsx as jsx3, jsxs } from "react/jsx-runtime";
+var MoveConversationModal = ({
+  open,
+  onClose,
+  conversations,
+  currentProjectId = null
+}) => {
+  const theme = useTheme();
+  const { projects, _hasHydrated, hydrate } = useProjectStore();
+  const { moveConversationToProject } = useConversationStore();
+  const [selectedProjectId, setSelectedProjectId] = useState2(
+    currentProjectId
+  );
+  useEffect2(() => {
+    if (open && !_hasHydrated) {
+      hydrate();
+    }
+  }, [open, _hasHydrated, hydrate]);
+  useEffect2(() => {
+    setSelectedProjectId(currentProjectId);
+  }, [currentProjectId, open]);
+  const handleMove = async () => {
+    try {
+      await Promise.all(
+        conversations.map(
+          (conv) => moveConversationToProject(conv.id, selectedProjectId)
+        )
+      );
+      onClose();
+    } catch (error) {
+      debugLogger.error("Failed to move conversations", {
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+  };
+  const conversationCount = conversations.length;
+  const isMultiple = conversationCount > 1;
+  return /* @__PURE__ */ jsxs(
+    Dialog,
+    {
+      open,
+      onClose,
+      maxWidth: "sm",
+      fullWidth: true,
+      PaperProps: {
+        sx: {
+          bgcolor: theme.palette.background.paper,
+          backgroundImage: "none"
+        }
+      },
+      children: [
+        /* @__PURE__ */ jsxs(DialogTitle, { children: [
+          "Move ",
+          isMultiple ? `${conversationCount} Conversations` : "Conversation"
+        ] }),
+        /* @__PURE__ */ jsxs(DialogContent, { sx: { px: 3 }, children: [
+          /* @__PURE__ */ jsx3(Typography, { variant: "body2", color: "text.secondary", sx: { mb: 2 }, children: isMultiple ? `Select a project to move ${conversationCount} conversations to:` : `Select a project to move "${conversations[0]?.name}" to:` }),
+          /* @__PURE__ */ jsxs(List, { children: [
+            /* @__PURE__ */ jsx3(ListItem, { disablePadding: true, children: /* @__PURE__ */ jsxs(
+              ListItemButton,
+              {
+                onClick: () => setSelectedProjectId(null),
+                selected: selectedProjectId === null,
+                children: [
+                  /* @__PURE__ */ jsx3(ListItemIcon, { children: /* @__PURE__ */ jsx3(
+                    Radio,
+                    {
+                      checked: selectedProjectId === null,
+                      onChange: () => setSelectedProjectId(null),
+                      size: "small"
+                    }
+                  ) }),
+                  /* @__PURE__ */ jsx3(ListItemIcon, { children: /* @__PURE__ */ jsx3(
+                    Avatar,
+                    {
+                      sx: {
+                        bgcolor: theme.palette.grey[400],
+                        width: 32,
+                        height: 32
+                      },
+                      children: /* @__PURE__ */ jsx3(Inbox, {})
+                    }
+                  ) }),
+                  /* @__PURE__ */ jsx3(
+                    ListItemText,
+                    {
+                      primary: "No Project",
+                      secondary: "Keep conversations ungrouped"
+                    }
+                  )
+                ]
+              }
+            ) }),
+            /* @__PURE__ */ jsx3(Divider, { sx: { my: 1 } }),
+            projects.map((project) => /* @__PURE__ */ jsx3(ListItem, { disablePadding: true, children: /* @__PURE__ */ jsxs(
+              ListItemButton,
+              {
+                onClick: () => setSelectedProjectId(project.id),
+                selected: selectedProjectId === project.id,
+                children: [
+                  /* @__PURE__ */ jsx3(ListItemIcon, { children: /* @__PURE__ */ jsx3(
+                    Radio,
+                    {
+                      checked: selectedProjectId === project.id,
+                      onChange: () => setSelectedProjectId(project.id),
+                      size: "small"
+                    }
+                  ) }),
+                  /* @__PURE__ */ jsx3(ListItemIcon, { children: /* @__PURE__ */ jsx3(
+                    Avatar,
+                    {
+                      sx: {
+                        bgcolor: project.color,
+                        width: 32,
+                        height: 32
+                      },
+                      children: /* @__PURE__ */ jsx3(Folder, {})
+                    }
+                  ) }),
+                  /* @__PURE__ */ jsx3(ListItemText, { primary: project.name, secondary: project.description })
+                ]
+              }
+            ) }, project.id)),
+            projects.length === 0 && /* @__PURE__ */ jsx3(
+              Box2,
+              {
+                sx: {
+                  textAlign: "center",
+                  py: 2,
+                  color: theme.palette.text.secondary
+                },
+                children: /* @__PURE__ */ jsx3(Typography, { variant: "body2", children: "No projects available. Create a project first to organize conversations." })
+              }
+            )
+          ] })
+        ] }),
+        /* @__PURE__ */ jsxs(DialogActions, { sx: { px: 3, pb: 2 }, children: [
+          /* @__PURE__ */ jsx3(Button, { onClick: onClose, children: "Cancel" }),
+          /* @__PURE__ */ jsxs(
+            Button,
+            {
+              onClick: handleMove,
+              variant: "contained",
+              disabled: selectedProjectId === currentProjectId,
+              children: [
+                "Move ",
+                isMultiple ? "Conversations" : "Conversation"
+              ]
+            }
+          )
+        ] })
+      ]
+    }
+  );
+};
+var move_conversation_modal_default = MoveConversationModal;
+
+// src/chat/simple-conversation-item.tsx
+import { useState as useState3, useRef as useRef2, useEffect as useEffect3 } from "react";
+import {
+  Box as Box3,
+  Typography as Typography2,
+  IconButton as IconButton2,
+  Menu,
+  MenuItem,
+  ListItemIcon as ListItemIcon2,
+  ListItemText as ListItemText2,
+  useMediaQuery,
+  TextField,
+  Dialog as Dialog2,
+  DialogTitle as DialogTitle2,
+  DialogContent as DialogContent2,
+  DialogActions as DialogActions2,
+  Button as Button2
+} from "@mui/material";
+import { useTheme as useTheme2, alpha as alpha2 } from "@mui/material/styles";
+import { Fragment, jsx as jsx4, jsxs as jsxs2 } from "react/jsx-runtime";
+var SimpleConversationItem = ({
+  conversation,
+  isSelected,
+  onSelect,
+  onDelete,
+  onRename,
+  onMove,
+  projectColor,
+  snippet,
+  searchQuery,
+  onTouchDragStart,
+  onTouchDragMove,
+  onTouchDragEnd,
+  isTouchDragActive,
+  dense = false
+}) => {
+  const theme = useTheme2();
+  const isMobile = useMediaQuery(theme.breakpoints.down("sm"));
+  const [anchorEl, setAnchorEl] = useState3(null);
+  const [isEditing, setIsEditing] = useState3(false);
+  const [editName, setEditName] = useState3(conversation.name);
+  const [isDragging, setIsDragging] = useState3(false);
+  const [isTouchDragging, setIsTouchDragging] = useState3(false);
+  const [showRenameDialog, setShowRenameDialog] = useState3(false);
+  const longPressTimeoutRef = useRef2(null);
+  const touchStartPointRef = useRef2(null);
+  const activeTouchIdRef = useRef2(null);
+  const suppressClickRef = useRef2(false);
+  const highlightText = (text, query) => {
+    if (!query || !query.trim()) {
+      return text;
+    }
+    const regex = new RegExp(`(${query.trim()})`, "gi");
+    const parts = text.split(regex);
+    return parts.map(
+      (part, index) => regex.test(part) ? /* @__PURE__ */ jsx4(
+        Box3,
+        {
+          component: "span",
+          sx: {
+            bgcolor: alpha2(theme.palette.warning.main, 0.3),
+            color: theme.palette.text.primary,
+            fontWeight: 600,
+            borderRadius: 0.5,
+            px: 0.25
+          },
+          children: part
+        },
+        index
+      ) : part
+    );
+  };
+  const handleMenuOpen = (event) => {
+    event.stopPropagation();
+    event.preventDefault();
+    setAnchorEl(event.currentTarget);
+  };
+  const handleMenuClose = () => {
+    setAnchorEl(null);
+  };
+  const handleEdit = () => {
+    setEditName(conversation.name);
+    if (isMobile) {
+      setShowRenameDialog(true);
+    } else {
+      setIsEditing(true);
+    }
+    handleMenuClose();
+  };
+  const handleMove = () => {
+    if (onMove) {
+      onMove();
+    }
+    handleMenuClose();
+  };
+  const handleDelete = () => {
+    onDelete();
+    handleMenuClose();
+  };
+  const commitRename = () => {
+    const trimmed = editName.trim();
+    if (!trimmed) {
+      return;
+    }
+    if (trimmed !== conversation.name) {
+      onRename?.(trimmed);
+    }
+    setEditName(trimmed);
+  };
+  const handleSaveEdit = () => {
+    commitRename();
+    setIsEditing(false);
+  };
+  const handleCancelEdit = () => {
+    setIsEditing(false);
+    setEditName(conversation.name);
+  };
+  const handleDragStart = (e) => {
+    setIsDragging(true);
+    e.dataTransfer.setData("text/plain", conversation.id);
+    e.dataTransfer.effectAllowed = "move";
+  };
+  const handleDragEnd = () => {
+    setIsDragging(false);
+  };
+  const cancelLongPress = () => {
+    if (longPressTimeoutRef.current !== null) {
+      window.clearTimeout(longPressTimeoutRef.current);
+      longPressTimeoutRef.current = null;
+    }
+  };
+  const handleTouchStart = (e) => {
+    if (!isMobile || isEditing) return;
+    if (e.touches.length === 0) return;
+    const touch = e.touches[0];
+    touchStartPointRef.current = { x: touch.clientX, y: touch.clientY };
+    activeTouchIdRef.current = touch.identifier;
+    suppressClickRef.current = false;
+    cancelLongPress();
+    const initialTouch = touch;
+    longPressTimeoutRef.current = window.setTimeout(() => {
+      if (activeTouchIdRef.current !== null) {
+        setIsTouchDragging(true);
+        onTouchDragStart?.(conversation, initialTouch);
+      }
+    }, 350);
+  };
+  const handleTouchMove = (e) => {
+    if (!isMobile) return;
+    const targetTouch = activeTouchIdRef.current !== null ? Array.from(e.touches).find((t) => t.identifier === activeTouchIdRef.current) : e.touches[0];
+    if (!targetTouch) return;
+    if (isTouchDragging) {
+      if (e.cancelable) {
+        e.preventDefault();
+      }
+      onTouchDragMove?.(targetTouch);
+      return;
+    }
+    const startPoint = touchStartPointRef.current;
+    if (startPoint) {
+      const deltaX = Math.abs(targetTouch.clientX - startPoint.x);
+      const deltaY = Math.abs(targetTouch.clientY - startPoint.y);
+      if (deltaX > 8 || deltaY > 8) {
+        cancelLongPress();
+      }
+    }
+  };
+  const finalizeTouchDrag = (touch) => {
+    if (isTouchDragging) {
+      onTouchDragEnd?.(touch);
+      suppressClickRef.current = true;
+    }
+    setIsTouchDragging(false);
+    activeTouchIdRef.current = null;
+    touchStartPointRef.current = null;
+    cancelLongPress();
+  };
+  const handleTouchEnd = (e) => {
+    if (!isMobile) return;
+    const touch = activeTouchIdRef.current !== null ? Array.from(e.changedTouches).find(
+      (t) => t.identifier === activeTouchIdRef.current
+    ) : e.changedTouches[0];
+    finalizeTouchDrag(touch);
+  };
+  const handleTouchCancel = () => {
+    if (!isMobile) return;
+    finalizeTouchDrag();
+  };
+  useEffect3(() => {
+    if (!isTouchDragActive && isTouchDragging) {
+      setIsTouchDragging(false);
+    }
+  }, [isTouchDragActive, isTouchDragging]);
+  return /* @__PURE__ */ jsxs2(Fragment, { children: [
+    /* @__PURE__ */ jsxs2(
+      Box3,
+      {
+        "data-project-id": conversation.projectId ?? "__ungrouped",
+        draggable: !isMobile && !isEditing,
+        onDragStart: handleDragStart,
+        onDragEnd: handleDragEnd,
+        onTouchStart: handleTouchStart,
+        onTouchMove: handleTouchMove,
+        onTouchEnd: handleTouchEnd,
+        onTouchCancel: handleTouchCancel,
+        onClick: isEditing || isTouchDragging ? void 0 : (event) => {
+          if (suppressClickRef.current) {
+            suppressClickRef.current = false;
+            event.preventDefault();
+            event.stopPropagation();
+            return;
+          }
+          onSelect();
+        },
+        sx: {
+          display: "flex",
+          alignItems: "center",
+          px: 2,
+          py: dense ? 0.5 : 1.5,
+          mx: 1,
+          borderRadius: 1,
+          cursor: isEditing || isTouchDragging ? "default" : "pointer",
+          bgcolor: isSelected ? alpha2(projectColor || theme.palette.primary.main, 0.15) : "transparent",
+          border: isSelected ? `1px solid ${alpha2(projectColor || theme.palette.primary.main, 0.3)}` : "1px solid transparent",
+          opacity: isDragging || isTouchDragActive ? 0.55 : 1,
+          transition: "all 0.2s ease",
+          transform: isTouchDragActive ? "scale(0.98)" : "none",
+          boxShadow: isTouchDragActive ? `0 12px 24px ${alpha2(theme.palette.common.black, 0.25)}` : void 0,
+          touchAction: isTouchDragActive ? "none" : void 0,
+          userSelect: isTouchDragging || isTouchDragActive ? "none" : void 0,
+          WebkitUserSelect: isTouchDragging || isTouchDragActive ? "none" : void 0,
+          "&:hover": !isEditing && !isTouchDragging ? {
+            bgcolor: alpha2(theme.palette.text.primary, 0.04)
+          } : {},
+          // Better touch handling on mobile
+          ...isMobile && {
+            minHeight: dense ? 44 : 48,
+            // Larger touch target
+            userSelect: "none",
+            WebkitUserSelect: "none",
+            WebkitTouchCallout: "none",
+            "&:active": {
+              bgcolor: alpha2(theme.palette.text.primary, 0.08)
+            }
+          }
+        },
+        children: [
+          !isMobile && !isEditing && /* @__PURE__ */ jsx4(
+            GripVertical,
+            {
+              size: 16,
+              color: theme.palette.text.disabled,
+              style: { marginRight: 4, cursor: "grab" }
+            }
+          ),
+          /* @__PURE__ */ jsxs2(Box3, { sx: { flex: 1, minWidth: 0 }, children: [
+            isEditing ? /* @__PURE__ */ jsx4(
+              TextField,
+              {
+                value: editName,
+                onChange: (e) => setEditName(e.target.value),
+                onBlur: handleSaveEdit,
+                onKeyDown: (e) => {
+                  if (e.key === "Enter") {
+                    handleSaveEdit();
+                  } else if (e.key === "Escape") {
+                    handleCancelEdit();
+                  }
+                },
+                size: "small",
+                variant: "standard",
+                autoFocus: true,
+                fullWidth: true,
+                sx: {
+                  "& .MuiInput-root": {
+                    fontSize: "0.875rem"
+                  }
+                }
+              }
+            ) : /* @__PURE__ */ jsx4(
+              Typography2,
+              {
+                variant: "body2",
+                sx: {
+                  fontWeight: isSelected ? 600 : 400,
+                  color: isSelected ? projectColor || theme.palette.primary.main : theme.palette.text.primary,
+                  overflow: "hidden",
+                  textOverflow: "ellipsis",
+                  whiteSpace: "nowrap",
+                  fontSize: "0.875rem"
+                },
+                children: highlightText(conversation.name, searchQuery)
+              }
+            ),
+            !isEditing && snippet && /* @__PURE__ */ jsx4(
+              Typography2,
+              {
+                variant: "caption",
+                sx: {
+                  display: "-webkit-box",
+                  WebkitLineClamp: 2,
+                  WebkitBoxOrient: "vertical",
+                  overflow: "hidden",
+                  color: alpha2(theme.palette.text.secondary, 0.9),
+                  mt: 0.25,
+                  lineHeight: 1.3,
+                  fontSize: "0.72rem"
+                },
+                title: snippet,
+                children: highlightText(snippet, searchQuery)
+              }
+            )
+          ] }),
+          !isEditing && /* @__PURE__ */ jsx4(
+            IconButton2,
+            {
+              onClick: handleMenuOpen,
+              size: "small",
+              sx: {
+                opacity: isMobile ? 1 : isSelected ? 1 : 0,
+                // Always visible on mobile
+                color: theme.palette.text.secondary,
+                ml: 1,
+                minWidth: 32,
+                minHeight: 32,
+                transition: "opacity 0.2s ease",
+                ".MuiBox-root:hover &": {
+                  opacity: 1
+                },
+                // Larger touch target on mobile
+                ...isMobile && {
+                  padding: 1,
+                  "&:before": {
+                    content: '""',
+                    position: "absolute",
+                    top: -8,
+                    left: -8,
+                    right: -8,
+                    bottom: -8
+                  }
+                }
+              },
+              children: /* @__PURE__ */ jsx4(MoreVertical, { size: 16 })
+            }
+          ),
+          /* @__PURE__ */ jsxs2(
+            Menu,
+            {
+              anchorEl,
+              open: Boolean(anchorEl),
+              onClose: handleMenuClose,
+              onClick: (e) => e.stopPropagation(),
+              transformOrigin: {
+                vertical: "top",
+                horizontal: "right"
+              },
+              anchorOrigin: {
+                vertical: "top",
+                horizontal: "right"
+              },
+              PaperProps: {
+                sx: {
+                  // Larger menu items on mobile for easier touch
+                  ...isMobile && {
+                    "& .MuiMenuItem-root": {
+                      minHeight: 48,
+                      fontSize: "1rem"
+                    }
+                  }
+                }
+              },
+              children: [
+                onRename && /* @__PURE__ */ jsxs2(MenuItem, { onClick: handleEdit, children: [
+                  /* @__PURE__ */ jsx4(ListItemIcon2, { children: /* @__PURE__ */ jsx4(Edit, { size: 16 }) }),
+                  /* @__PURE__ */ jsx4(ListItemText2, { children: "Rename" })
+                ] }),
+                onMove && /* @__PURE__ */ jsxs2(MenuItem, { onClick: handleMove, children: [
+                  /* @__PURE__ */ jsx4(ListItemIcon2, { children: /* @__PURE__ */ jsx4(MailOpen, { size: 16 }) }),
+                  /* @__PURE__ */ jsx4(ListItemText2, { children: "Move to Project" })
+                ] }),
+                /* @__PURE__ */ jsxs2(MenuItem, { onClick: handleDelete, children: [
+                  /* @__PURE__ */ jsx4(ListItemIcon2, { children: /* @__PURE__ */ jsx4(Trash, { size: 16 }) }),
+                  /* @__PURE__ */ jsx4(ListItemText2, { children: "Delete" })
+                ] })
+              ]
+            }
+          )
+        ]
+      }
+    ),
+    isMobile && /* @__PURE__ */ jsxs2(
+      Dialog2,
+      {
+        open: showRenameDialog,
+        onClose: () => {
+          setShowRenameDialog(false);
+          setEditName(conversation.name);
+        },
+        fullWidth: true,
+        PaperProps: {
+          sx: {
+            borderRadius: 3,
+            pb: 1
+          }
+        },
+        children: [
+          /* @__PURE__ */ jsx4(DialogTitle2, { sx: { pb: 1 }, children: "Rename Conversation" }),
+          /* @__PURE__ */ jsx4(DialogContent2, { children: /* @__PURE__ */ jsx4(
+            TextField,
+            {
+              value: editName,
+              onChange: (e) => setEditName(e.target.value),
+              autoFocus: true,
+              fullWidth: true,
+              placeholder: "Enter a new name",
+              InputProps: {
+                sx: { fontSize: "1rem" }
+              }
+            }
+          ) }),
+          /* @__PURE__ */ jsxs2(DialogActions2, { sx: { px: 3, pb: 2 }, children: [
+            /* @__PURE__ */ jsx4(
+              Button2,
+              {
+                onClick: () => {
+                  setShowRenameDialog(false);
+                  setEditName(conversation.name);
+                },
+                children: "Cancel"
+              }
+            ),
+            /* @__PURE__ */ jsx4(
+              Button2,
+              {
+                onClick: () => {
+                  commitRename();
+                  setShowRenameDialog(false);
+                },
+                variant: "contained",
+                disabled: !editName.trim() || editName.trim() === conversation.name,
+                children: "Save"
+              }
+            )
+          ] })
+        ]
+      }
+    )
+  ] });
+};
+var simple_conversation_item_default = SimpleConversationItem;
+
+// src/chat/sidebar/ProjectDialog.tsx
+import { useEffect as useEffect4, useState as useState4 } from "react";
+import {
+  Box as Box4,
+  Button as Button3,
+  Dialog as Dialog3,
+  DialogActions as DialogActions3,
+  DialogContent as DialogContent3,
+  DialogTitle as DialogTitle3,
+  TextField as TextField2,
+  alpha as alpha3
+} from "@mui/material";
+import { useTheme as useTheme3 } from "@mui/material/styles";
+import { jsx as jsx5, jsxs as jsxs3 } from "react/jsx-runtime";
+var ProjectDialog = ({
+  open,
+  onClose,
+  project,
+  onCreated
+}) => {
+  const theme = useTheme3();
+  const { createProject, renameProject, updateProjectColor, projects } = useProjectStore();
+  const [name, setName] = useState4("");
+  const [color, setColor] = useState4(PROJECT_COLORS[0]);
+  const [saving, setSaving] = useState4(false);
+  const [error, setError] = useState4(null);
+  useEffect4(() => {
+    if (!open) return;
+    setName(project?.name ?? "");
+    setColor(project?.color ?? PROJECT_COLORS[projects.length % PROJECT_COLORS.length]);
+    setError(null);
+  }, [open, project, projects.length]);
+  const trimmed = name.trim();
+  const canSave = trimmed.length > 0 && !saving;
+  const save = async () => {
+    if (!canSave) return;
+    setSaving(true);
+    setError(null);
+    try {
+      if (project) {
+        if (trimmed !== project.name)
+          await renameProject(project.id, trimmed, project.description);
+        if (color !== project.color) await updateProjectColor(project.id, color);
+      } else {
+        const created = await createProject(trimmed, void 0, color);
+        onCreated?.(created);
+      }
+      onClose();
+    } catch (cause) {
+      debugLogger.error("Saving the project failed", {
+        error: cause instanceof Error ? cause.message : String(cause)
+      });
+      setError("The project could not be saved. Try again.");
+    } finally {
+      setSaving(false);
+    }
+  };
+  return /* @__PURE__ */ jsxs3(Dialog3, { open, onClose, maxWidth: "xs", fullWidth: true, children: [
+    /* @__PURE__ */ jsx5(DialogTitle3, { children: project ? "Edit project" : "New project" }),
+    /* @__PURE__ */ jsxs3(DialogContent3, { sx: { display: "flex", flexDirection: "column", gap: 2 }, children: [
+      /* @__PURE__ */ jsx5(
+        TextField2,
+        {
+          autoFocus: true,
+          label: "Name",
+          value: name,
+          onChange: (event) => setName(event.target.value),
+          onKeyDown: (event) => {
+            if (event.key === "Enter") {
+              event.preventDefault();
+              void save();
+            }
+          },
+          error: Boolean(error),
+          helperText: error ?? " ",
+          fullWidth: true,
+          size: "small",
+          inputProps: { maxLength: 80 }
+        }
+      ),
+      /* @__PURE__ */ jsx5(
+        Box4,
+        {
+          role: "radiogroup",
+          "aria-label": "Colour",
+          sx: { display: "flex", gap: 1, flexWrap: "wrap" },
+          children: PROJECT_COLORS.map((swatch) => {
+            const selected = swatch === color;
+            return /* @__PURE__ */ jsx5(
+              Box4,
+              {
+                component: "button",
+                type: "button",
+                role: "radio",
+                "aria-checked": selected,
+                "aria-label": `Colour ${swatch}`,
+                onClick: () => setColor(swatch),
+                sx: {
+                  width: 28,
+                  height: 28,
+                  p: 0,
+                  borderRadius: "50%",
+                  border: `2px solid ${selected ? theme.palette.text.primary : "transparent"}`,
+                  bgcolor: swatch,
+                  cursor: "pointer",
+                  display: "grid",
+                  placeItems: "center",
+                  color: theme.palette.getContrastText(swatch),
+                  "&:focus-visible": {
+                    outline: `2px solid ${theme.palette.primary.main}`,
+                    outlineOffset: "2px"
+                  },
+                  "&:hover": { boxShadow: `0 0 0 3px ${alpha3(swatch, 0.35)}` }
+                },
+                children: selected && /* @__PURE__ */ jsx5(Check, { size: 14, "aria-hidden": true })
+              },
+              swatch
+            );
+          })
+        }
+      )
+    ] }),
+    /* @__PURE__ */ jsxs3(DialogActions3, { children: [
+      /* @__PURE__ */ jsx5(Button3, { onClick: onClose, children: "Cancel" }),
+      /* @__PURE__ */ jsx5(Button3, { variant: "contained", onClick: () => void save(), disabled: !canSave, children: project ? "Save" : "Create" })
+    ] })
+  ] });
+};
+
+// src/chat/sidebar/recents.ts
+var BUCKET_LABELS = {
+  today: "Today",
+  week: "Previous 7 days",
+  older: "Older"
+};
+var DAY_MS = 24 * 60 * 60 * 1e3;
+var asTime = (value) => {
+  if (!value) return 0;
+  const time = value instanceof Date ? value.getTime() : new Date(value).getTime();
+  return Number.isNaN(time) ? 0 : time;
+};
+var lastActivity = (conversation) => asTime(conversation.updatedAt) || asTime(conversation.createdAt);
+var startOfDay = (now) => {
+  const date = new Date(now);
+  date.setHours(0, 0, 0, 0);
+  return date.getTime();
+};
+function groupByRecency(conversations, now = Date.now()) {
+  const today = startOfDay(now);
+  const weekAgo = today - 7 * DAY_MS;
+  const sorted = [...conversations].sort((a, b) => lastActivity(b) - lastActivity(a));
+  const buckets = { today: [], week: [], older: [] };
+  for (const conversation of sorted) {
+    const time = lastActivity(conversation);
+    if (time >= today) buckets.today.push(conversation);
+    else if (time >= weekAgo) buckets.week.push(conversation);
+    else buckets.older.push(conversation);
+  }
+  return ["today", "week", "older"].filter((id) => buckets[id].length > 0).map((id) => ({ id, label: BUCKET_LABELS[id], items: buckets[id] }));
+}
+var buildSnippet = (text, query, index) => {
+  const start = Math.max(0, index - 40);
+  const end = Math.min(text.length, index + query.length + 60);
+  return text.slice(start, end).replace(/\s+/g, " ").trim();
+};
+function searchConversations(conversations, query) {
+  const needle = query.trim().toLowerCase();
+  if (!needle) return [];
+  const matches = [];
+  for (const conversation of conversations) {
+    if (conversation.name.toLowerCase().includes(needle)) {
+      matches.push({ conversation });
+      continue;
+    }
+    for (const entry of conversation.history) {
+      const body = `${entry.question || ""} ${entry.answer || ""}`;
+      const index = body.toLowerCase().indexOf(needle);
+      if (index !== -1) {
+        matches.push({ conversation, snippet: buildSnippet(body, needle, index) });
+        break;
+      }
+    }
+  }
+  return matches;
+}
+var listable = (conversations) => conversations.filter((conversation) => !conversation.incognito);
+function formatRelative(time, now = Date.now()) {
+  if (!time) return "";
+  const diff = Math.max(0, now - time);
+  const minute = 60 * 1e3;
+  const hour = 60 * minute;
+  if (diff < minute) return "just now";
+  if (diff < hour) return `${Math.floor(diff / minute)} min ago`;
+  if (diff < DAY_MS) return `${Math.floor(diff / hour)} h ago`;
+  const days = Math.floor((startOfDay(now) - startOfDay(time)) / DAY_MS);
+  if (days <= 1) return "yesterday";
+  if (days < 7) return `${days} days ago`;
+  const date = new Date(time);
+  const sameYear = date.getFullYear() === new Date(now).getFullYear();
+  return date.toLocaleDateString(void 0, {
+    month: "short",
+    day: "numeric",
+    ...sameYear ? {} : { year: "numeric" }
+  });
+}
+
+// src/chat/sidebar/SidebarProjects.tsx
+import { useMemo } from "react";
+import { Box as Box6, IconButton as IconButton3, Tooltip, Typography as Typography4 } from "@mui/material";
+import { useTheme as useTheme5 } from "@mui/material/styles";
+
+// src/chat/sidebar/SectionRow.tsx
+import { forwardRef } from "react";
+import { Box as Box5, ButtonBase, Typography as Typography3, alpha as alpha4 } from "@mui/material";
+import { useTheme as useTheme4 } from "@mui/material/styles";
+import { jsx as jsx6, jsxs as jsxs4 } from "react/jsx-runtime";
+var IS_MAC = typeof navigator !== "undefined" && /Mac|iPhone|iPad/.test(navigator.platform ?? "");
+var shortcutLabel = (combo) => {
+  if (IS_MAC) {
+    return combo.map((key) => key === "mod" ? "\u2318" : key === "shift" ? "\u21E7" : key).join("");
+  }
+  return combo.map((key) => key === "mod" ? "Ctrl" : key === "shift" ? "Shift" : key).join("+");
+};
+var SidebarKbd = ({ children }) => {
+  const theme = useTheme4();
+  return /* @__PURE__ */ jsx6(
+    Box5,
+    {
+      component: "kbd",
+      "aria-hidden": true,
+      sx: {
+        ml: "auto",
+        px: 0.6,
+        py: 0.1,
+        borderRadius: 0.75,
+        border: `1px solid ${alpha4(theme.palette.text.primary, 0.14)}`,
+        color: theme.palette.text.secondary,
+        fontFamily: "inherit",
+        fontSize: "0.68rem",
+        lineHeight: 1.4,
+        whiteSpace: "nowrap",
+        opacity: 0.9
+      },
+      children
+    }
+  );
+};
+var SidebarCaption = ({
+  children,
+  action,
+  component = "h2"
+}) => {
+  const theme = useTheme4();
+  return /* @__PURE__ */ jsxs4(
+    Box5,
+    {
+      sx: {
+        display: "flex",
+        alignItems: "center",
+        gap: 1,
+        px: 2,
+        pt: 1.5,
+        pb: 0.5,
+        minHeight: 32
+      },
+      children: [
+        /* @__PURE__ */ jsx6(
+          Typography3,
+          {
+            component,
+            sx: {
+              m: 0,
+              flex: 1,
+              color: theme.palette.text.secondary,
+              fontSize: "0.7rem",
+              fontWeight: 600,
+              letterSpacing: "0.5px",
+              textTransform: "uppercase",
+              lineHeight: 1.4
+            },
+            children
+          }
+        ),
+        action
+      ]
+    }
+  );
+};
+var SectionRow = forwardRef(function SectionRow2({
+  icon,
+  label,
+  trailing,
+  active = false,
+  href,
+  external,
+  onClick,
+  size = "regular",
+  swatch,
+  ...rest
+}, ref) {
+  const theme = useTheme4();
+  const anchorProps = href ? {
+    component: "a",
+    href,
+    ...external ? { rel: "noopener" } : {}
+  } : { component: "button", type: "button" };
+  return /* @__PURE__ */ jsxs4(
+    ButtonBase,
+    {
+      ref,
+      ...anchorProps,
+      onClick,
+      "aria-current": active ? "page" : void 0,
+      "aria-label": rest["aria-label"],
+      "data-section": rest["data-section"],
+      "data-external": external ? "" : void 0,
+      sx: {
+        width: "calc(100% - 16px)",
+        mx: 1,
+        minHeight: size === "touch" ? 44 : 36,
+        px: 1.25,
+        py: 0.5,
+        display: "flex",
+        alignItems: "center",
+        justifyContent: "flex-start",
+        gap: 1.25,
+        borderRadius: 1,
+        textAlign: "left",
+        textDecoration: "none",
+        font: "inherit",
+        fontSize: "0.875rem",
+        fontWeight: active ? 600 : 500,
+        color: active ? theme.palette.text.primary : theme.palette.text.secondary,
+        bgcolor: active ? alpha4(theme.palette.text.primary, 0.08) : "transparent",
+        transition: theme.transitions.create(["background-color", "color"], {
+          duration: theme.transitions.duration.shorter
+        }),
+        "@media (pointer: coarse)": { minHeight: 44 },
+        "&:hover": {
+          color: theme.palette.text.primary,
+          bgcolor: alpha4(theme.palette.text.primary, active ? 0.1 : 0.04)
+        },
+        "&:focus-visible": {
+          outline: `2px solid ${theme.palette.primary.main}`,
+          outlineOffset: "-2px"
+        },
+        "& svg": { flexShrink: 0 }
+      },
+      children: [
+        swatch ? /* @__PURE__ */ jsx6(
+          Box5,
+          {
+            "aria-hidden": true,
+            sx: {
+              width: 10,
+              height: 10,
+              mx: "4px",
+              borderRadius: "50%",
+              bgcolor: swatch,
+              flexShrink: 0
+            }
+          }
+        ) : icon,
+        /* @__PURE__ */ jsx6(
+          Box5,
+          {
+            component: "span",
+            sx: {
+              flex: 1,
+              minWidth: 0,
+              overflow: "hidden",
+              textOverflow: "ellipsis",
+              whiteSpace: "nowrap"
+            },
+            children: label
+          }
+        ),
+        trailing
+      ]
+    }
+  );
+});
+
+// src/chat/sidebar/SidebarProjects.tsx
+import { jsx as jsx7, jsxs as jsxs5 } from "react/jsx-runtime";
+var SIDEBAR_PROJECT_LIMIT = 6;
+function summarizeProjects(projects, conversations) {
+  return projects.map((project) => {
+    const chats = conversations.filter((c) => c.projectId === project.id);
+    const newest = chats.reduce((max, c) => Math.max(max, lastActivity(c)), 0);
+    return {
+      project,
+      chatCount: chats.length,
+      activeAt: newest || project.updatedAt.getTime()
+    };
+  }).sort((a, b) => b.activeAt - a.activeAt || a.project.order - b.project.order);
+}
+var SidebarProjects = ({
+  activeProjectId,
+  onOpenProject,
+  onAllProjects,
+  onNewProject,
+  size
+}) => {
+  const theme = useTheme5();
+  const projects = useProjectStore((state) => state.projects);
+  const conversations = useConversationStore((state) => state.conversations);
+  const summaries = useMemo(
+    () => summarizeProjects(projects, listable(conversations)),
+    [projects, conversations]
+  );
+  const shown = summaries.slice(0, SIDEBAR_PROJECT_LIMIT);
+  return /* @__PURE__ */ jsxs5(Box6, { component: "section", "aria-labelledby": "bandit-sidebar-projects", children: [
+    /* @__PURE__ */ jsx7(
+      SidebarCaption,
+      {
+        action: /* @__PURE__ */ jsx7(Tooltip, { title: "New project", arrow: true, children: /* @__PURE__ */ jsx7(
+          IconButton3,
+          {
+            size: "small",
+            "aria-label": "New project",
+            onClick: onNewProject,
+            sx: { color: theme.palette.text.secondary, width: 28, height: 28 },
+            children: /* @__PURE__ */ jsx7(Plus, { size: 16 })
+          }
+        ) }),
+        children: /* @__PURE__ */ jsx7("span", { id: "bandit-sidebar-projects", children: "Projects" })
+      }
+    ),
+    shown.length === 0 && /* @__PURE__ */ jsx7(
+      Typography4,
+      {
+        variant: "caption",
+        sx: { display: "block", px: 2.25, pb: 1, color: theme.palette.text.secondary },
+        children: "No projects yet."
+      }
+    ),
+    shown.map(({ project, chatCount }) => /* @__PURE__ */ jsx7(
+      SectionRow,
+      {
+        "data-section": `project:${project.id}`,
+        swatch: project.color || theme.palette.text.disabled,
+        label: project.name,
+        size,
+        active: activeProjectId === project.id,
+        onClick: () => onOpenProject(project.id),
+        trailing: chatCount > 0 ? /* @__PURE__ */ jsx7(
+          Typography4,
+          {
+            component: "span",
+            variant: "caption",
+            "aria-label": `${chatCount} ${chatCount === 1 ? "chat" : "chats"}`,
+            sx: {
+              color: theme.palette.text.disabled,
+              fontVariantNumeric: "tabular-nums"
+            },
+            children: chatCount
+          }
+        ) : null
+      },
+      project.id
+    )),
+    summaries.length > SIDEBAR_PROJECT_LIMIT && /* @__PURE__ */ jsx7(
+      SectionRow,
+      {
+        "data-section": "all-projects",
+        label: `All projects (${summaries.length})`,
+        size,
+        onClick: onAllProjects,
+        icon: /* @__PURE__ */ jsx7(Box6, { "aria-hidden": true, sx: { width: 18 } })
+      }
+    )
+  ] });
+};
+
+// src/chat/sidebar/SidebarSections.tsx
+import { Box as Box7 } from "@mui/material";
+import { jsx as jsx8, jsxs as jsxs6 } from "react/jsx-runtime";
+var NEW_CHAT_SHORTCUT = ["mod", "shift", "O"];
+var SEARCH_SHORTCUT = ["mod", "K"];
+var TOGGLE_SIDEBAR_SHORTCUT = ["mod", "shift", "S"];
+var useNoSections = () => [];
+function useHostSections() {
+  const useSections = usePackageSettingsStore(
+    (state) => state.settings?.navigation?.useSections
+  );
+  return (useSections ?? useNoSections)();
+}
+var isPlainLeftClick = (event) => event.button === 0 && !event.metaKey && !event.ctrlKey && !event.shiftKey && !event.altKey;
+var SidebarSections = ({
+  onNewChat,
+  onSearch,
+  searchOpen,
+  onProjects,
+  projectsActive,
+  showHints = false,
+  size = "regular",
+  onAfterNavigate
+}) => {
+  const hostSections = useHostSections();
+  const safeNavigate = useSafeNavigate();
+  const iconSize = 18;
+  const follow = (section) => (event) => {
+    if (!isPlainLeftClick(event)) return;
+    section.onSelect?.(event);
+    if (event.defaultPrevented) {
+      onAfterNavigate?.();
+      return;
+    }
+    if (section.external) {
+      onAfterNavigate?.();
+      return;
+    }
+    event.preventDefault();
+    safeNavigate(section.href);
+    onAfterNavigate?.();
+  };
+  return /* @__PURE__ */ jsxs6(
+    Box7,
+    {
+      component: "nav",
+      "aria-label": "Chat navigation",
+      sx: { display: "flex", flexDirection: "column", gap: 0.25, pt: 0.5, pb: 1 },
+      children: [
+        /* @__PURE__ */ jsx8(
+          SectionRow,
+          {
+            "data-section": "new-chat",
+            icon: /* @__PURE__ */ jsx8(MessageSquarePlus, { size: iconSize }),
+            label: "New chat",
+            size,
+            onClick: onNewChat,
+            trailing: showHints ? /* @__PURE__ */ jsx8(SidebarKbd, { children: shortcutLabel(NEW_CHAT_SHORTCUT) }) : null
+          }
+        ),
+        /* @__PURE__ */ jsx8(
+          SectionRow,
+          {
+            "data-section": "search",
+            icon: /* @__PURE__ */ jsx8(Search, { size: iconSize }),
+            label: "Search chats",
+            size,
+            active: searchOpen,
+            onClick: onSearch,
+            "aria-label": searchOpen ? "Close search" : "Search chats",
+            trailing: showHints ? /* @__PURE__ */ jsx8(SidebarKbd, { children: shortcutLabel(SEARCH_SHORTCUT) }) : null
+          }
+        ),
+        /* @__PURE__ */ jsx8(
+          SectionRow,
+          {
+            "data-section": "projects",
+            icon: /* @__PURE__ */ jsx8(Folder, { size: iconSize }),
+            label: "Projects",
+            size,
+            active: projectsActive,
+            onClick: onProjects
+          }
+        ),
+        hostSections.map((section) => /* @__PURE__ */ jsx8(
+          SectionRow,
+          {
+            "data-section": section.id,
+            icon: section.icon,
+            label: section.label,
+            size,
+            href: section.href,
+            external: section.external,
+            active: section.active,
+            onClick: follow(section)
+          },
+          section.id
+        ))
+      ]
+    }
+  );
+};
+
+// src/chat/sidebar/SidebarUserCard.tsx
+import { Avatar as Avatar2, Box as Box8, IconButton as IconButton4, Tooltip as Tooltip2, Typography as Typography5, alpha as alpha5 } from "@mui/material";
+import { useTheme as useTheme6 } from "@mui/material/styles";
+
+// src/utils/installedApp.ts
+var isNativeShell = () => {
+  if (typeof window === "undefined") return false;
+  const cap = window.Capacitor;
+  return typeof cap?.isNativePlatform === "function" && cap.isNativePlatform() === true;
+};
+var isStandalonePwa = () => {
+  if (typeof window === "undefined") return false;
+  const nav = window.navigator;
+  return window.matchMedia?.("(display-mode: standalone)").matches || nav.standalone === true;
+};
+
+// src/chat/sidebar/useSidebarUser.ts
+import { useCallback as useCallback2, useEffect as useEffect5, useMemo as useMemo2, useState as useState5 } from "react";
+var BANDIT_AVATAR = "https://cdn.burtson.ai/images/bandit-head.png";
+var optionalString = (value) => {
+  if (typeof value !== "string") return void 0;
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : void 0;
+};
+var deriveInitials = (value) => {
+  const sanitized = (value || "").trim();
+  if (!sanitized) return "B";
+  const words = sanitized.split(/\s+/).filter(Boolean);
+  if (words.length >= 2) {
+    const initials = `${words[0]?.charAt(0) ?? ""}${words[words.length - 1]?.charAt(0) ?? ""}`;
+    return (initials.trim() || sanitized.slice(0, 2)).toUpperCase();
+  }
+  const alphanumeric = sanitized.replace(/[^A-Za-z0-9]/g, "");
+  if (alphanumeric.length >= 1) return alphanumeric.slice(0, 2).toUpperCase();
+  return sanitized.slice(0, 2).toUpperCase();
+};
+function useSidebarUser() {
+  const { user } = useAuthenticationStore();
+  const [avatarSrc, setAvatarSrc] = useState5(BANDIT_AVATAR);
+  const claim = useCallback2(
+    (key) => user ? optionalString(user[key]) : void 0,
+    [user]
+  );
+  const displayName = useMemo2(() => {
+    if (!user) return void 0;
+    const candidates = [
+      optionalString(user.name),
+      optionalString(user.preferred_username),
+      user.given_name && user.family_name ? optionalString(`${user.given_name} ${user.family_name}`) : void 0,
+      claim("full_name"),
+      claim("displayName")
+    ];
+    return candidates.find(Boolean) ?? optionalString(user.email) ?? user.sub;
+  }, [user, claim]);
+  const secondaryText = useMemo2(() => {
+    if (!user) return void 0;
+    const email = optionalString(user.email);
+    if (email && email !== displayName) return email;
+    const sub = optionalString(user.sub);
+    return sub && sub !== displayName ? sub : void 0;
+  }, [user, displayName]);
+  useEffect5(() => {
+    const fresh = readPersistedToken();
+    const store = useAuthenticationStore.getState();
+    if (fresh && fresh !== store.token) store.setToken(fresh);
+  }, []);
+  useEffect5(() => {
+    let active = true;
+    let objectUrl = null;
+    const resolve = async () => {
+      try {
+        const avatarId = claim("avatarUrl");
+        const fileStorageApiUrl = usePackageSettingsStore.getState().settings?.fileStorageApiUrl;
+        const token = useAuthenticationStore.getState().token;
+        if (avatarId && fileStorageApiUrl && token) {
+          const base = fileStorageApiUrl.replace(/\/$/, "");
+          const response = await fetch(
+            `${base}/app-asset/download/${encodeURIComponent(avatarId)}`,
+            { headers: { Authorization: `Bearer ${token}` } }
+          );
+          if (response.ok) {
+            const blob = await response.blob();
+            if (active) {
+              objectUrl = URL.createObjectURL(blob);
+              setAvatarSrc(objectUrl);
+            }
+            return;
+          }
+        }
+      } catch {
+      }
+      try {
+        const branding = await brandingService_default.getBranding();
+        if (active) setAvatarSrc(branding?.logoBase64 || BANDIT_AVATAR);
+      } catch (error) {
+        debugLogger.error("Failed to load branding avatar", {
+          error: error instanceof Error ? error.message : String(error)
+        });
+        if (active) setAvatarSrc(BANDIT_AVATAR);
+      }
+    };
+    void resolve();
+    return () => {
+      active = false;
+      if (objectUrl) URL.revokeObjectURL(objectUrl);
+    };
+  }, [claim]);
+  const label = displayName || user?.email || "Bandit";
+  return {
+    signedIn: Boolean(user),
+    displayName,
+    secondaryText,
+    avatarSrc,
+    initials: deriveInitials(label)
+  };
+}
+
+// src/chat/sidebar/SidebarUserCard.tsx
+import { jsx as jsx9, jsxs as jsxs7 } from "react/jsx-runtime";
+function goHome(safeNavigate, preferencesHomeUrl) {
+  const homeUrl = preferencesHomeUrl?.trim() || usePackageSettingsStore.getState().settings?.homeUrl?.trim() || "";
+  if (homeUrl) {
+    window.location.href = homeUrl;
+    return;
+  }
+  if (isNativeShell()) {
+    safeNavigate("/chat");
+    return;
+  }
+  if (isStandalonePwa()) {
+    try {
+      sessionStorage.setItem("banditPwaStayOnHome", "true");
+    } catch {
+    }
+    window.location.href = "/?mode=home";
+    return;
+  }
+  window.location.href = "/";
+}
+var managementPathFor = (pathname) => pathname.startsWith("/playground") ? "/playground/management" : "/management";
+var SidebarUserCard = ({ safeAreaBottom }) => {
+  const theme = useTheme6();
+  const user = useSidebarUser();
+  const safeNavigate = useSafeNavigate();
+  const { preferences } = usePreferencesStore();
+  const { showLimitedAdminPanel } = useFeatureVisibility();
+  const managementPath = managementPathFor(
+    typeof window === "undefined" ? "/" : window.location.pathname
+  );
+  const roundButton = {
+    flexShrink: 0,
+    width: 32,
+    height: 32,
+    border: `1px solid ${alpha5(theme.palette.divider, 0.8)}`,
+    color: theme.palette.text.secondary,
+    "&:hover": {
+      color: theme.palette.text.primary,
+      bgcolor: alpha5(theme.palette.text.primary, 0.06)
+    },
+    "&:focus-visible": {
+      outline: `2px solid ${theme.palette.primary.main}`,
+      outlineOffset: "2px"
+    }
+  };
+  return /* @__PURE__ */ jsxs7(
+    Box8,
+    {
+      sx: {
+        mt: "auto",
+        px: 1.5,
+        py: 1.25,
+        pb: safeAreaBottom ? `calc(${theme.spacing(1.25)} + env(safe-area-inset-bottom, 0px))` : 1.25,
+        borderTop: `1px solid ${alpha5(theme.palette.divider, 0.6)}`,
+        display: "flex",
+        alignItems: "center",
+        gap: 1
+      },
+      children: [
+        /* @__PURE__ */ jsxs7(
+          Box8,
+          {
+            component: user.signedIn ? "button" : "div",
+            type: user.signedIn ? "button" : void 0,
+            onClick: user.signedIn ? () => safeNavigate("/profile") : void 0,
+            "aria-label": user.signedIn ? "Profile and account" : void 0,
+            sx: {
+              flex: 1,
+              minWidth: 0,
+              display: "flex",
+              alignItems: "center",
+              gap: 1.25,
+              p: 0.5,
+              m: -0.5,
+              border: 0,
+              borderRadius: 1,
+              bgcolor: "transparent",
+              color: "inherit",
+              font: "inherit",
+              textAlign: "left",
+              cursor: user.signedIn ? "pointer" : "default",
+              "&:hover": user.signedIn ? { bgcolor: alpha5(theme.palette.text.primary, 0.04) } : void 0,
+              "&:focus-visible": {
+                outline: `2px solid ${theme.palette.primary.main}`,
+                outlineOffset: "-2px"
+              }
+            },
+            children: [
+              /* @__PURE__ */ jsx9(
+                Avatar2,
+                {
+                  src: user.avatarSrc,
+                  alt: "",
+                  sx: {
+                    width: 34,
+                    height: 34,
+                    fontSize: "0.9rem",
+                    bgcolor: alpha5(theme.palette.primary.main, 0.12),
+                    color: theme.palette.primary.main
+                  },
+                  children: user.initials
+                }
+              ),
+              /* @__PURE__ */ jsxs7(Box8, { sx: { minWidth: 0, display: "flex", flexDirection: "column" }, children: [
+                /* @__PURE__ */ jsx9(
+                  Typography5,
+                  {
+                    variant: "subtitle2",
+                    noWrap: true,
+                    sx: { fontWeight: 600, lineHeight: 1.3 },
+                    children: user.signedIn ? user.displayName : "Not signed in"
+                  }
+                ),
+                /* @__PURE__ */ jsx9(
+                  Typography5,
+                  {
+                    variant: "caption",
+                    noWrap: true,
+                    sx: { color: theme.palette.text.secondary, lineHeight: 1.3 },
+                    children: user.signedIn ? user.secondaryText || "Profile and account" : "Sign in to sync chats"
+                  }
+                )
+              ] })
+            ]
+          }
+        ),
+        /* @__PURE__ */ jsx9(Tooltip2, { title: "Home", arrow: true, children: /* @__PURE__ */ jsx9(
+          IconButton4,
+          {
+            "aria-label": "Home",
+            onClick: () => goHome(safeNavigate, preferences.homeUrl),
+            sx: roundButton,
+            children: /* @__PURE__ */ jsx9(Home, { size: 16 })
+          }
+        ) }),
+        user.signedIn && showLimitedAdminPanel() && /* @__PURE__ */ jsx9(Tooltip2, { title: "Settings", arrow: true, children: /* @__PURE__ */ jsx9(
+          IconButton4,
+          {
+            "aria-label": "Settings",
+            onClick: () => safeNavigate(managementPath),
+            sx: roundButton,
+            children: /* @__PURE__ */ jsx9(Settings, { size: 16 })
+          }
+        ) }),
+        user.signedIn && /* @__PURE__ */ jsx9(Tooltip2, { title: "Sign out", arrow: true, children: /* @__PURE__ */ jsx9(
+          IconButton4,
+          {
+            "aria-label": "Sign out",
+            onClick: () => {
+              authenticationService.clearToken();
+              window.location.href = "/login";
+            },
+            sx: {
+              ...roundButton,
+              border: `1px solid ${alpha5(theme.palette.error.main, 0.4)}`,
+              color: theme.palette.error.main,
+              "&:hover": { bgcolor: alpha5(theme.palette.error.main, 0.1) }
+            },
+            children: /* @__PURE__ */ jsx9(LogOut, { size: 16 })
+          }
+        ) })
+      ]
+    }
+  );
+};
+
+export {
+  newId,
+  useAIQueryStore,
+  CONVERSATION_UPSERT_EVENT,
+  CONVERSATION_DELETE_EVENT,
+  PROJECT_UPSERT_EVENT,
+  PROJECT_DELETE_EVENT,
+  sanitizeConversationName,
+  useConversationStore,
+  useProjectStore,
+  DEFAULT_TIER_FEATURES,
+  OSS_DEFAULT_FEATURES,
+  FeatureFlagContext,
+  FeatureFlagProvider,
+  useFeatureFlag,
+  useFeatures,
+  useFeatureVisibility,
+  brandingService_default,
+  light,
+  dark,
+  radius,
+  shadow,
+  fontSans,
+  fontMono,
+  duration,
+  easing,
+  mix,
+  contrast,
+  accentTokens,
+  chatTokens,
+  fileIconFor,
+  monoFont,
+  fileExtensionLabel,
+  ComposerControl,
+  appBarTokens,
+  responseTokens,
+  isNativeShell,
+  isStandalonePwa,
+  useSafeNavigate,
+  move_conversation_modal_default,
+  simple_conversation_item_default,
+  ProjectDialog,
+  lastActivity,
+  groupByRecency,
+  searchConversations,
+  listable,
+  formatRelative,
+  shortcutLabel,
+  SidebarCaption,
+  summarizeProjects,
+  SidebarProjects,
+  TOGGLE_SIDEBAR_SHORTCUT,
+  useHostSections,
+  SidebarSections,
+  SIDEBAR_WIDTH,
+  writePersistedCollapsed,
+  initialSidebarOpen,
+  useSidebarStore,
+  syncViewWithUrl,
+  useSectionsLayout,
+  managementPathFor,
+  SidebarUserCard
+};
+//# sourceMappingURL=chunk-SQJ4OKWM.mjs.map