@hoox-sh/hoox-shared 1.2.0

package/dist/stores/service-store.js

@@ -0,0 +1,516 @@
+// @bun
+var __defProp = Object.defineProperty;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+
+// src/operator-transport.ts
+function stripTrailingSlashes(url) {
+  return url.replace(/\/+$/, "");
+}
+function parseTransport(raw) {
+  if (!raw)
+    return null;
+  const v = raw.trim().toLowerCase();
+  if (VALID_TRANSPORTS.has(v)) {
+    return v;
+  }
+  return null;
+}
+function resolveOperatorTransportProfile(env = process.env, options = {}) {
+  const accessClientId = env.CF_ACCESS_CLIENT_ID?.trim() ?? "";
+  const accessClientSecret = env.CF_ACCESS_CLIENT_SECRET?.trim() ?? "";
+  const hasAccess = Boolean(accessClientId && accessClientSecret);
+  const explicit = parseTransport(env.HOOX_TRANSPORT) ?? parseTransport(options.configTransport);
+  const transport = explicit ?? (hasAccess ? "access" : "public");
+  const apiFromEnv = env.HOOX_API_URL?.trim();
+  const apiFromConfig = options.configApiUrl?.trim();
+  const tokenFromEnv = env.HOOX_API_TOKEN?.trim();
+  const tokenFromConfig = options.configApiToken?.trim();
+  return {
+    transport,
+    apiBase: stripTrailingSlashes(apiFromEnv || apiFromConfig || DEFAULT_API_BASE),
+    bearerToken: tokenFromEnv || tokenFromConfig || "",
+    accessClientId,
+    accessClientSecret
+  };
+}
+function buildOperatorAuthHeaders(profile) {
+  const headers = {};
+  if (profile.bearerToken) {
+    headers.Authorization = `Bearer ${profile.bearerToken}`;
+  }
+  const useAccessHeaders = profile.transport === "access" || Boolean(profile.accessClientId) && Boolean(profile.accessClientSecret);
+  if (useAccessHeaders && profile.accessClientId && profile.accessClientSecret) {
+    headers["CF-Access-Client-Id"] = profile.accessClientId;
+    headers["CF-Access-Client-Secret"] = profile.accessClientSecret;
+  }
+  return headers;
+}
+function hasOperatorClientCredentials(profile) {
+  if (profile.bearerToken)
+    return true;
+  return Boolean(profile.accessClientId && profile.accessClientSecret);
+}
+function operatorUrl(profile, path) {
+  const base = profile.apiBase.replace(/\/+$/, "");
+  const p = path.startsWith("/") ? path : `/${path}`;
+  return `${base}${p}`;
+}
+var DEFAULT_API_BASE = "http://localhost:8787", VALID_TRANSPORTS;
+var init_operator_transport = __esm(() => {
+  VALID_TRANSPORTS = new Set([
+    "public",
+    "access",
+    "mtls",
+    "tunnel"
+  ]);
+});
+
+// src/api-client.ts
+var exports_api_client = {};
+__export(exports_api_client, {
+  hooxFetch: () => hooxFetch,
+  WorkerAPIError: () => WorkerAPIError
+});
+function isRetryableStatus(status) {
+  if (status === 401 || status === 403 || status === 429)
+    return false;
+  if (status >= 500)
+    return true;
+  if (status === 408)
+    return true;
+  return false;
+}
+function isNetworkError(error) {
+  if (error instanceof Error) {
+    const msg = error.message.toLowerCase();
+    return error.name === "AbortError" || error.name === "TimeoutError" || msg.includes("fetch") || msg.includes("network") || msg.includes("econnrefused") || msg.includes("enotfound") || msg.includes("dns") || msg.includes("timeout");
+  }
+  return false;
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function activeProfile(override) {
+  return override ?? resolveOperatorTransportProfile();
+}
+async function hooxFetch(path, options) {
+  const profile = options?.transport ?? (options?.transportEnv ? resolveOperatorTransportProfile(options.transportEnv) : activeProfile());
+  const { transport: _t, transportEnv: _e, ...fetchInit } = options ?? {};
+  let lastError;
+  for (let attempt = 0;attempt <= MAX_RETRIES; attempt++) {
+    const controller = new AbortController;
+    const timeoutId = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
+    try {
+      const url = operatorUrl(profile, path);
+      const headers = {
+        "Content-Type": "application/json",
+        ...buildOperatorAuthHeaders(profile),
+        ...fetchInit.headers
+      };
+      const response = await fetch(url, {
+        ...fetchInit,
+        headers,
+        signal: controller.signal
+      });
+      if (response.status === 429) {
+        throw new WorkerAPIError("API rate limited \u2014 backing off", {
+          status: 429,
+          retryable: false
+        });
+      }
+      if (response.status === 401 || response.status === 403) {
+        throw new WorkerAPIError(`Authentication failed (HTTP ${response.status})`, { status: response.status, retryable: false });
+      }
+      if (!response.ok) {
+        if (attempt < MAX_RETRIES && isRetryableStatus(response.status)) {
+          const delay = Math.min(BASE_RETRY_DELAY_MS * Math.pow(2, attempt), MAX_RETRY_DELAY_MS);
+          await sleep(delay);
+          continue;
+        }
+        throw new WorkerAPIError(`HTTP ${response.status}: ${response.statusText}`, {
+          status: response.status,
+          retryable: isRetryableStatus(response.status)
+        });
+      }
+      return await response.json();
+    } catch (error) {
+      lastError = error;
+      if (error instanceof WorkerAPIError && !error.retryable) {
+        throw error;
+      }
+      if (attempt < MAX_RETRIES && isNetworkError(error)) {
+        const delay = Math.min(BASE_RETRY_DELAY_MS * Math.pow(2, attempt), MAX_RETRY_DELAY_MS);
+        await sleep(delay);
+        continue;
+      }
+      if (!(error instanceof WorkerAPIError)) {
+        throw new WorkerAPIError(`Network request failed: ${error.message}`, { cause: error, retryable: false, status: 0 });
+      }
+      throw error;
+    } finally {
+      clearTimeout(timeoutId);
+    }
+  }
+  throw new WorkerAPIError("Max retries exhausted", {
+    cause: lastError,
+    retryable: false
+  });
+}
+var FETCH_TIMEOUT_MS = 5000, MAX_RETRIES = 3, BASE_RETRY_DELAY_MS = 1000, MAX_RETRY_DELAY_MS = 16000, WorkerAPIError;
+var init_api_client = __esm(() => {
+  init_operator_transport();
+  WorkerAPIError = class WorkerAPIError extends Error {
+    status;
+    retryable;
+    constructor(message, options) {
+      super(message, { cause: options?.cause });
+      this.name = "WorkerAPIError";
+      this.status = options?.status ?? 0;
+      this.retryable = options?.retryable ?? false;
+    }
+  };
+});
+
+// src/sse.ts
+var exports_sse = {};
+__export(exports_sse, {
+  subscribeSSE: () => subscribeSSE
+});
+function subscribeSSE(path, callback, onStatus, options) {
+  let aborted = false;
+  const profile = options?.transport ?? (options?.transportEnv ? resolveOperatorTransportProfile(options.transportEnv) : resolveOperatorTransportProfile());
+  const run = async () => {
+    let attempt = 0;
+    while (!aborted && attempt < MAX_RECONNECT_ATTEMPTS) {
+      try {
+        const url = operatorUrl(profile, path);
+        const response = await fetch(url, {
+          headers: {
+            Accept: "text/event-stream",
+            ...buildOperatorAuthHeaders(profile)
+          }
+        });
+        if (!response.ok || !response.body) {
+          throw new Error(`SSE connection failed: HTTP ${response.status}`);
+        }
+        attempt = 0;
+        onStatus?.("connected");
+        const reader = response.body.getReader();
+        const decoder = new TextDecoder;
+        let buffer = "";
+        while (!aborted) {
+          const { done, value } = await reader.read();
+          if (done)
+            break;
+          buffer += decoder.decode(value, { stream: true });
+          const lines = buffer.split(`
+`);
+          buffer = lines.pop() || "";
+          for (const line of lines) {
+            const trimmed = line.trim();
+            if (trimmed.startsWith("data: ")) {
+              try {
+                const parsed = JSON.parse(trimmed.slice(6));
+                callback(parsed);
+              } catch {}
+            }
+          }
+        }
+      } catch {
+        if (aborted)
+          break;
+        onStatus?.("reconnecting");
+        const delay = Math.min(RECONNECT_BASE_MS * Math.pow(2, attempt), RECONNECT_MAX_MS);
+        attempt++;
+        await new Promise((resolve) => setTimeout(resolve, delay));
+      }
+    }
+    if (!aborted) {
+      onStatus?.("disconnected");
+    }
+  };
+  run();
+  return {
+    abort: () => {
+      aborted = true;
+    }
+  };
+}
+var RECONNECT_BASE_MS = 1000, RECONNECT_MAX_MS = 16000, MAX_RECONNECT_ATTEMPTS = 10;
+var init_sse = __esm(() => {
+  init_operator_transport();
+});
+
+// src/stores/service-store.ts
+import { create } from "zustand";
+import { immer } from "zustand/middleware/immer";
+function summarizeCliError(details) {
+  const raw = details.stderr.trim() || details.stdout.trim() || details.command || "Unknown CLI error";
+  const firstLine = raw.split(`
+`, 1)[0] ?? "";
+  const trimmed = firstLine.slice(0, 120).trimEnd();
+  return trimmed.length > 0 ? trimmed : details.command;
+}
+var BACKOFF_SEQUENCE = [1000, 2000, 4000, 8000, 16000];
+var MAX_RETRIES2 = 5;
+function ringPush(arr, item, max) {
+  const next = [...arr, item];
+  return next.length > max ? next.slice(next.length - max) : next;
+}
+var tradeStreamAbort = null;
+var logStreamAbort = null;
+var fetchWorkersGeneration = 0;
+var MAX_TRADES = 500;
+var MAX_ALERTS = 100;
+var MAX_LOGS = 1000;
+var initialState = {
+  workers: [],
+  tradeStream: [],
+  alerts: [],
+  logs: [],
+  metrics: null,
+  connectionStatus: "offline",
+  lastUpdated: 0,
+  selectedWorkerId: null,
+  retryCount: 0,
+  lastError: null,
+  lastErrorDetails: null,
+  lastSuccessfulFetch: 0,
+  reconnectDelay: 0,
+  disconnectedAt: null
+};
+function getBackoffDelay(retryCount) {
+  if (retryCount <= 0)
+    return 0;
+  const index = Math.min(retryCount - 1, BACKOFF_SEQUENCE.length - 1);
+  return BACKOFF_SEQUENCE[index];
+}
+var useServiceStore = create()(immer((set, get) => ({
+  ...initialState,
+  fetchWorkers: async () => {
+    const gen = ++fetchWorkersGeneration;
+    const { hooxFetch: hooxFetch2 } = await Promise.resolve().then(() => (init_api_client(), exports_api_client));
+    try {
+      const data = await hooxFetch2("/v1/workers");
+      if (gen !== fetchWorkersGeneration)
+        return;
+      set((state) => {
+        state.workers = data;
+        state.lastUpdated = Date.now();
+        state.lastSuccessfulFetch = Date.now();
+        if (state.connectionStatus === "polling" || state.connectionStatus === "reconnecting" || state.connectionStatus === "offline") {
+          state.connectionStatus = "connected";
+          state.retryCount = 0;
+          state.lastError = null;
+          state.lastErrorDetails = null;
+          state.reconnectDelay = 0;
+          state.disconnectedAt = null;
+        }
+      });
+    } catch (error) {
+      if (gen !== fetchWorkersGeneration)
+        return;
+      const msg = error instanceof Error ? error.message : "Unknown fetch error";
+      get().addAlert({
+        id: crypto.randomUUID(),
+        type: "connection",
+        severity: "error",
+        message: msg,
+        timestamp: Date.now(),
+        acknowledged: false
+      });
+      set((state) => {
+        state.lastError = msg;
+        state.disconnectedAt = state.disconnectedAt ?? Date.now();
+        if (state.connectionStatus === "connected" || state.connectionStatus === "polling") {
+          state.connectionStatus = "reconnecting";
+          state.retryCount = state.retryCount + 1;
+          if (state.retryCount >= MAX_RETRIES2) {
+            state.connectionStatus = "offline";
+            state.lastError = `Connection lost after ${MAX_RETRIES2} retries`;
+          } else {
+            state.reconnectDelay = getBackoffDelay(state.retryCount);
+          }
+        } else if (state.connectionStatus === "reconnecting") {
+          state.retryCount = state.retryCount + 1;
+          if (state.retryCount >= MAX_RETRIES2) {
+            state.connectionStatus = "offline";
+            state.lastError = `Connection lost after ${MAX_RETRIES2} retries`;
+            state.reconnectDelay = 0;
+          } else {
+            state.reconnectDelay = getBackoffDelay(state.retryCount);
+          }
+        }
+      });
+    }
+  },
+  streamTrades: async () => {
+    const { subscribeSSE: subscribeSSE2 } = await Promise.resolve().then(() => (init_sse(), exports_sse));
+    tradeStreamAbort?.();
+    tradeStreamAbort = null;
+    try {
+      const sub = subscribeSSE2("/v1/trades/stream", (trade) => {
+        get().pushTrade(trade);
+      });
+      const resolved = await Promise.resolve(sub);
+      tradeStreamAbort = resolved.abort.bind(resolved);
+    } catch (error) {
+      const msg = error instanceof Error ? error.message : "SSE trade stream failed";
+      get().addAlert({
+        id: crypto.randomUUID(),
+        type: "connection",
+        severity: "error",
+        message: msg,
+        timestamp: Date.now(),
+        acknowledged: false
+      });
+      get().handleConnectionFailure(msg);
+    }
+  },
+  streamLogs: async () => {
+    const { subscribeSSE: subscribeSSE2 } = await Promise.resolve().then(() => (init_sse(), exports_sse));
+    logStreamAbort?.();
+    logStreamAbort = null;
+    try {
+      const sub = subscribeSSE2("/v1/logs/stream", (log) => {
+        get().pushLog(log);
+      });
+      const resolved = await Promise.resolve(sub);
+      logStreamAbort = resolved.abort.bind(resolved);
+    } catch (error) {
+      const msg = error instanceof Error ? error.message : "SSE log stream failed";
+      get().addAlert({
+        id: crypto.randomUUID(),
+        type: "connection",
+        severity: "error",
+        message: msg,
+        timestamp: Date.now(),
+        acknowledged: false
+      });
+      get().handleConnectionFailure(msg);
+    }
+  },
+  stopStreams: () => {
+    tradeStreamAbort?.();
+    logStreamAbort?.();
+    tradeStreamAbort = null;
+    logStreamAbort = null;
+  },
+  addAlert: (alert) => set((state) => {
+    state.alerts = ringPush(state.alerts, alert, MAX_ALERTS);
+  }),
+  addAlerts: (alerts) => set((state) => {
+    const merged = [...state.alerts, ...alerts];
+    state.alerts = merged.length > MAX_ALERTS ? merged.slice(merged.length - MAX_ALERTS) : merged;
+  }),
+  setConnectionStatus: (status) => set((state) => {
+    if (status === "connected") {
+      state.retryCount = 0;
+      state.lastError = null;
+      state.lastErrorDetails = null;
+      state.reconnectDelay = 0;
+      state.disconnectedAt = null;
+    }
+    if (status === "offline" || status === "reconnecting") {
+      state.disconnectedAt = state.disconnectedAt ?? Date.now();
+    }
+    state.connectionStatus = status;
+  }),
+  selectWorker: (id) => set((state) => {
+    state.selectedWorkerId = id;
+  }),
+  setWorkers: (workers) => set((state) => {
+    state.workers = workers;
+    state.lastUpdated = Date.now();
+  }),
+  pushTrade: (trade) => set((state) => {
+    state.tradeStream = ringPush(state.tradeStream, trade, MAX_TRADES);
+  }),
+  pushLog: (log) => set((state) => {
+    state.logs = ringPush(state.logs, log, MAX_LOGS);
+  }),
+  setMetrics: (metrics) => set((state) => {
+    state.metrics = metrics;
+    state.lastUpdated = metrics.lastUpdated;
+  }),
+  handleConnectionSuccess: () => set((state) => {
+    state.lastSuccessfulFetch = Date.now();
+    state.retryCount = 0;
+    state.lastError = null;
+    state.lastErrorDetails = null;
+    state.reconnectDelay = 0;
+    state.disconnectedAt = null;
+    state.connectionStatus = "connected";
+  }),
+  handleConnectionFailure: (errorMessage) => set((state) => {
+    state.lastError = errorMessage;
+    state.disconnectedAt = state.disconnectedAt ?? Date.now();
+    if (state.connectionStatus === "connected" || state.connectionStatus === "polling") {
+      state.connectionStatus = "reconnecting";
+      state.retryCount = 1;
+      state.reconnectDelay = getBackoffDelay(1);
+    } else if (state.connectionStatus === "reconnecting") {
+      state.retryCount = state.retryCount + 1;
+      if (state.retryCount >= MAX_RETRIES2) {
+        state.connectionStatus = "offline";
+        state.lastError = `Connection lost after ${MAX_RETRIES2} retries`;
+        state.reconnectDelay = 0;
+      } else {
+        state.reconnectDelay = getBackoffDelay(state.retryCount);
+      }
+    }
+  }),
+  resetRetries: () => set((state) => {
+    state.retryCount = 0;
+    state.lastError = null;
+    state.lastErrorDetails = null;
+    state.reconnectDelay = 0;
+    state.disconnectedAt = null;
+  }),
+  forceRetry: () => set((state) => {
+    if (state.connectionStatus === "offline") {
+      state.connectionStatus = "polling";
+      state.retryCount = 0;
+      state.lastError = null;
+      state.lastErrorDetails = null;
+      state.reconnectDelay = 0;
+    }
+  }),
+  setLastErrorDetails: (details) => set((state) => {
+    state.lastErrorDetails = details;
+    state.lastError = details === null ? null : summarizeCliError(details);
+  }),
+  clearError: () => set((state) => {
+    state.lastError = null;
+    state.lastErrorDetails = null;
+  }),
+  addCliErrorAlert: (details) => set((state) => {
+    state.lastErrorDetails = details;
+    state.lastError = summarizeCliError(details);
+    const summary = summarizeCliError(details);
+    state.alerts = ringPush(state.alerts, {
+      id: crypto.randomUUID(),
+      type: "connection",
+      severity: "error",
+      message: `CLI failure: ${summary}`,
+      timestamp: Date.now(),
+      acknowledged: false
+    }, MAX_ALERTS);
+  })
+})));
+export {
+  useServiceStore
+};

package/dist/stores/ui-store.d.ts

@@ -0,0 +1,67 @@
+/**
+ * Copyright (c) 2026 HOOX · HOOX · jango-blockchained (hoox-sh)
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { ViewId, ModalState } from "../types";
+export interface UIState {
+    activeView: ViewId;
+    sidebarExpanded: boolean;
+    modal: ModalState | null;
+    commandPaletteOpen: boolean;
+    previousView: ViewId | null;
+}
+interface UIActions {
+    setView: (view: ViewId) => void;
+    toggleSidebar: () => void;
+    openPalette: () => void;
+    closePalette: () => void;
+    showModal: (modal: ModalState) => void;
+    dismissModal: () => void;
+    goBack: () => void;
+}
+export declare const useUIStore: import("zustand").UseBoundStore<Omit<import("zustand").StoreApi<UIState & UIActions>, "setState"> & {
+    setState(nextStateOrUpdater: (UIState & UIActions) | Partial<UIState & UIActions> | ((state: {
+        activeView: ViewId;
+        sidebarExpanded: boolean;
+        modal: {
+            type: "confirm" | "alert" | "prompt" | "custom";
+            title: string;
+            message?: string | undefined;
+            data?: unknown;
+            onConfirm?: (() => void) | undefined;
+            onCancel?: (() => void) | undefined;
+        } | null;
+        commandPaletteOpen: boolean;
+        previousView: ViewId | null;
+        setView: (view: ViewId) => void;
+        toggleSidebar: () => void;
+        openPalette: () => void;
+        closePalette: () => void;
+        showModal: (modal: ModalState) => void;
+        dismissModal: () => void;
+        goBack: () => void;
+    }) => void), shouldReplace?: false): void;
+    setState(nextStateOrUpdater: (UIState & UIActions) | ((state: {
+        activeView: ViewId;
+        sidebarExpanded: boolean;
+        modal: {
+            type: "confirm" | "alert" | "prompt" | "custom";
+            title: string;
+            message?: string | undefined;
+            data?: unknown;
+            onConfirm?: (() => void) | undefined;
+            onCancel?: (() => void) | undefined;
+        } | null;
+        commandPaletteOpen: boolean;
+        previousView: ViewId | null;
+        setView: (view: ViewId) => void;
+        toggleSidebar: () => void;
+        openPalette: () => void;
+        closePalette: () => void;
+        showModal: (modal: ModalState) => void;
+        dismissModal: () => void;
+        goBack: () => void;
+    }) => void), shouldReplace: true): void;
+}>;
+export {};
+//# sourceMappingURL=ui-store.d.ts.map

package/dist/stores/ui-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ui-store.d.ts","sourceRoot":"","sources":["../../src/stores/ui-store.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAQH,OAAO,KAAK,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AAInD,MAAM,WAAW,OAAO;IACtB,UAAU,EAAE,MAAM,CAAC;IACnB,eAAe,EAAE,OAAO,CAAC;IACzB,KAAK,EAAE,UAAU,GAAG,IAAI,CAAC;IACzB,kBAAkB,EAAE,OAAO,CAAC;IAC5B,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;CAC7B;AAID,UAAU,SAAS;IACjB,OAAO,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IAChC,aAAa,EAAE,MAAM,IAAI,CAAC;IAC1B,WAAW,EAAE,MAAM,IAAI,CAAC;IACxB,YAAY,EAAE,MAAM,IAAI,CAAC;IACzB,SAAS,EAAE,CAAC,KAAK,EAAE,UAAU,KAAK,IAAI,CAAC;IACvC,YAAY,EAAE,MAAM,IAAI,CAAC;IACzB,MAAM,EAAE,MAAM,IAAI,CAAC;CACpB;AAgBD,eAAO,MAAM,UAAU;;oBAjCT,MAAM;yBACD,OAAO;;;;;;;;;4BAEJ,OAAO;sBACb,MAAM,GAAG,IAAI;iBAMlB,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI;uBAChB,MAAM,IAAI;qBACZ,MAAM,IAAI;sBACT,MAAM,IAAI;mBACb,CAAC,KAAK,EAAE,UAAU,KAAK,IAAI;sBACxB,MAAM,IAAI;gBAChB,MAAM,IAAI;;;oBAhBN,MAAM;yBACD,OAAO;;;;;;;;;4BAEJ,OAAO;sBACb,MAAM,GAAG,IAAI;iBAMlB,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI;uBAChB,MAAM,IAAI;qBACZ,MAAM,IAAI;sBACT,MAAM,IAAI;mBACb,CAAC,KAAK,EAAE,UAAU,KAAK,IAAI;sBACxB,MAAM,IAAI;gBAChB,MAAM,IAAI;;EAiEnB,CAAC"}

package/dist/stores/ui-store.js

@@ -0,0 +1,62 @@
+// @bun
+var __defProp = Object.defineProperty;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+
+// src/stores/ui-store.ts
+import { create } from "zustand";
+import { immer } from "zustand/middleware/immer";
+var DEFAULT_VIEW = "dashboard";
+var initialState = {
+  activeView: DEFAULT_VIEW,
+  sidebarExpanded: true,
+  modal: null,
+  commandPaletteOpen: false,
+  previousView: null
+};
+var useUIStore = create()(immer((set) => ({
+  ...initialState,
+  setView: (view) => set((state) => {
+    if (state.activeView !== view) {
+      state.previousView = state.activeView;
+    }
+    state.activeView = view;
+    state.commandPaletteOpen = false;
+  }),
+  toggleSidebar: () => set((state) => {
+    state.sidebarExpanded = !state.sidebarExpanded;
+  }),
+  openPalette: () => set((state) => {
+    state.commandPaletteOpen = true;
+  }),
+  closePalette: () => set((state) => {
+    state.commandPaletteOpen = false;
+  }),
+  showModal: (modal) => set((state) => {
+    state.modal = modal;
+  }),
+  dismissModal: () => set((state) => {
+    state.modal = null;
+  }),
+  goBack: () => set((state) => {
+    if (state.previousView) {
+      state.activeView = state.previousView;
+      state.previousView = null;
+    }
+  })
+})));
+export {
+  useUIStore
+};