@jango-blockchained/hoox-shared 1.0.8

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

@@ -0,0 +1,206 @@
+import type { WorkerInfo, Trade, Alert, LogEntry, SystemMetrics, ConnectionStatus } from "../types";
+export interface ServiceState {
+    workers: WorkerInfo[];
+    tradeStream: Trade[];
+    alerts: Alert[];
+    logs: LogEntry[];
+    metrics: SystemMetrics | null;
+    connectionStatus: ConnectionStatus;
+    lastUpdated: number;
+    selectedWorkerId: string | null;
+    /** Number of consecutive failed reconnection attempts */
+    retryCount: number;
+    /** Last connection error message (for display) */
+    lastError: string | null;
+    /** Timestamp (ms) of the last successful API fetch */
+    lastSuccessfulFetch: number;
+    /** Current backoff delay in ms (0 when not reconnecting) */
+    reconnectDelay: number;
+    /** Timestamp when the connection was lost (for downtime calculation) */
+    disconnectedAt: number | null;
+}
+interface ServiceActions {
+    fetchWorkers: () => Promise<void>;
+    streamTrades: () => Promise<void>;
+    streamLogs: () => Promise<void>;
+    addAlert: (alert: Alert) => void;
+    addAlerts: (alerts: Alert[]) => void;
+    setConnectionStatus: (status: ConnectionStatus) => void;
+    selectWorker: (id: string | null) => void;
+    setWorkers: (workers: WorkerInfo[]) => void;
+    pushTrade: (trade: Trade) => void;
+    pushLog: (log: LogEntry) => void;
+    setMetrics: (metrics: SystemMetrics) => void;
+    /** Called on successful API response — resets error state */
+    handleConnectionSuccess: () => void;
+    /** Called on API failure — increments retry, applies backoff */
+    handleConnectionFailure: (errorMessage: string) => void;
+    /** Reset all retry/reconnect state (on full reconnect) */
+    resetRetries: () => void;
+    /** Force a connection retry from offline state */
+    forceRetry: () => void;
+}
+export declare const useServiceStore: import("zustand").UseBoundStore<Omit<import("zustand").StoreApi<ServiceState & ServiceActions>, "setState"> & {
+    setState(nextStateOrUpdater: (ServiceState & ServiceActions) | Partial<ServiceState & ServiceActions> | ((state: {
+        workers: {
+            id: string;
+            name: string;
+            status: import("..").WorkerStatus;
+            uptime: number;
+            cpu: number;
+            memory: number;
+            requests: number;
+            durableObjectCount: number;
+            edgeCount: number;
+            version?: string | undefined;
+            lastDeployed?: number | undefined;
+        }[];
+        tradeStream: {
+            id: string;
+            symbol: string;
+            side: import("..").TradeSide;
+            price: number;
+            quantity: number;
+            timestamp: number;
+            exchange: string;
+            strategy?: string | undefined;
+            pnl?: number | undefined;
+        }[];
+        alerts: {
+            id: string;
+            type: string;
+            severity: import("..").AlertSeverity;
+            message: string;
+            timestamp: number;
+            workerId?: string | undefined;
+            acknowledged: boolean;
+            source?: string | undefined;
+        }[];
+        logs: {
+            id: string;
+            level: import("..").LogLevel;
+            message: string;
+            timestamp: number;
+            workerId?: string | undefined;
+            source?: string | undefined;
+            metadata?: {
+                [x: string]: unknown;
+            } | undefined;
+        }[];
+        metrics: {
+            totalWorkers: number;
+            onlineWorkers: number;
+            totalPnl: number;
+            activeStrategies: number;
+            dailyTrades: number;
+            aiCalls: number;
+            uptime: number;
+            lastUpdated: number;
+        } | null;
+        connectionStatus: ConnectionStatus;
+        lastUpdated: number;
+        selectedWorkerId: string | null;
+        retryCount: number;
+        lastError: string | null;
+        lastSuccessfulFetch: number;
+        reconnectDelay: number;
+        disconnectedAt: number | null;
+        fetchWorkers: () => Promise<void>;
+        streamTrades: () => Promise<void>;
+        streamLogs: () => Promise<void>;
+        addAlert: (alert: Alert) => void;
+        addAlerts: (alerts: Alert[]) => void;
+        setConnectionStatus: (status: ConnectionStatus) => void;
+        selectWorker: (id: string | null) => void;
+        setWorkers: (workers: WorkerInfo[]) => void;
+        pushTrade: (trade: Trade) => void;
+        pushLog: (log: LogEntry) => void;
+        setMetrics: (metrics: SystemMetrics) => void;
+        handleConnectionSuccess: () => void;
+        handleConnectionFailure: (errorMessage: string) => void;
+        resetRetries: () => void;
+        forceRetry: () => void;
+    }) => void), shouldReplace?: false): void;
+    setState(nextStateOrUpdater: (ServiceState & ServiceActions) | ((state: {
+        workers: {
+            id: string;
+            name: string;
+            status: import("..").WorkerStatus;
+            uptime: number;
+            cpu: number;
+            memory: number;
+            requests: number;
+            durableObjectCount: number;
+            edgeCount: number;
+            version?: string | undefined;
+            lastDeployed?: number | undefined;
+        }[];
+        tradeStream: {
+            id: string;
+            symbol: string;
+            side: import("..").TradeSide;
+            price: number;
+            quantity: number;
+            timestamp: number;
+            exchange: string;
+            strategy?: string | undefined;
+            pnl?: number | undefined;
+        }[];
+        alerts: {
+            id: string;
+            type: string;
+            severity: import("..").AlertSeverity;
+            message: string;
+            timestamp: number;
+            workerId?: string | undefined;
+            acknowledged: boolean;
+            source?: string | undefined;
+        }[];
+        logs: {
+            id: string;
+            level: import("..").LogLevel;
+            message: string;
+            timestamp: number;
+            workerId?: string | undefined;
+            source?: string | undefined;
+            metadata?: {
+                [x: string]: unknown;
+            } | undefined;
+        }[];
+        metrics: {
+            totalWorkers: number;
+            onlineWorkers: number;
+            totalPnl: number;
+            activeStrategies: number;
+            dailyTrades: number;
+            aiCalls: number;
+            uptime: number;
+            lastUpdated: number;
+        } | null;
+        connectionStatus: ConnectionStatus;
+        lastUpdated: number;
+        selectedWorkerId: string | null;
+        retryCount: number;
+        lastError: string | null;
+        lastSuccessfulFetch: number;
+        reconnectDelay: number;
+        disconnectedAt: number | null;
+        fetchWorkers: () => Promise<void>;
+        streamTrades: () => Promise<void>;
+        streamLogs: () => Promise<void>;
+        addAlert: (alert: Alert) => void;
+        addAlerts: (alerts: Alert[]) => void;
+        setConnectionStatus: (status: ConnectionStatus) => void;
+        selectWorker: (id: string | null) => void;
+        setWorkers: (workers: WorkerInfo[]) => void;
+        pushTrade: (trade: Trade) => void;
+        pushLog: (log: LogEntry) => void;
+        setMetrics: (metrics: SystemMetrics) => void;
+        handleConnectionSuccess: () => void;
+        handleConnectionFailure: (errorMessage: string) => void;
+        resetRetries: () => void;
+        forceRetry: () => void;
+    }) => void), shouldReplace: true): void;
+}>;
+export {};
+//# sourceMappingURL=service-store.d.ts.map

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

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

package/dist/stores/service-store.js

@@ -0,0 +1,359 @@
+// @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/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));
+}
+async function hooxFetch(path, 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 = `${API_BASE}${path}`;
+      const headers = {
+        "Content-Type": "application/json",
+        ...API_TOKEN ? { Authorization: `Bearer ${API_TOKEN}` } : {},
+        ...options?.headers
+      };
+      const response = await fetch(url, {
+        ...options,
+        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 API_BASE, API_TOKEN, FETCH_TIMEOUT_MS = 5000, MAX_RETRIES = 3, BASE_RETRY_DELAY_MS = 1000, MAX_RETRY_DELAY_MS = 16000, WorkerAPIError;
+var init_api_client = __esm(() => {
+  API_BASE = process.env.HOOX_API_URL || "http://localhost:8787";
+  API_TOKEN = process.env.HOOX_API_TOKEN || "";
+  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) {
+  let aborted = false;
+  const run = async () => {
+    let attempt = 0;
+    while (!aborted && attempt < MAX_RECONNECT_ATTEMPTS) {
+      try {
+        const url = `${API_BASE2}${path}`;
+        const response = await fetch(url, {
+          headers: {
+            Accept: "text/event-stream",
+            ...API_TOKEN2 ? { Authorization: `Bearer ${API_TOKEN2}` } : {}
+          }
+        });
+        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 (error) {
+        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 API_BASE2, API_TOKEN2, RECONNECT_BASE_MS = 1000, RECONNECT_MAX_MS = 16000, MAX_RECONNECT_ATTEMPTS = 10;
+var init_sse = __esm(() => {
+  API_BASE2 = process.env.HOOX_API_URL || "http://localhost:8787";
+  API_TOKEN2 = process.env.HOOX_API_TOKEN || "";
+});
+
+// src/stores/service-store.ts
+import { create } from "zustand";
+import { immer } from "zustand/middleware/immer";
+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 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,
+  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 { hooxFetch: hooxFetch2 } = await Promise.resolve().then(() => (init_api_client(), exports_api_client));
+    try {
+      const data = await hooxFetch2("/workers");
+      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.reconnectDelay = 0;
+          state.disconnectedAt = null;
+        }
+      });
+    } catch (error) {
+      const msg = error instanceof Error ? error.message : "Unknown fetch error";
+      set((state) => {
+        if (state.connectionStatus === "connected" || state.connectionStatus === "polling") {
+          state.connectionStatus = "reconnecting";
+          state.retryCount = state.retryCount + 1;
+          state.lastError = msg;
+          state.disconnectedAt = state.disconnectedAt ?? Date.now();
+          if (state.retryCount >= MAX_RETRIES2) {
+            state.connectionStatus = "offline";
+            state.lastError = `Connection lost after ${MAX_RETRIES2} retries`;
+          } else {
+            state.reconnectDelay = getBackoffDelay(state.retryCount);
+          }
+        }
+        if (state.connectionStatus === "reconnecting") {
+          state.lastError = msg;
+        }
+      });
+    }
+  },
+  streamTrades: async () => {
+    const { subscribeSSE: subscribeSSE2 } = await Promise.resolve().then(() => (init_sse(), exports_sse));
+    try {
+      await subscribeSSE2("/trades/stream", (trade) => {
+        get().pushTrade(trade);
+      });
+    } catch {}
+  },
+  streamLogs: async () => {
+    const { subscribeSSE: subscribeSSE2 } = await Promise.resolve().then(() => (init_sse(), exports_sse));
+    try {
+      await subscribeSSE2("/logs/stream", (log) => {
+        get().pushLog(log);
+      });
+    } catch {}
+  },
+  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.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.reconnectDelay = 0;
+    state.disconnectedAt = null;
+    if (state.connectionStatus === "reconnecting" || state.connectionStatus === "polling") {
+      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.reconnectDelay = 0;
+    state.disconnectedAt = null;
+  }),
+  forceRetry: () => set((state) => {
+    if (state.connectionStatus === "offline") {
+      state.connectionStatus = "polling";
+      state.retryCount = 0;
+      state.lastError = null;
+      state.reconnectDelay = 0;
+    }
+  })
+})));
+export {
+  useServiceStore
+};

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

@@ -0,0 +1,63 @@
+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":"AAMA,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"}