@elizaos/ui 2.0.0-alpha.85 → 2.0.0-beta.2

package/state/useStartupCoordinator.js

@@ -0,0 +1,194 @@
+/**
+ * useStartupCoordinator — React hook that drives the StartupCoordinator
+ * state machine with side effects.
+ *
+ * This hook is the SOLE startup authority. It:
+ * 1. Uses useReducer with the coordinator's startupReducer
+ * 2. Delegates per-phase work to phase modules (startup-phase-*.ts)
+ * 3. Dispatches events as async operations complete
+ * 4. Syncs coordinator state to the legacy lifecycle setters
+ *
+ * Architecture: Each phase is handled by a dedicated function imported from
+ * a phase module. One-time hydration work runs in the "hydrating" effect.
+ * Persistent WS bindings and navigation listeners are set up via bindReadyPhase
+ * in a "ready" effect that only cleans up on unmount (not on phase transitions).
+ */
+import { useCallback, useEffect, useReducer, useRef } from "react";
+import { isElectrobunRuntime } from "../bridge/index.js";
+import { isAndroid, isElizaOS, isNative } from "../platform/index.js";
+import { loadPersistedOnboardingComplete } from "./persistence.js";
+import { createAndroidPolicy, createDesktopPolicy, createElizaOSPolicy, createMobilePolicy, createWebPolicy, INITIAL_STARTUP_STATE, isStartupLoading, isStartupTerminal, startupReducer, toLegacyStartupPhase, } from "./startup-coordinator.js";
+import { bindReadyPhase, runHydrating, } from "./startup-phase-hydrate.js";
+import { runPollingBackend, } from "./startup-phase-poll.js";
+import { runRestoringSession, } from "./startup-phase-restore.js";
+import { runStartingRuntime, } from "./startup-phase-runtime.js";
+function detectPlatformPolicy() {
+    if (isElectrobunRuntime())
+        return createDesktopPolicy();
+    // ElizaOS check must come before the generic mobile branch — both are
+    // native, but ElizaOS bundles the on-device agent and needs the longer
+    // backend timeout (vanilla mobile is cloud-only with a fast-fail budget).
+    if (isElizaOS())
+        return createElizaOSPolicy();
+    if (isAndroid)
+        return createAndroidPolicy();
+    if (isNative)
+        return createMobilePolicy();
+    return createWebPolicy();
+}
+// ── Hook ────────────────────────────────────────────────────────────
+export function useStartupCoordinator(deps) {
+    const [state, dispatch] = useReducer(startupReducer, INITIAL_STARTUP_STATE);
+    const policy = useRef(detectPlatformPolicy()).current;
+    const effectRunRef = useRef(0);
+    // Deps ref — effects always access latest deps without re-triggering
+    const depsRef = useRef(deps);
+    depsRef.current = deps;
+    const depsReady = deps != null;
+    // Session context carried between restoring-session and polling-backend
+    const _ctx = useRef(null);
+    // Track whether the ready-phase WS bindings have been set up
+    const wsBindingsActiveRef = useRef(false);
+    // ── Legacy sync — derive startupPhase from coordinator state ────
+    const legacyPhase = toLegacyStartupPhase(state);
+    useEffect(() => {
+        if (!depsReady)
+            return;
+        depsRef.current?.setStartupPhase(legacyPhase);
+    }, [legacyPhase, depsReady]);
+    // ── Phase: splash — auto-skip for returning users, mark loaded for new users
+    // Fresh installs stay on splash until the user explicitly continues.
+    useEffect(() => {
+        if (state.phase !== "splash")
+            return;
+        if (!depsReady)
+            return;
+        if (loadPersistedOnboardingComplete()) {
+            dispatch({ type: "SPLASH_CONTINUE" });
+            return;
+        }
+        dispatch({ type: "SPLASH_LOADED" });
+    }, [state.phase, depsReady]);
+    // ── Phase: restoring-session ────────────────────────────────────
+    useEffect(() => {
+        if (state.phase !== "restoring-session" || !depsReady)
+            return;
+        const d = depsRef.current;
+        if (!d)
+            return;
+        effectRunRef.current += 1;
+        const cancelled = { current: false };
+        runRestoringSession(d, dispatch, _ctx, cancelled).catch((err) => {
+            console.error("[eliza][startup:restore] Unexpected error:", err);
+        });
+        return () => {
+            cancelled.current = true;
+        };
+    }, [state.phase, depsReady]);
+    // ── Phase: resolving-target (auto-advance) ──────────────────────
+    useEffect(() => {
+        if (state.phase !== "resolving-target")
+            return;
+        dispatch({ type: "BACKEND_POLL_RETRY" });
+    }, [state.phase]);
+    // ── Phase: polling-backend ──────────────────────────────────────
+    useEffect(() => {
+        if (state.phase !== "polling-backend" || !depsReady)
+            return;
+        const currentDeps = depsRef.current;
+        if (!currentDeps)
+            return;
+        effectRunRef.current += 1;
+        const runId = effectRunRef.current;
+        const cancelled = { current: false };
+        const tidRef = { current: null };
+        runPollingBackend(currentDeps, dispatch, policy, _ctx.current, runId, effectRunRef, cancelled, tidRef).catch((err) => {
+            console.error("[eliza][startup:poll] Unexpected error:", err);
+        });
+        return () => {
+            cancelled.current = true;
+            if (tidRef.current)
+                clearTimeout(tidRef.current);
+        };
+    }, [state.phase, policy.backendTimeoutMs, depsReady, policy]);
+    // ── Phase: starting-runtime ─────────────────────────────────────
+    useEffect(() => {
+        if (state.phase !== "starting-runtime" || !depsReady)
+            return;
+        const currentDeps = depsRef.current;
+        if (!currentDeps)
+            return;
+        effectRunRef.current += 1;
+        const runId = effectRunRef.current;
+        const cancelled = { current: false };
+        const tidRef = { current: null };
+        runStartingRuntime(currentDeps, dispatch, runId, effectRunRef, cancelled, tidRef).catch((err) => {
+            console.error("[eliza][startup:runtime] Unexpected error:", err);
+        });
+        return () => {
+            cancelled.current = true;
+            if (tidRef.current)
+                clearTimeout(tidRef.current);
+        };
+    }, [state.phase, depsReady]);
+    // ── Phase: hydrating — one-time data load, then HYDRATION_COMPLETE ─
+    useEffect(() => {
+        if (state.phase !== "hydrating" || !depsReady)
+            return;
+        const currentDeps = depsRef.current;
+        if (!currentDeps)
+            return;
+        const cancelled = { current: false };
+        runHydrating(currentDeps, dispatch, cancelled).catch((err) => {
+            console.error("[eliza][startup:hydrate] Unexpected error:", err);
+        });
+        return () => {
+            cancelled.current = true;
+        };
+    }, [state.phase, depsReady]);
+    // ── Ready phase — persistent WS bindings + nav listener ─────────
+    // This effect runs once when the coordinator reaches "ready" and stays
+    // active until the component unmounts. It does NOT depend on state.phase
+    // after the guard, so phase transitions won't clean up WS bindings.
+    const readyPhaseReached = state.phase === "ready";
+    useEffect(() => {
+        if (!readyPhaseReached || !depsReady)
+            return;
+        if (wsBindingsActiveRef.current)
+            return; // Already bound
+        wsBindingsActiveRef.current = true;
+        const cleanup = bindReadyPhase(depsRef);
+        return () => {
+            wsBindingsActiveRef.current = false;
+            cleanup();
+        };
+    }, [readyPhaseReached, depsReady]);
+    // ── Public interface ─────────────────────────────────────────────
+    const retry = useCallback(() => dispatch({ type: "RETRY" }), []);
+    const reset = useCallback(() => {
+        _ctx.current = null;
+        effectRunRef.current += 1;
+        dispatch({ type: "RESET" });
+    }, []);
+    const pairingSuccess = useCallback(() => dispatch({ type: "PAIRING_SUCCESS" }), []);
+    const onboardingCompleteFn = useCallback(() => dispatch({ type: "ONBOARDING_COMPLETE" }), []);
+    let target = null;
+    if (state.phase === "resolving-target")
+        target = state.target;
+    else if (state.phase === "polling-backend")
+        target = state.target;
+    return {
+        state,
+        dispatch,
+        retry,
+        reset,
+        pairingSuccess,
+        onboardingComplete: onboardingCompleteFn,
+        policy,
+        legacyPhase: toLegacyStartupPhase(state),
+        loading: isStartupLoading(state),
+        terminal: isStartupTerminal(state),
+        target,
+        phase: state.phase,
+    };
+}

package/state/useTriggersState.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Trigger (heartbeat) state — extracted from AppContext.
+ *
+ * Manages trigger CRUD, run history, and health polling. Zero coupling to
+ * the startup sequence — triggers are only loaded post-ready.
+ */
+import type { CreateTriggerRequest, TriggerHealthSnapshot, TriggerRunRecord, TriggerSummary, UpdateTriggerRequest } from "../api";
+export declare function useTriggersState(): {
+    state: {
+        triggers: TriggerSummary[];
+        triggersLoaded: boolean;
+        triggersLoading: boolean;
+        triggersSaving: boolean;
+        triggerRunsById: Record<string, TriggerRunRecord[]>;
+        triggerHealth: TriggerHealthSnapshot | null;
+        triggerError: string | null;
+    };
+    loadTriggers: (options?: {
+        silent?: boolean;
+    }) => Promise<void>;
+    loadTriggerHealth: () => Promise<void>;
+    loadTriggerRuns: (id: string) => Promise<void>;
+    ensureTriggersLoaded: () => Promise<void>;
+    createTrigger: (request: CreateTriggerRequest) => Promise<TriggerSummary | null>;
+    updateTrigger: (id: string, request: UpdateTriggerRequest) => Promise<TriggerSummary | null>;
+    deleteTrigger: (id: string) => Promise<boolean>;
+    runTriggerNow: (id: string) => Promise<boolean>;
+};
+//# sourceMappingURL=useTriggersState.d.ts.map

package/state/useTriggersState.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useTriggersState.d.ts","sourceRoot":"","sources":["../../../../../src/state/useTriggersState.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,KAAK,EACV,oBAAoB,EACpB,qBAAqB,EACrB,gBAAgB,EAChB,cAAc,EACd,oBAAoB,EACrB,MAAM,QAAQ,CAAC;AAgBhB,wBAAgB,gBAAgB;;;;;;;;;;6BAqBoB;QAAE,MAAM,CAAC,EAAE,OAAO,CAAA;KAAE;;0BA4BvB,MAAM;;6BAanC,oBAAoB,KAAG,OAAO,CAAC,cAAc,GAAG,IAAI,CAAC;wBA2B/D,MAAM,WACD,oBAAoB,KAC5B,OAAO,CAAC,cAAc,GAAG,IAAI,CAAC;wBA2BtB,MAAM,KAAG,OAAO,CAAC,OAAO,CAAC;wBA4BzB,MAAM,KAAG,OAAO,CAAC,OAAO,CAAC;EAqDvC"}

package/state/useTriggersState.js

@@ -0,0 +1,198 @@
+/**
+ * Trigger (heartbeat) state — extracted from AppContext.
+ *
+ * Manages trigger CRUD, run history, and health polling. Zero coupling to
+ * the startup sequence — triggers are only loaded post-ready.
+ */
+import { useCallback, useState } from "react";
+import { client } from "../api/index.js";
+// ── Helpers ───────────────────────────────────────────────────────────
+function sortTriggersByNextRun(items) {
+    return [...items].sort((a, b) => {
+        const aNext = a.nextRunAtMs ?? Number.MAX_SAFE_INTEGER;
+        const bNext = b.nextRunAtMs ?? Number.MAX_SAFE_INTEGER;
+        if (aNext !== bNext)
+            return aNext - bNext;
+        return a.displayName.localeCompare(b.displayName);
+    });
+}
+// ── Hook ──────────────────────────────────────────────────────────────
+export function useTriggersState() {
+    const [triggers, setTriggers] = useState([]);
+    const [triggersLoaded, setTriggersLoaded] = useState(false);
+    const [triggersLoading, setTriggersLoading] = useState(false);
+    const [triggersSaving, setTriggersSaving] = useState(false);
+    const [triggerRunsById, setTriggerRunsById] = useState({});
+    const [triggerHealth, setTriggerHealth] = useState(null);
+    const [triggerError, setTriggerError] = useState(null);
+    const loadTriggerHealth = useCallback(async () => {
+        try {
+            const health = await client.getTriggerHealth();
+            setTriggerHealth(health);
+        }
+        catch {
+            setTriggerHealth(null);
+        }
+    }, []);
+    const loadTriggers = useCallback(async (options) => {
+        const silent = options?.silent === true;
+        if (!silent) {
+            setTriggersLoading(true);
+        }
+        try {
+            const data = await client.getTriggers();
+            setTriggers(sortTriggersByNextRun(data.triggers));
+            setTriggerError(null);
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : "Failed to load triggers";
+            setTriggerError(message);
+            if (!silent) {
+                setTriggers([]);
+            }
+        }
+        finally {
+            setTriggersLoaded(true);
+            if (!silent) {
+                setTriggersLoading(false);
+            }
+        }
+    }, []);
+    const ensureTriggersLoaded = useCallback(async () => {
+        await loadTriggers(triggersLoaded ? { silent: true } : undefined);
+    }, [loadTriggers, triggersLoaded]);
+    const loadTriggerRuns = useCallback(async (id) => {
+        try {
+            const data = await client.getTriggerRuns(id);
+            setTriggerRunsById((prev) => ({ ...prev, [id]: data.runs }));
+            setTriggerError(null);
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : "Failed to load trigger runs";
+            setTriggerError(message);
+        }
+    }, []);
+    const createTrigger = useCallback(async (request) => {
+        setTriggersSaving(true);
+        try {
+            const response = await client.createTrigger(request);
+            const created = response.trigger;
+            setTriggers((prev) => {
+                const merged = prev.filter((item) => item.id !== created.id);
+                merged.push(created);
+                return sortTriggersByNextRun(merged);
+            });
+            setTriggerError(null);
+            void loadTriggerHealth();
+            return created;
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : "Failed to create trigger";
+            setTriggerError(message);
+            return null;
+        }
+        finally {
+            setTriggersSaving(false);
+        }
+    }, [loadTriggerHealth]);
+    const updateTrigger = useCallback(async (id, request) => {
+        setTriggersSaving(true);
+        try {
+            const response = await client.updateTrigger(id, request);
+            const updated = response.trigger;
+            setTriggers((prev) => {
+                const merged = prev.map((item) => item.id === updated.id ? updated : item);
+                return sortTriggersByNextRun(merged);
+            });
+            setTriggerError(null);
+            void loadTriggerHealth();
+            return updated;
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : "Failed to update trigger";
+            setTriggerError(message);
+            return null;
+        }
+        finally {
+            setTriggersSaving(false);
+        }
+    }, [loadTriggerHealth]);
+    const deleteTrigger = useCallback(async (id) => {
+        setTriggersSaving(true);
+        try {
+            await client.deleteTrigger(id);
+            setTriggers((prev) => prev.filter((item) => item.id !== id));
+            setTriggerRunsById((prev) => {
+                const next = {};
+                for (const [key, runs] of Object.entries(prev)) {
+                    if (key !== id)
+                        next[key] = runs;
+                }
+                return next;
+            });
+            setTriggerError(null);
+            void loadTriggerHealth();
+            return true;
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : "Failed to delete trigger";
+            setTriggerError(message);
+            return false;
+        }
+        finally {
+            setTriggersSaving(false);
+        }
+    }, [loadTriggerHealth]);
+    const runTriggerNow = useCallback(async (id) => {
+        setTriggersSaving(true);
+        try {
+            const response = await client.runTriggerNow(id);
+            if (response.trigger) {
+                const trigger = response.trigger;
+                setTriggers((prev) => {
+                    const idx = prev.findIndex((item) => item.id === id);
+                    if (idx === -1) {
+                        return sortTriggersByNextRun([...prev, trigger]);
+                    }
+                    const updated = [...prev];
+                    updated[idx] = trigger;
+                    return sortTriggersByNextRun(updated);
+                });
+            }
+            else {
+                await loadTriggers();
+            }
+            await loadTriggerRuns(id);
+            void loadTriggerHealth();
+            setTriggerError(null);
+            return response.ok;
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : "Failed to run trigger";
+            setTriggerError(message);
+            return false;
+        }
+        finally {
+            setTriggersSaving(false);
+        }
+    }, [loadTriggerHealth, loadTriggerRuns, loadTriggers]);
+    return {
+        state: {
+            triggers,
+            triggersLoaded,
+            triggersLoading,
+            triggersSaving,
+            triggerRunsById,
+            triggerHealth,
+            triggerError,
+        },
+        loadTriggers,
+        loadTriggerHealth,
+        loadTriggerRuns,
+        ensureTriggersLoaded,
+        createTrigger,
+        updateTrigger,
+        deleteTrigger,
+        runTriggerNow,
+    };
+}

package/state/useVincentState.d.ts

@@ -0,0 +1,3 @@
+import type { VincentStateHookArgs, VincentStateHookResult } from "../config/boot-config";
+export declare function useVincentState(args: VincentStateHookArgs): VincentStateHookResult;
+//# sourceMappingURL=useVincentState.d.ts.map

package/state/useVincentState.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useVincentState.d.ts","sourceRoot":"","sources":["../../../../../src/state/useVincentState.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,oBAAoB,EACpB,sBAAsB,EACvB,MAAM,uBAAuB,CAAC;AAa/B,wBAAgB,eAAe,CAC7B,IAAI,EAAE,oBAAoB,GACzB,sBAAsB,CAExB"}

package/state/useVincentState.js

@@ -0,0 +1,13 @@
+import { getBootConfig } from "../config/boot-config.js";
+const DEFAULT_VINCENT_STATE = {
+    vincentConnected: false,
+    vincentLoginBusy: false,
+    vincentLoginError: null,
+    vincentConnectedAt: null,
+    handleVincentLogin: async () => { },
+    handleVincentDisconnect: async () => { },
+    pollVincentStatus: async () => false,
+};
+export function useVincentState(args) {
+    return getBootConfig().useVincentState?.(args) ?? DEFAULT_VINCENT_STATE;
+}

package/state/useWalletState.d.ts

@@ -0,0 +1,97 @@
+/**
+ * Wallet / Inventory / Registry / Drop / Whitelist state — extracted from AppContext.
+ *
+ * Manages:
+ * - Wallet addresses, config, balances, NFTs, export flow
+ * - Inventory view preferences (sort, filter, chain toggles)
+ * - ERC-8004 on-chain registry (register, sync, status)
+ * - Drop / mint state and actions
+ * - Whitelist status
+ *
+ * Cross-domain dependencies accepted as params:
+ * - `setActionNotice` — from useLifecycleState, used by handleWalletApiKeySave
+ * - `agentName`       — from agentStatus?.agentName, used by registry/mint
+ * - `characterName`   — from characterDraft?.name, used by registry/mint
+ * - `promptModal`     — from AppContext's usePrompt(), used by handleExportKeys
+ * - `confirmAction`   — confirmDesktopAction utility, used by handleExportKeys
+ */
+import type { WalletAddresses, WalletBalancesResponse, WalletChainKind, WalletConfigStatus, WalletConfigUpdateRequest, WalletEntry, WalletNftsResponse, WalletPrimaryMap, WalletSource } from "@elizaos/shared";
+import { type DropStatus, type MintResult, type RegistryStatus, type WalletExportResult, type WhitelistStatus } from "../api";
+import type { PromptOptions } from "../components/ui/confirm-dialog";
+import type { InventoryChainFilters } from "./types";
+interface WalletStateParams {
+    setActionNotice: (text: string, tone?: "info" | "success" | "error", ttlMs?: number, once?: boolean, busy?: boolean) => void;
+    /** Prompt modal function from AppContext's usePrompt() instance */
+    promptModal: (opts: PromptOptions) => Promise<string | null>;
+    /** Current agent name (from agentStatus?.agentName) */
+    agentName: string | undefined;
+    /** Current character draft name (from characterDraft?.name) */
+    characterName: string | undefined;
+}
+export declare function useWalletState({ setActionNotice, promptModal, agentName, characterName, }: WalletStateParams): {
+    state: {
+        browserEnabled: boolean;
+        computerUseEnabled: boolean;
+        walletEnabled: boolean;
+        walletAddresses: WalletAddresses | null;
+        walletConfig: WalletConfigStatus | null;
+        walletBalances: WalletBalancesResponse | null;
+        walletNfts: WalletNftsResponse | null;
+        walletLoading: boolean;
+        walletNftsLoading: boolean;
+        inventoryView: "tokens" | "nfts";
+        walletExportData: WalletExportResult | null;
+        walletExportVisible: boolean;
+        walletApiKeySaving: boolean;
+        wallets: WalletEntry[];
+        walletPrimary: WalletPrimaryMap | null;
+        walletPrimaryRestarting: Partial<Record<WalletChainKind, boolean>>;
+        walletPrimaryPending: Partial<Record<WalletChainKind, boolean>>;
+        cloudRefreshing: boolean;
+        inventorySort: "symbol" | "value" | "chain";
+        inventorySortDirection: "desc" | "asc";
+        inventoryChainFilters: InventoryChainFilters;
+        walletError: string | null;
+        registryStatus: RegistryStatus | null;
+        registryLoading: boolean;
+        registryRegistering: boolean;
+        registryError: string | null;
+        dropStatus: DropStatus | null;
+        dropLoading: boolean;
+        mintInProgress: boolean;
+        mintResult: MintResult | null;
+        mintError: string | null;
+        mintShiny: boolean;
+        whitelistStatus: WhitelistStatus | null;
+        whitelistLoading: boolean;
+    };
+    setBrowserEnabled: (v: boolean) => void;
+    setComputerUseEnabled: (v: boolean) => void;
+    setWalletEnabled: (v: boolean) => void;
+    setWalletAddresses: import("react").Dispatch<import("react").SetStateAction<WalletAddresses | null>>;
+    setInventoryView: import("react").Dispatch<import("react").SetStateAction<"tokens" | "nfts">>;
+    setInventorySort: import("react").Dispatch<import("react").SetStateAction<"symbol" | "value" | "chain">>;
+    setInventorySortDirection: import("react").Dispatch<import("react").SetStateAction<"desc" | "asc">>;
+    setInventoryChainFilters: import("react").Dispatch<import("react").SetStateAction<InventoryChainFilters>>;
+    setWalletError: import("react").Dispatch<import("react").SetStateAction<string | null>>;
+    setRegistryError: import("react").Dispatch<import("react").SetStateAction<string | null>>;
+    setMintResult: import("react").Dispatch<import("react").SetStateAction<MintResult | null>>;
+    setMintError: import("react").Dispatch<import("react").SetStateAction<string | null>>;
+    loadWalletConfig: () => Promise<void>;
+    loadBalances: () => Promise<void>;
+    loadNfts: () => Promise<void>;
+    handleWalletApiKeySave: (config: WalletConfigUpdateRequest) => Promise<boolean>;
+    setWalletPrimary: (chain: WalletChainKind, source: WalletSource) => Promise<void>;
+    setPrimary: (chain: WalletChainKind, source: WalletSource) => Promise<void>;
+    refreshCloud: () => Promise<void>;
+    refreshCloudWallets: () => Promise<void>;
+    handleExportKeys: () => Promise<void>;
+    loadRegistryStatus: () => Promise<void>;
+    registerOnChain: () => Promise<void>;
+    syncRegistryProfile: () => Promise<void>;
+    loadDropStatus: () => Promise<void>;
+    mintFromDrop: (shiny: boolean) => Promise<void>;
+    loadWhitelistStatus: () => Promise<void>;
+};
+export {};
+//# sourceMappingURL=useWalletState.d.ts.map

package/state/useWalletState.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useWalletState.d.ts","sourceRoot":"","sources":["../../../../../src/state/useWalletState.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,KAAK,EACV,eAAe,EACf,sBAAsB,EACtB,eAAe,EACf,kBAAkB,EAClB,yBAAyB,EACzB,WAAW,EACX,kBAAkB,EAClB,gBAAgB,EAChB,YAAY,EACb,MAAM,iBAAiB,CAAC;AAEzB,OAAO,EAEL,KAAK,UAAU,EACf,KAAK,UAAU,EACf,KAAK,cAAc,EACnB,KAAK,kBAAkB,EACvB,KAAK,eAAe,EACrB,MAAM,QAAQ,CAAC;AAChB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iCAAiC,CAAC;AAUrE,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAC;AAIrD,UAAU,iBAAiB;IACzB,eAAe,EAAE,CACf,IAAI,EAAE,MAAM,EACZ,IAAI,CAAC,EAAE,MAAM,GAAG,SAAS,GAAG,OAAO,EACnC,KAAK,CAAC,EAAE,MAAM,EACd,IAAI,CAAC,EAAE,OAAO,EACd,IAAI,CAAC,EAAE,OAAO,KACX,IAAI,CAAC;IACV,mEAAmE;IACnE,WAAW,EAAE,CAAC,IAAI,EAAE,aAAa,KAAK,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAAC;IAC7D,uDAAuD;IACvD,SAAS,EAAE,MAAM,GAAG,SAAS,CAAC;IAC9B,+DAA+D;IAC/D,aAAa,EAAE,MAAM,GAAG,SAAS,CAAC;CACnC;AAID,wBAAgB,cAAc,CAAC,EAC7B,eAAe,EACf,WAAW,EACX,SAAS,EACT,aAAa,GACd,EAAE,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAYwB,OAAO;+BAWH,OAAO;0BApBZ,OAAO;;;;;;;;;;;;;qCAwP/B,yBAAyB;8BAyF1B,eAAe,UAAU,YAAY;wBAArC,eAAe,UAAU,YAAY;;;;;;;;0BA4JrC,OAAO;;EA0GxB"}