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

package/hooks/useRuntimeMode.js

@@ -0,0 +1,81 @@
+/**
+ * useRuntimeMode — reads the authoritative runtime-mode snapshot from
+ * `GET /api/runtime/mode`.
+ *
+ * The endpoint is the single source of truth for `local` / `local-only` /
+ * `cloud` / `remote` (see `packages/app-core/src/runtime/mode/runtime-mode.ts`
+ * and `runtime-mode-routes.ts`). UI surfaces that previously inferred mode
+ * from `activeServer` / `clientBaseUrl` heuristics should consume this hook
+ * so the dashboard agrees with the server's resolved configuration.
+ *
+ * The result is cached at module scope and shared across all consumers — a
+ * single `GET /api/runtime/mode` per session is enough; the snapshot only
+ * changes when the user reconfigures deployment, which itself triggers a
+ * full reload.
+ *
+ * Failure mode: when the endpoint is unreachable (no auth, no server, older
+ * build), the hook returns `phase: "unavailable"` and callers fall back to
+ * local heuristics. The snapshot is advisory; it never gates security.
+ */
+import { useCallback, useEffect, useRef, useState } from "react";
+import { fetchRuntimeModeSnapshot, } from "../api/runtime-mode-client.js";
+const subscribers = new Set();
+let snapshot = { phase: "loading" };
+let inFlight = null;
+function publish(next) {
+    snapshot = next;
+    for (const subscriber of subscribers)
+        subscriber(next);
+}
+async function refresh() {
+    if (inFlight)
+        return inFlight;
+    inFlight = fetchRuntimeModeSnapshot()
+        .then((result) => {
+        publish(result === null
+            ? { phase: "unavailable" }
+            : { phase: "ready", snapshot: result });
+    })
+        .finally(() => {
+        inFlight = null;
+    });
+    return inFlight;
+}
+/**
+ * Test-only escape hatch — clears the module-scope cache so a hook test
+ * can verify the second mount short-circuits the network call. Not
+ * exported from the package barrel.
+ */
+export function __resetRuntimeModeCacheForTests() {
+    snapshot = { phase: "loading" };
+    inFlight = null;
+}
+export function useRuntimeMode() {
+    const [state, setState] = useState(snapshot);
+    const mountedRef = useRef(true);
+    const refetch = useCallback(() => {
+        if (!mountedRef.current)
+            return;
+        void refresh();
+    }, []);
+    useEffect(() => {
+        mountedRef.current = true;
+        subscribers.add(setState);
+        setState(snapshot);
+        if (snapshot.phase === "loading")
+            void refresh();
+        return () => {
+            mountedRef.current = false;
+            subscribers.delete(setState);
+        };
+    }, []);
+    const mode = state.phase === "ready" ? state.snapshot.mode : null;
+    return {
+        state,
+        mode,
+        isLocalOnly: mode === "local" || mode === "local-only",
+        isCloudMode: mode === "cloud",
+        isRemoteMode: mode === "remote",
+        refetch,
+    };
+}

package/hooks/useSecretsManagerModal.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Global open/close state for the Vault modal.
+ *
+ * Backed by `window.dispatchEvent` rather than a React context so any
+ * code path (renderer keydown, bun-side menu accelerator dispatched
+ * via `subscribeDesktopBridgeEvent`, an inline Settings launcher
+ * button) can trigger open/close without context plumbing through the
+ * tree.
+ *
+ * The dispatch contract carries an optional initial tab plus optional
+ * focus targets so cross-tab jumps (e.g. Routing rule chip → Secrets
+ * tab pre-expanded on a key) can be parameterized through the same
+ * event.
+ */
+export type VaultTab = "overview" | "secrets" | "logins" | "routing";
+export declare const VAULT_TABS: readonly VaultTab[];
+export interface SecretsManagerOpenOptions {
+    readonly tab?: VaultTab;
+    readonly focusKey?: string;
+    readonly focusProfileId?: string;
+}
+export declare function dispatchSecretsManagerOpen(options?: SecretsManagerOpenOptions): void;
+export declare function dispatchSecretsManagerClose(): void;
+export declare function dispatchSecretsManagerToggle(tab?: VaultTab): void;
+export interface SecretsManagerModalState {
+    readonly isOpen: boolean;
+    readonly initialTab: VaultTab | null;
+    readonly focusKey: string | null;
+    readonly focusProfileId: string | null;
+    readonly open: () => void;
+    readonly close: () => void;
+    readonly toggle: () => void;
+    readonly setOpen: (next: boolean) => void;
+    readonly openOnTab: (options: SecretsManagerOpenOptions) => void;
+    readonly clearFocus: () => void;
+}
+/**
+ * Subscribe to the modal's open state. Useful for the modal itself
+ * (it must mount its content based on this flag) and for the inline
+ * launcher row (so it can optionally show "Manage…" disabled while
+ * the modal is open).
+ *
+ * `initialTab` / `focusKey` / `focusProfileId` carry the parameters of
+ * the most recent open dispatch. The modal consumes them on mount and
+ * is expected to call `clearFocus()` once the focus has been applied so
+ * subsequent opens (e.g. via the keyboard shortcut) start fresh.
+ */
+export declare function useSecretsManagerModalState(): SecretsManagerModalState;
+//# sourceMappingURL=useSecretsManagerModal.d.ts.map

package/hooks/useSecretsManagerModal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useSecretsManagerModal.d.ts","sourceRoot":"","sources":["../../../../../src/hooks/useSecretsManagerModal.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;GAaG;AAEH,MAAM,MAAM,QAAQ,GAAG,UAAU,GAAG,SAAS,GAAG,QAAQ,GAAG,SAAS,CAAC;AAErE,eAAO,MAAM,UAAU,EAAE,SAAS,QAAQ,EAKhC,CAAC;AAsBX,MAAM,WAAW,yBAAyB;IACxC,QAAQ,CAAC,GAAG,CAAC,EAAE,QAAQ,CAAC;IACxB,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,cAAc,CAAC,EAAE,MAAM,CAAC;CAClC;AAED,wBAAgB,0BAA0B,CACxC,OAAO,GAAE,yBAA8B,GACtC,IAAI,CAON;AAED,wBAAgB,2BAA2B,IAAI,IAAI,CAKlD;AAED,wBAAgB,4BAA4B,CAAC,GAAG,CAAC,EAAE,QAAQ,GAAG,IAAI,CAOjE;AAED,MAAM,WAAW,wBAAwB;IACvC,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;IACzB,QAAQ,CAAC,UAAU,EAAE,QAAQ,GAAG,IAAI,CAAC;IACrC,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACjC,QAAQ,CAAC,cAAc,EAAE,MAAM,GAAG,IAAI,CAAC;IACvC,QAAQ,CAAC,IAAI,EAAE,MAAM,IAAI,CAAC;IAC1B,QAAQ,CAAC,KAAK,EAAE,MAAM,IAAI,CAAC;IAC3B,QAAQ,CAAC,MAAM,EAAE,MAAM,IAAI,CAAC;IAC5B,QAAQ,CAAC,OAAO,EAAE,CAAC,IAAI,EAAE,OAAO,KAAK,IAAI,CAAC;IAC1C,QAAQ,CAAC,SAAS,EAAE,CAAC,OAAO,EAAE,yBAAyB,KAAK,IAAI,CAAC;IACjE,QAAQ,CAAC,UAAU,EAAE,MAAM,IAAI,CAAC;CACjC;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,2BAA2B,IAAI,wBAAwB,CA6DtE"}

package/hooks/useSecretsManagerModal.js

@@ -0,0 +1,101 @@
+import { useCallback, useEffect, useState } from "react";
+export const VAULT_TABS = [
+    "overview",
+    "secrets",
+    "logins",
+    "routing",
+];
+const EVENT_NAME = "eliza:secrets-manager-toggle";
+export function dispatchSecretsManagerOpen(options = {}) {
+    if (typeof window === "undefined")
+        return;
+    window.dispatchEvent(new CustomEvent(EVENT_NAME, {
+        detail: { action: "open", ...options },
+    }));
+}
+export function dispatchSecretsManagerClose() {
+    if (typeof window === "undefined")
+        return;
+    window.dispatchEvent(new CustomEvent(EVENT_NAME, { detail: { action: "close" } }));
+}
+export function dispatchSecretsManagerToggle(tab) {
+    if (typeof window === "undefined")
+        return;
+    window.dispatchEvent(new CustomEvent(EVENT_NAME, {
+        detail: tab ? { action: "toggle", tab } : { action: "toggle" },
+    }));
+}
+/**
+ * Subscribe to the modal's open state. Useful for the modal itself
+ * (it must mount its content based on this flag) and for the inline
+ * launcher row (so it can optionally show "Manage…" disabled while
+ * the modal is open).
+ *
+ * `initialTab` / `focusKey` / `focusProfileId` carry the parameters of
+ * the most recent open dispatch. The modal consumes them on mount and
+ * is expected to call `clearFocus()` once the focus has been applied so
+ * subsequent opens (e.g. via the keyboard shortcut) start fresh.
+ */
+export function useSecretsManagerModalState() {
+    const [isOpen, setIsOpen] = useState(false);
+    const [initialTab, setInitialTab] = useState(null);
+    const [focusKey, setFocusKey] = useState(null);
+    const [focusProfileId, setFocusProfileId] = useState(null);
+    useEffect(() => {
+        if (typeof window === "undefined")
+            return;
+        const onToggle = (event) => {
+            const detail = event.detail;
+            if (!detail)
+                return;
+            if (detail.action === "open") {
+                setIsOpen(true);
+                setInitialTab(detail.tab ?? null);
+                setFocusKey(detail.focusKey ?? null);
+                setFocusProfileId(detail.focusProfileId ?? null);
+                return;
+            }
+            if (detail.action === "close") {
+                setIsOpen(false);
+                return;
+            }
+            // toggle
+            setIsOpen((prev) => {
+                if (!prev && detail.tab)
+                    setInitialTab(detail.tab);
+                return !prev;
+            });
+        };
+        window.addEventListener(EVENT_NAME, onToggle);
+        return () => {
+            window.removeEventListener(EVENT_NAME, onToggle);
+        };
+    }, []);
+    const open = useCallback(() => setIsOpen(true), []);
+    const close = useCallback(() => setIsOpen(false), []);
+    const toggle = useCallback(() => setIsOpen((prev) => !prev), []);
+    const setOpen = useCallback((next) => setIsOpen(next), []);
+    const openOnTab = useCallback((options) => {
+        setIsOpen(true);
+        setInitialTab(options.tab ?? null);
+        setFocusKey(options.focusKey ?? null);
+        setFocusProfileId(options.focusProfileId ?? null);
+    }, []);
+    const clearFocus = useCallback(() => {
+        setInitialTab(null);
+        setFocusKey(null);
+        setFocusProfileId(null);
+    }, []);
+    return {
+        isOpen,
+        initialTab,
+        focusKey,
+        focusProfileId,
+        open,
+        close,
+        toggle,
+        setOpen,
+        openOnTab,
+        clearFocus,
+    };
+}

package/hooks/useSecretsManagerShortcut.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Wires the keyboard / menu triggers for the Secrets Manager modal.
+ *
+ * Two trigger paths feed the same open action:
+ *
+ *   1. **Renderer-side keyboard chord** — caught by a `keydown`
+ *      listener on `document`. Handles every Eliza window.
+ *      Mac default: ⌘⌥⌃V (Command + Option + Control + V)
+ *      Win/Linux:   Ctrl + Alt + Shift + V
+ *
+ *   2. **Application menu accelerator** — Electrobun's bun-side menu
+ *      registers an item with the same accelerator. When the user
+ *      hits the chord, bun fires `application-menu-clicked` with
+ *      action `"open-secrets-manager"`, the bun handler turns that
+ *      into `sendToActiveRenderer("openSecretsManager", {})`, and
+ *      this hook subscribes to receive it. Both routes converge on
+ *      the same toggle dispatch.
+ *
+ * Mount this hook ONCE in the top-level App component alongside the
+ * `<SecretsManagerModalRoot />` mount.
+ */
+export declare function useSecretsManagerShortcut(): void;
+/**
+ * Detects the Secrets-Manager shortcut. Per-platform mapping:
+ *   - macOS (`navigator.platform.includes("Mac")`):
+ *       metaKey (⌘) + altKey (⌥) + ctrlKey (⌃) + key === "v"
+ *   - Otherwise:
+ *       ctrlKey + altKey + shiftKey + key === "v"
+ */
+export declare function matchesShortcut(event: KeyboardEvent): boolean;
+/** Human-readable label for the shortcut, suitable for UI hints. */
+export declare function getShortcutLabel(): string;
+/** Electron-style accelerator string for the menu item. */
+export declare const SECRETS_MANAGER_MAC_ACCELERATOR = "Command+Option+Control+V";
+export declare const SECRETS_MANAGER_OTHER_ACCELERATOR = "Ctrl+Alt+Shift+V";
+//# sourceMappingURL=useSecretsManagerShortcut.d.ts.map

package/hooks/useSecretsManagerShortcut.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useSecretsManagerShortcut.d.ts","sourceRoot":"","sources":["../../../../../src/hooks/useSecretsManagerShortcut.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,yBAAyB,IAAI,IAAI,CA2BhD;AAED;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,aAAa,GAAG,OAAO,CAS7D;AAED,oEAAoE;AACpE,wBAAgB,gBAAgB,IAAI,MAAM,CAKzC;AAED,2DAA2D;AAC3D,eAAO,MAAM,+BAA+B,6BAA6B,CAAC;AAC1E,eAAO,MAAM,iCAAiC,qBAAqB,CAAC"}

package/hooks/useSecretsManagerShortcut.js

@@ -0,0 +1,80 @@
+import { useEffect } from "react";
+import { subscribeDesktopBridgeEvent } from "../bridge/electrobun-rpc.js";
+import { dispatchSecretsManagerOpen } from "./useSecretsManagerModal.js";
+/**
+ * Wires the keyboard / menu triggers for the Secrets Manager modal.
+ *
+ * Two trigger paths feed the same open action:
+ *
+ *   1. **Renderer-side keyboard chord** — caught by a `keydown`
+ *      listener on `document`. Handles every Eliza window.
+ *      Mac default: ⌘⌥⌃V (Command + Option + Control + V)
+ *      Win/Linux:   Ctrl + Alt + Shift + V
+ *
+ *   2. **Application menu accelerator** — Electrobun's bun-side menu
+ *      registers an item with the same accelerator. When the user
+ *      hits the chord, bun fires `application-menu-clicked` with
+ *      action `"open-secrets-manager"`, the bun handler turns that
+ *      into `sendToActiveRenderer("openSecretsManager", {})`, and
+ *      this hook subscribes to receive it. Both routes converge on
+ *      the same toggle dispatch.
+ *
+ * Mount this hook ONCE in the top-level App component alongside the
+ * `<SecretsManagerModalRoot />` mount.
+ */
+export function useSecretsManagerShortcut() {
+    // Renderer-side keydown
+    useEffect(() => {
+        if (typeof window === "undefined")
+            return;
+        const onKeyDown = (event) => {
+            if (event.repeat)
+                return;
+            if (!matchesShortcut(event))
+                return;
+            event.preventDefault();
+            event.stopPropagation();
+            dispatchSecretsManagerOpen();
+        };
+        window.addEventListener("keydown", onKeyDown, { capture: true });
+        return () => {
+            window.removeEventListener("keydown", onKeyDown, { capture: true });
+        };
+    }, []);
+    // Bun-side menu accelerator route
+    useEffect(() => {
+        return subscribeDesktopBridgeEvent({
+            rpcMessage: "openSecretsManager",
+            ipcChannel: "desktop:openSecretsManager",
+            listener: () => {
+                dispatchSecretsManagerOpen();
+            },
+        });
+    }, []);
+}
+/**
+ * Detects the Secrets-Manager shortcut. Per-platform mapping:
+ *   - macOS (`navigator.platform.includes("Mac")`):
+ *       metaKey (⌘) + altKey (⌥) + ctrlKey (⌃) + key === "v"
+ *   - Otherwise:
+ *       ctrlKey + altKey + shiftKey + key === "v"
+ */
+export function matchesShortcut(event) {
+    if (event.key.toLowerCase() !== "v" && event.code !== "KeyV")
+        return false;
+    const isMac = typeof navigator !== "undefined" &&
+        /Mac|iPhone|iPad|iPod/i.test(navigator.platform);
+    if (isMac) {
+        return event.metaKey && event.altKey && event.ctrlKey && !event.shiftKey;
+    }
+    return event.ctrlKey && event.altKey && event.shiftKey && !event.metaKey;
+}
+/** Human-readable label for the shortcut, suitable for UI hints. */
+export function getShortcutLabel() {
+    const isMac = typeof navigator !== "undefined" &&
+        /Mac|iPhone|iPad|iPod/i.test(navigator.platform);
+    return isMac ? "⌘⌥⌃V" : "Ctrl+Alt+Shift+V";
+}
+/** Electron-style accelerator string for the menu item. */
+export const SECRETS_MANAGER_MAC_ACCELERATOR = "Command+Option+Control+V";
+export const SECRETS_MANAGER_OTHER_ACCELERATOR = "Ctrl+Alt+Shift+V";

package/hooks/useSignalPairing.d.ts

@@ -0,0 +1,12 @@
+export type { SignalPairingStatus } from "../api/client-types-core";
+import type { SignalPairingStatus } from "../api/client-types-core";
+export declare function useSignalPairing(accountId?: string): {
+    startPairing: () => Promise<void>;
+    stopPairing: () => Promise<void>;
+    disconnect: () => Promise<void>;
+    status: SignalPairingStatus;
+    qrDataUrl: string | null;
+    phoneNumber: string | null;
+    error: string | null;
+};
+//# sourceMappingURL=useSignalPairing.d.ts.map

package/hooks/useSignalPairing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useSignalPairing.d.ts","sourceRoot":"","sources":["../../../../../src/hooks/useSignalPairing.ts"],"names":[],"mappings":"AAIA,YAAY,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAC;AAEpE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAC;AAqCpE,wBAAgB,gBAAgB,CAAC,SAAS,SAA+B;;;;YAlC/D,mBAAmB;eAChB,MAAM,GAAG,IAAI;iBACX,MAAM,GAAG,IAAI;WACnB,MAAM,GAAG,IAAI;EAsJrB"}

package/hooks/useSignalPairing.js

@@ -0,0 +1,130 @@
+import { useCallback, useEffect, useState } from "react";
+import { client } from "../api/client.js";
+import { DEFAULT_CONNECTOR_ACCOUNT_ID } from "./useConnectorAccounts.js";
+const IDLE_SIGNAL_PAIRING_STATE = {
+    status: "idle",
+    qrDataUrl: null,
+    phoneNumber: null,
+    error: null,
+};
+function stateFromStatusResponse(response) {
+    return {
+        status: response.status,
+        qrDataUrl: response.qrDataUrl,
+        phoneNumber: response.phoneNumber,
+        error: response.error,
+    };
+}
+function toSignalPairingErrorState(error) {
+    return {
+        ...IDLE_SIGNAL_PAIRING_STATE,
+        status: "error",
+        error: error instanceof Error ? error.message : String(error),
+    };
+}
+export function useSignalPairing(accountId = DEFAULT_CONNECTOR_ACCOUNT_ID) {
+    const [state, setState] = useState(IDLE_SIGNAL_PAIRING_STATE);
+    useEffect(() => {
+        let cancelled = false;
+        void client
+            .getSignalStatus(accountId)
+            .then((response) => {
+            if (cancelled) {
+                return;
+            }
+            setState(stateFromStatusResponse(response));
+        })
+            .catch((error) => {
+            if (cancelled) {
+                return;
+            }
+            setState(toSignalPairingErrorState(error));
+        });
+        return () => {
+            cancelled = true;
+        };
+    }, [accountId]);
+    useEffect(() => {
+        const unbindQr = client.onWsEvent("signal-qr", (data) => {
+            if (data.accountId !== accountId)
+                return;
+            setState((prev) => ({
+                ...prev,
+                status: "waiting_for_qr",
+                qrDataUrl: data.qrDataUrl ?? null,
+                error: null,
+            }));
+        });
+        const unbindStatus = client.onWsEvent("signal-status", (data) => {
+            if (data.accountId !== accountId)
+                return;
+            const nextStatus = data.status;
+            const clearQrDataUrl = nextStatus === "connected" ||
+                nextStatus === "disconnected" ||
+                nextStatus === "timeout" ||
+                nextStatus === "error";
+            setState((prev) => ({
+                ...prev,
+                status: nextStatus,
+                phoneNumber: data.phoneNumber ?? prev.phoneNumber,
+                error: data.error ?? null,
+                qrDataUrl: clearQrDataUrl ? null : prev.qrDataUrl,
+            }));
+        });
+        return () => {
+            unbindQr();
+            unbindStatus();
+        };
+    }, [accountId]);
+    const startPairing = useCallback(async () => {
+        setState({
+            status: "initializing",
+            qrDataUrl: null,
+            phoneNumber: null,
+            error: null,
+        });
+        try {
+            const result = await client.startSignalPairing(accountId);
+            if (result.ok) {
+                setState((prev) => ({
+                    ...prev,
+                    status: result.status,
+                    error: null,
+                }));
+            }
+            else {
+                setState((prev) => ({
+                    ...prev,
+                    status: "error",
+                    error: result.error ?? "Failed to start Signal pairing",
+                }));
+            }
+        }
+        catch (error) {
+            setState((prev) => ({
+                ...prev,
+                status: "error",
+                error: error instanceof Error ? error.message : String(error),
+            }));
+        }
+    }, [accountId]);
+    const stopPairing = useCallback(async () => {
+        try {
+            await client.stopSignalPairing(accountId);
+            setState(IDLE_SIGNAL_PAIRING_STATE);
+        }
+        catch (error) {
+            setState(toSignalPairingErrorState(error));
+        }
+    }, [accountId]);
+    const disconnect = useCallback(async () => {
+        try {
+            await client.disconnectSignal(accountId);
+            setState(IDLE_SIGNAL_PAIRING_STATE);
+        }
+        catch (error) {
+            setState(toSignalPairingErrorState(error));
+        }
+    }, [accountId]);
+    return { ...state, startPairing, stopPairing, disconnect };
+}

package/hooks/useStreamPopoutNavigation.d.ts

@@ -0,0 +1,3 @@
+export declare function getNextTabForStreamPopoutEvent<TTab extends string>(_detail: unknown): TTab | null;
+export declare function useStreamPopoutNavigation<TTab extends string>(_setTab: (tab: TTab) => void): void;
+//# sourceMappingURL=useStreamPopoutNavigation.d.ts.map

package/hooks/useStreamPopoutNavigation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useStreamPopoutNavigation.d.ts","sourceRoot":"","sources":["../../../../../src/hooks/useStreamPopoutNavigation.ts"],"names":[],"mappings":"AAAA,wBAAgB,8BAA8B,CAAC,IAAI,SAAS,MAAM,EAChE,OAAO,EAAE,OAAO,GACf,IAAI,GAAG,IAAI,CAEb;AAED,wBAAgB,yBAAyB,CAAC,IAAI,SAAS,MAAM,EAC3D,OAAO,EAAE,CAAC,GAAG,EAAE,IAAI,KAAK,IAAI,GAC3B,IAAI,CAAG"}

package/hooks/useStreamPopoutNavigation.js

@@ -0,0 +1,4 @@
+export function getNextTabForStreamPopoutEvent(_detail) {
+    return null;
+}
+export function useStreamPopoutNavigation(_setTab) { }

package/hooks/useTimeout.d.ts

@@ -0,0 +1,5 @@
+export declare function useTimeout(): {
+    setTimeout: (callback: () => void, ms: number) => NodeJS.Timeout;
+    clearTimeout: (id: ReturnType<typeof setTimeout>) => void;
+};
+//# sourceMappingURL=useTimeout.d.ts.map

package/hooks/useTimeout.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useTimeout.d.ts","sourceRoot":"","sources":["../../../../../src/hooks/useTimeout.ts"],"names":[],"mappings":"AAEA,wBAAgB,UAAU;2BAGsB,MAAM,IAAI,MAAM,MAAM;uBAS1B,UAAU,CAAC,OAAO,UAAU,CAAC;EAgBxE"}

package/hooks/useTimeout.js

@@ -0,0 +1,26 @@
+import { useCallback, useEffect, useRef } from "react";
+export function useTimeout() {
+    const timeoutRefs = useRef(new Set());
+    const setSafeTimeout = useCallback((callback, ms) => {
+        const id = setTimeout(() => {
+            timeoutRefs.current.delete(id);
+            callback();
+        }, ms);
+        timeoutRefs.current.add(id);
+        return id;
+    }, []);
+    const clearSafeTimeout = useCallback((id) => {
+        clearTimeout(id);
+        timeoutRefs.current.delete(id);
+    }, []);
+    useEffect(() => {
+        const refs = timeoutRefs;
+        return () => {
+            for (const id of refs.current) {
+                clearTimeout(id);
+            }
+            refs.current.clear();
+        };
+    }, []);
+    return { setTimeout: setSafeTimeout, clearTimeout: clearSafeTimeout };
+}

package/hooks/useVoiceChat.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Bidirectional voice hook for chat + avatar lip sync.
+ *
+ * TTS providers (in priority order):
+ *  1. ElevenLabs  — streaming endpoint; assistant replies enqueue text deltas as
+ *     the stream grows (no sentence-boundary wait — lower time-to-first-audio).
+ *  2. Browser SpeechSynthesis — fallback when ElevenLabs isn't configured.
+ *
+ * STT: Web Speech API (SpeechRecognition) for user voice input.
+ */
+import { queueableSpeechPrefix, remainderAfter, splitFirstSentence, toSpeakableText } from "../voice/voice-chat-playback";
+import { mergeTranscriptWindows } from "../voice/voice-chat-recording";
+import { resolveEffectiveVoiceConfig, resolveVoiceMode, resolveVoiceProxyEndpoint, type VoiceChatOptions, type VoiceChatState, webSpeechVoiceDebugFields } from "../voice/voice-chat-types";
+export { nextIdleMouthOpen } from "../voice/voice-chat-playback";
+export type { VoiceCaptureMode, VoiceChatOptions, VoiceChatState, VoicePlaybackStartEvent, VoiceTranscriptPreviewEvent, } from "../voice/voice-chat-types";
+declare function shouldPreferNativeTalkMode(): boolean;
+declare function isWindowsElectrobunRenderer(): boolean;
+declare function shouldAutoRestartBrowserRecognition(): boolean;
+export declare const __voiceChatInternals: {
+    isWindowsElectrobunRenderer: typeof isWindowsElectrobunRenderer;
+    shouldPreferNativeTalkMode: typeof shouldPreferNativeTalkMode;
+    shouldAutoRestartBrowserRecognition: typeof shouldAutoRestartBrowserRecognition;
+    splitFirstSentence: typeof splitFirstSentence;
+    remainderAfter: typeof remainderAfter;
+    queueableSpeechPrefix: typeof queueableSpeechPrefix;
+    resolveEffectiveVoiceConfig: typeof resolveEffectiveVoiceConfig;
+    resolveVoiceMode: typeof resolveVoiceMode;
+    resolveVoiceProxyEndpoint: typeof resolveVoiceProxyEndpoint;
+    toSpeakableText: typeof toSpeakableText;
+    mergeTranscriptWindows: typeof mergeTranscriptWindows;
+    webSpeechVoiceDebugFields: typeof webSpeechVoiceDebugFields;
+    ASSISTANT_TTS_FINAL_ONLY: boolean;
+    ASSISTANT_TTS_FIRST_FLUSH_CHARS: number;
+    ASSISTANT_TTS_MIN_CHUNK_CHARS: number;
+};
+export declare function useVoiceChat(options: VoiceChatOptions): VoiceChatState;
+//# sourceMappingURL=useVoiceChat.d.ts.map

package/hooks/useVoiceChat.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useVoiceChat.d.ts","sourceRoot":"","sources":["../../../../../src/hooks/useVoiceChat.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAgCH,OAAO,EAKL,qBAAqB,EACrB,cAAc,EACd,kBAAkB,EAClB,eAAe,EAChB,MAAM,8BAA8B,CAAC;AACtC,OAAO,EAAE,sBAAsB,EAAE,MAAM,+BAA+B,CAAC;AACvE,OAAO,EAgBL,2BAA2B,EAC3B,gBAAgB,EAChB,yBAAyB,EAOzB,KAAK,gBAAgB,EACrB,KAAK,cAAc,EAGnB,yBAAyB,EAC1B,MAAM,2BAA2B,CAAC;AAInC,OAAO,EAAE,iBAAiB,EAAE,MAAM,8BAA8B,CAAC;AACjE,YAAY,EACV,gBAAgB,EAChB,gBAAgB,EAChB,cAAc,EACd,uBAAuB,EACvB,2BAA2B,GAC5B,MAAM,2BAA2B,CAAC;AAQnC,iBAAS,0BAA0B,IAAI,OAAO,CAG7C;AAED,iBAAS,2BAA2B,IAAI,OAAO,CAO9C;AAED,iBAAS,mCAAmC,IAAI,OAAO,CAMtD;AAID,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;CAgBhC,CAAC;AAIF,wBAAgB,YAAY,CAAC,OAAO,EAAE,gBAAgB,GAAG,cAAc,CAi+CtE"}