@elizaos/app-core 2.0.0-alpha.73 → 2.0.0-alpha.75

package/hooks/useChatAvatarVoice.d.ts

@@ -0,0 +1,10 @@
+import { type ChatAvatarVoiceEventDetail } from "../events";
+export interface ChatAvatarVoiceBridgeOptions {
+    mouthOpen: number;
+    isSpeaking: boolean;
+    usingAudioAnalysis?: boolean;
+    onSpeakingChange?: (isSpeaking: boolean) => void;
+}
+export declare function useChatAvatarVoiceBridge({ mouthOpen, isSpeaking, usingAudioAnalysis, onSpeakingChange, }: ChatAvatarVoiceBridgeOptions): void;
+export declare function useChatAvatarVoiceState(): ChatAvatarVoiceEventDetail;
+//# sourceMappingURL=useChatAvatarVoice.d.ts.map

package/hooks/useChatAvatarVoice.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useChatAvatarVoice.d.ts","sourceRoot":"","sources":["../../src/hooks/useChatAvatarVoice.ts"],"names":[],"mappings":"AACA,OAAO,EAEL,KAAK,0BAA0B,EAEhC,MAAM,WAAW,CAAC;AAiCnB,MAAM,WAAW,4BAA4B;IAC3C,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,OAAO,CAAC;IACpB,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAC7B,gBAAgB,CAAC,EAAE,CAAC,UAAU,EAAE,OAAO,KAAK,IAAI,CAAC;CAClD;AAED,wBAAgB,wBAAwB,CAAC,EACvC,SAAS,EACT,UAAU,EACV,kBAA0B,EAC1B,gBAAgB,GACjB,EAAE,4BAA4B,GAAG,IAAI,CAiCrC;AAED,wBAAgB,uBAAuB,IAAI,0BAA0B,CAyBpE"}

package/hooks/useChatAvatarVoice.js

@@ -0,0 +1,71 @@
+import { useEffect, useEffectEvent, useRef, useState } from "react";
+import { CHAT_AVATAR_VOICE_EVENT, dispatchWindowEvent, } from "../events";
+const CHAT_AVATAR_MOUTH_STEP = 0.02;
+const CHAT_AVATAR_SILENCE = {
+    mouthOpen: 0,
+    isSpeaking: false,
+};
+function normalizeMouthOpen(value) {
+    const clamped = Math.max(0, Math.min(1, value ?? 0));
+    const stepped = Math.round(clamped / CHAT_AVATAR_MOUTH_STEP) * CHAT_AVATAR_MOUTH_STEP;
+    return stepped < CHAT_AVATAR_MOUTH_STEP ? 0 : Math.min(1, stepped);
+}
+function normalizeChatAvatarVoice(value) {
+    return {
+        mouthOpen: normalizeMouthOpen(value?.mouthOpen),
+        isSpeaking: value?.isSpeaking === true,
+    };
+}
+function isSameChatAvatarVoice(left, right) {
+    return (left.isSpeaking === right.isSpeaking && left.mouthOpen === right.mouthOpen);
+}
+export function useChatAvatarVoiceBridge({ mouthOpen, isSpeaking, usingAudioAnalysis = false, onSpeakingChange, }) {
+    const voice = normalizeChatAvatarVoice({
+        mouthOpen,
+        isSpeaking: isSpeaking && !usingAudioAnalysis,
+    });
+    const lastVoiceRef = useRef(CHAT_AVATAR_SILENCE);
+    const emitSpeakingChange = useEffectEvent((nextIsSpeaking) => {
+        onSpeakingChange?.(nextIsSpeaking);
+    });
+    useEffect(() => {
+        if (lastVoiceRef.current.isSpeaking !== voice.isSpeaking) {
+            emitSpeakingChange(voice.isSpeaking);
+        }
+        if (isSameChatAvatarVoice(lastVoiceRef.current, voice)) {
+            return;
+        }
+        lastVoiceRef.current = voice;
+        dispatchWindowEvent(CHAT_AVATAR_VOICE_EVENT, voice);
+    }, [voice]);
+    useEffect(() => {
+        return () => {
+            if (lastVoiceRef.current.isSpeaking) {
+                emitSpeakingChange(false);
+            }
+            if (isSameChatAvatarVoice(lastVoiceRef.current, CHAT_AVATAR_SILENCE)) {
+                return;
+            }
+            lastVoiceRef.current = CHAT_AVATAR_SILENCE;
+            dispatchWindowEvent(CHAT_AVATAR_VOICE_EVENT, CHAT_AVATAR_SILENCE);
+        };
+    }, []);
+}
+export function useChatAvatarVoiceState() {
+    const [voice, setVoice] = useState(CHAT_AVATAR_SILENCE);
+    useEffect(() => {
+        if (typeof window === "undefined") {
+            return;
+        }
+        const handleVoiceEvent = (event) => {
+            const detail = event.detail;
+            const nextVoice = normalizeChatAvatarVoice(detail);
+            setVoice((previousVoice) => isSameChatAvatarVoice(previousVoice, nextVoice)
+                ? previousVoice
+                : nextVoice);
+        };
+        window.addEventListener(CHAT_AVATAR_VOICE_EVENT, handleVoiceEvent);
+        return () => window.removeEventListener(CHAT_AVATAR_VOICE_EVENT, handleVoiceEvent);
+    }, []);
+    return voice;
+}

package/hooks/useClickOutside.d.ts

@@ -0,0 +1,6 @@
+import { type RefObject } from "react";
+/**
+ * Calls `handler` when a click lands outside `ref.current` or Escape is pressed.
+ */
+export declare function useClickOutside(ref: RefObject<HTMLElement | null>, handler: () => void, active?: boolean): void;
+//# sourceMappingURL=useClickOutside.d.ts.map

package/hooks/useClickOutside.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useClickOutside.d.ts","sourceRoot":"","sources":["../../src/hooks/useClickOutside.ts"],"names":[],"mappings":"AAAA,OAAO,EAAa,KAAK,SAAS,EAAE,MAAM,OAAO,CAAC;AAElD;;GAEG;AACH,wBAAgB,eAAe,CAC7B,GAAG,EAAE,SAAS,CAAC,WAAW,GAAG,IAAI,CAAC,EAClC,OAAO,EAAE,MAAM,IAAI,EACnB,MAAM,UAAO,QAsBd"}

package/hooks/useClickOutside.js

@@ -0,0 +1,25 @@
+import { useEffect } from "react";
+/**
+ * Calls `handler` when a click lands outside `ref.current` or Escape is pressed.
+ */
+export function useClickOutside(ref, handler, active = true) {
+    useEffect(() => {
+        if (!active)
+            return;
+        const onMouseDown = (e) => {
+            if (ref.current && !ref.current.contains(e.target)) {
+                handler();
+            }
+        };
+        const onKeyDown = (e) => {
+            if (e.key === "Escape")
+                handler();
+        };
+        document.addEventListener("mousedown", onMouseDown);
+        document.addEventListener("keydown", onKeyDown);
+        return () => {
+            document.removeEventListener("mousedown", onMouseDown);
+            document.removeEventListener("keydown", onKeyDown);
+        };
+    }, [ref, handler, active]);
+}

package/hooks/useContextMenu.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Listens for native desktop context-menu events
+ * and dispatches actions into the app state.
+ */
+import { type SavedCustomCommand } from "../chat";
+export type CustomCommand = SavedCustomCommand;
+/** Read saved custom commands from localStorage. */
+export declare function loadCustomCommands(): CustomCommand[];
+export interface ContextMenuState {
+    saveCommandModalOpen: boolean;
+    saveCommandText: string;
+    customCommands: CustomCommand[];
+    closeSaveCommandModal: () => void;
+    confirmSaveCommand: (name: string) => void;
+}
+export declare function useContextMenu(): ContextMenuState;
+//# sourceMappingURL=useContextMenu.d.ts.map

package/hooks/useContextMenu.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useContextMenu.d.ts","sourceRoot":"","sources":["../../src/hooks/useContextMenu.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAIH,OAAO,EAGL,KAAK,kBAAkB,EACxB,MAAM,SAAS,CAAC;AAGjB,MAAM,MAAM,aAAa,GAAG,kBAAkB,CAAC;AAE/C,oDAAoD;AACpD,wBAAgB,kBAAkB,IAAI,aAAa,EAAE,CAEpD;AAED,MAAM,WAAW,gBAAgB;IAC/B,oBAAoB,EAAE,OAAO,CAAC;IAC9B,eAAe,EAAE,MAAM,CAAC;IACxB,cAAc,EAAE,aAAa,EAAE,CAAC;IAChC,qBAAqB,EAAE,MAAM,IAAI,CAAC;IAClC,kBAAkB,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;CAC5C;AAED,wBAAgB,cAAc,IAAI,gBAAgB,CAiGjD"}

package/hooks/useContextMenu.js

@@ -0,0 +1,100 @@
+/**
+ * Listens for native desktop context-menu events
+ * and dispatches actions into the app state.
+ */
+import { useCallback, useEffect, useState } from "react";
+import { subscribeDesktopBridgeEvent } from "../bridge";
+import { appendSavedCustomCommand, loadSavedCustomCommands, } from "../chat";
+import { useApp } from "../state/useApp";
+/** Read saved custom commands from localStorage. */
+export function loadCustomCommands() {
+    return loadSavedCustomCommands();
+}
+export function useContextMenu() {
+    const { setState, chatInput, handleChatSend, setActionNotice } = useApp();
+    const [saveCommandModalOpen, setSaveCommandModalOpen] = useState(false);
+    const [saveCommandText, setSaveCommandText] = useState("");
+    const [customCommands, setCustomCommands] = useState(loadCustomCommands);
+    useEffect(() => {
+        const onSaveAsCommand = (payload) => {
+            const command = payload;
+            if (!command?.text)
+                return;
+            setSaveCommandText(command.text);
+            setSaveCommandModalOpen(true);
+        };
+        const onAskAgent = (payload) => {
+            const command = payload;
+            if (!command?.text)
+                return;
+            setState("chatInput", command.text);
+            // Defer send to next tick so chatInput state propagates
+            setTimeout(() => handleChatSend(), 0);
+        };
+        const onCreateSkill = (payload) => {
+            const command = payload;
+            if (!command?.text)
+                return;
+            const prompt = `Create a skill from the following content:\n\n"""${command.text}"""\n\nAnalyze this and create a reusable skill.`;
+            setState("chatInput", prompt);
+            setTimeout(() => handleChatSend(), 0);
+        };
+        const onQuoteInChat = (payload) => {
+            const command = payload;
+            if (!command?.text)
+                return;
+            const quoted = `> ${command.text}\n\n`;
+            setState("chatInput", quoted + chatInput);
+        };
+        const unsubscribers = [
+            subscribeDesktopBridgeEvent({
+                rpcMessage: "contextMenuSaveAsCommand",
+                ipcChannel: "contextMenu:saveAsCommand",
+                listener: onSaveAsCommand,
+            }),
+            subscribeDesktopBridgeEvent({
+                rpcMessage: "contextMenuAskAgent",
+                ipcChannel: "contextMenu:askAgent",
+                listener: onAskAgent,
+            }),
+            subscribeDesktopBridgeEvent({
+                rpcMessage: "contextMenuCreateSkill",
+                ipcChannel: "contextMenu:createSkill",
+                listener: onCreateSkill,
+            }),
+            subscribeDesktopBridgeEvent({
+                rpcMessage: "contextMenuQuoteInChat",
+                ipcChannel: "contextMenu:quoteInChat",
+                listener: onQuoteInChat,
+            }),
+        ];
+        return () => {
+            for (const unsubscribe of unsubscribers) {
+                unsubscribe();
+            }
+        };
+    }, [setState, chatInput, handleChatSend]);
+    const closeSaveCommandModal = useCallback(() => {
+        setSaveCommandModalOpen(false);
+        setSaveCommandText("");
+    }, []);
+    const confirmSaveCommand = useCallback((name) => {
+        const cmd = {
+            name,
+            text: saveCommandText,
+            createdAt: Date.now(),
+        };
+        appendSavedCustomCommand(cmd);
+        setCustomCommands(loadCustomCommands());
+        setSaveCommandModalOpen(false);
+        setSaveCommandText("");
+        setActionNotice(`Saved /${name} command`, "success");
+    }, [saveCommandText, setActionNotice]);
+    return {
+        saveCommandModalOpen,
+        saveCommandText,
+        customCommands,
+        closeSaveCommandModal,
+        confirmSaveCommand,
+    };
+}

package/hooks/useKeyboardShortcuts.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Keyboard shortcuts manager for the application.
+ */
+export interface ShortcutConfig {
+    key: string;
+    ctrl?: boolean;
+    shift?: boolean;
+    alt?: boolean;
+    meta?: boolean;
+    handler: () => void;
+    description: string;
+    scope?: "global" | "chat" | "settings";
+}
+export declare function useKeyboardShortcuts(shortcuts: ShortcutConfig[]): void;
+export declare const COMMON_SHORTCUTS: Omit<ShortcutConfig, "handler">[];
+export declare function useShortcutsHelp(): string;
+//# sourceMappingURL=useKeyboardShortcuts.d.ts.map

package/hooks/useKeyboardShortcuts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useKeyboardShortcuts.d.ts","sourceRoot":"","sources":["../../src/hooks/useKeyboardShortcuts.ts"],"names":[],"mappings":"AAAA;;GAEG;AAIH,MAAM,WAAW,cAAc;IAC7B,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,GAAG,CAAC,EAAE,OAAO,CAAC;IACd,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,OAAO,EAAE,MAAM,IAAI,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC;IACpB,KAAK,CAAC,EAAE,QAAQ,GAAG,MAAM,GAAG,UAAU,CAAC;CACxC;AAED,wBAAgB,oBAAoB,CAAC,SAAS,EAAE,cAAc,EAAE,QAwB/D;AAGD,eAAO,MAAM,gBAAgB,EAAE,IAAI,CAAC,cAAc,EAAE,SAAS,CAAC,EAwB7D,CAAC;AAGF,wBAAgB,gBAAgB,IAAI,MAAM,CAIzC"}

package/hooks/useKeyboardShortcuts.js

@@ -0,0 +1,67 @@
+/**
+ * Keyboard shortcuts manager for the application.
+ */
+import { useCallback, useEffect } from "react";
+export function useKeyboardShortcuts(shortcuts) {
+    const handleKeyDown = useCallback((event) => {
+        for (const shortcut of shortcuts) {
+            const keyMatch = event.key.toLowerCase() === shortcut.key.toLowerCase();
+            const ctrlMatch = !!shortcut.ctrl === event.ctrlKey;
+            const shiftMatch = !!shortcut.shift === event.shiftKey;
+            const altMatch = !!shortcut.alt === event.altKey;
+            const metaMatch = !!shortcut.meta === event.metaKey;
+            if (keyMatch && ctrlMatch && shiftMatch && altMatch && metaMatch) {
+                event.preventDefault();
+                shortcut.handler();
+                break;
+            }
+        }
+    }, [shortcuts]);
+    useEffect(() => {
+        window.addEventListener("keydown", handleKeyDown);
+        return () => window.removeEventListener("keydown", handleKeyDown);
+    }, [handleKeyDown]);
+}
+// Common shortcuts
+export const COMMON_SHORTCUTS = [
+    {
+        key: "k",
+        ctrl: true,
+        description: "Open command palette",
+        scope: "global",
+    },
+    { key: "Enter", ctrl: true, description: "Send message", scope: "chat" },
+    { key: "Escape", description: "Close modal / Cancel", scope: "global" },
+    {
+        key: "?",
+        shift: true,
+        description: "Show keyboard shortcuts",
+        scope: "global",
+    },
+    { key: "r", ctrl: true, description: "Restart agent", scope: "global" },
+    { key: " ", description: "Pause/Resume agent", scope: "global" },
+    {
+        key: "t",
+        ctrl: true,
+        shift: true,
+        description: "Toggle terminal",
+        scope: "global",
+    },
+];
+// Hook to get shortcuts display
+export function useShortcutsHelp() {
+    return COMMON_SHORTCUTS.map((s) => `${formatShortcut(s)} — ${s.description}`).join("\n");
+}
+function formatShortcut(s) {
+    const parts = [];
+    if (s.ctrl)
+        parts.push("Ctrl");
+    if (s.shift)
+        parts.push("Shift");
+    if (s.alt)
+        parts.push("Alt");
+    if (s.meta)
+        parts.push("Cmd");
+    parts.push(s.key.length === 1 ? s.key.toUpperCase() : s.key);
+    return parts.join("+");
+}

package/hooks/useLifoSync.d.ts

@@ -0,0 +1,18 @@
+import { type LifoRuntime, type LifoSyncMessage } from "../platform";
+interface UseLifoSyncOptions {
+    popoutMode: boolean;
+    lifoSessionId: string | null;
+    runtimeRef: React.RefObject<LifoRuntime | null>;
+    appendOutput: (line: string) => void;
+    setRunCount: React.Dispatch<React.SetStateAction<number>>;
+    setSessionKey: React.Dispatch<React.SetStateAction<number>>;
+    setControllerOnline: React.Dispatch<React.SetStateAction<boolean>>;
+    controllerHeartbeatAtRef: React.MutableRefObject<number>;
+}
+interface UseLifoSyncReturn {
+    broadcastSyncMessage: (message: Omit<LifoSyncMessage, "source">) => void;
+    syncChannelRef: React.RefObject<BroadcastChannel | null>;
+}
+export declare function useLifoSync({ popoutMode, lifoSessionId, runtimeRef, appendOutput, setRunCount, setSessionKey, setControllerOnline, controllerHeartbeatAtRef, }: UseLifoSyncOptions): UseLifoSyncReturn;
+export {};
+//# sourceMappingURL=useLifoSync.d.ts.map

package/hooks/useLifoSync.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useLifoSync.d.ts","sourceRoot":"","sources":["../../src/hooks/useLifoSync.ts"],"names":[],"mappings":"AACA,OAAO,EAEL,KAAK,WAAW,EAChB,KAAK,eAAe,EAErB,MAAM,aAAa,CAAC;AAErB,UAAU,kBAAkB;IAC1B,UAAU,EAAE,OAAO,CAAC;IACpB,aAAa,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B,UAAU,EAAE,KAAK,CAAC,SAAS,CAAC,WAAW,GAAG,IAAI,CAAC,CAAC;IAChD,YAAY,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IACrC,WAAW,EAAE,KAAK,CAAC,QAAQ,CAAC,KAAK,CAAC,cAAc,CAAC,MAAM,CAAC,CAAC,CAAC;IAC1D,aAAa,EAAE,KAAK,CAAC,QAAQ,CAAC,KAAK,CAAC,cAAc,CAAC,MAAM,CAAC,CAAC,CAAC;IAC5D,mBAAmB,EAAE,KAAK,CAAC,QAAQ,CAAC,KAAK,CAAC,cAAc,CAAC,OAAO,CAAC,CAAC,CAAC;IACnE,wBAAwB,EAAE,KAAK,CAAC,gBAAgB,CAAC,MAAM,CAAC,CAAC;CAC1D;AAED,UAAU,iBAAiB;IACzB,oBAAoB,EAAE,CAAC,OAAO,EAAE,IAAI,CAAC,eAAe,EAAE,QAAQ,CAAC,KAAK,IAAI,CAAC;IACzE,cAAc,EAAE,KAAK,CAAC,SAAS,CAAC,gBAAgB,GAAG,IAAI,CAAC,CAAC;CAC1D;AAED,wBAAgB,WAAW,CAAC,EAC1B,UAAU,EACV,aAAa,EACb,UAAU,EACV,YAAY,EACZ,WAAW,EACX,aAAa,EACb,mBAAmB,EACnB,wBAAwB,GACzB,EAAE,kBAAkB,GAAG,iBAAiB,CA6GxC"}

package/hooks/useLifoSync.js

@@ -0,0 +1,113 @@
+import { useCallback, useEffect, useRef } from "react";
+import { getLifoSyncChannelName, normalizeTerminalText, } from "../platform";
+export function useLifoSync({ popoutMode, lifoSessionId, runtimeRef, appendOutput, setRunCount, setSessionKey, setControllerOnline, controllerHeartbeatAtRef, }) {
+    const syncChannelRef = useRef(null);
+    const broadcastSyncMessage = useCallback((message) => {
+        if (!popoutMode)
+            return;
+        syncChannelRef.current?.postMessage({
+            source: "controller",
+            ...message,
+        });
+    }, [popoutMode]);
+    useEffect(() => {
+        if (typeof BroadcastChannel === "undefined")
+            return;
+        const channel = new BroadcastChannel(getLifoSyncChannelName(lifoSessionId));
+        syncChannelRef.current = channel;
+        let heartbeatInterval = null;
+        let heartbeatWatchInterval = null;
+        if (popoutMode) {
+            setControllerOnline(true);
+            broadcastSyncMessage({ type: "heartbeat" });
+            heartbeatInterval = setInterval(() => {
+                broadcastSyncMessage({ type: "heartbeat" });
+            }, 1000);
+        }
+        else {
+            heartbeatWatchInterval = setInterval(() => {
+                const online = Date.now() - controllerHeartbeatAtRef.current < 3500;
+                setControllerOnline(online);
+            }, 1000);
+        }
+        channel.onmessage = (event) => {
+            if (popoutMode)
+                return;
+            const data = event.data;
+            if (!data || data.source !== "controller")
+                return;
+            if (data.type === "heartbeat") {
+                controllerHeartbeatAtRef.current = Date.now();
+                setControllerOnline(true);
+                return;
+            }
+            const runtime = runtimeRef.current;
+            if (!runtime)
+                return;
+            switch (data.type) {
+                case "session-reset":
+                    setSessionKey((value) => value + 1);
+                    break;
+                case "command-start":
+                    if (typeof data.command !== "string")
+                        return;
+                    runtime.terminal.writeln(`$ ${data.command}`);
+                    appendOutput(`$ ${data.command}`);
+                    setRunCount((prev) => prev + 1);
+                    break;
+                case "stdout":
+                    if (typeof data.chunk !== "string")
+                        return;
+                    runtime.terminal.write(normalizeTerminalText(data.chunk));
+                    if (data.chunk.trimEnd())
+                        appendOutput(data.chunk.trimEnd());
+                    break;
+                case "stderr":
+                    if (typeof data.chunk !== "string")
+                        return;
+                    runtime.terminal.write(normalizeTerminalText(data.chunk));
+                    if (data.chunk.trimEnd()) {
+                        appendOutput(`stderr: ${data.chunk.trimEnd()}`);
+                    }
+                    break;
+                case "command-exit":
+                    if (typeof data.exitCode !== "number")
+                        return;
+                    runtime.terminal.writeln(`[exit ${data.exitCode}]`);
+                    appendOutput(`[exit ${data.exitCode}]`);
+                    try {
+                        runtime.explorer.refresh();
+                    }
+                    catch {
+                        // Ignore refresh failures when mirroring popout events.
+                    }
+                    break;
+                case "command-error":
+                    if (typeof data.message !== "string")
+                        return;
+                    runtime.terminal.writeln(`error: ${data.message}`);
+                    appendOutput(`error: ${data.message}`);
+                    break;
+            }
+        };
+        return () => {
+            if (heartbeatInterval)
+                clearInterval(heartbeatInterval);
+            if (heartbeatWatchInterval)
+                clearInterval(heartbeatWatchInterval);
+            syncChannelRef.current = null;
+            channel.close();
+        };
+    }, [
+        appendOutput,
+        broadcastSyncMessage,
+        controllerHeartbeatAtRef,
+        lifoSessionId,
+        popoutMode,
+        runtimeRef,
+        setControllerOnline,
+        setRunCount,
+        setSessionKey,
+    ]);
+    return { broadcastSyncMessage, syncChannelRef };
+}

package/hooks/useMemoryMonitor.d.ts

@@ -0,0 +1,87 @@
+/**
+ * Memory monitoring hook for detecting memory leaks.
+ *
+ * Uses the Performance API's memory metrics (Chrome/Edge only) to track
+ * heap usage over time and detect potential memory leaks by analyzing
+ * growth patterns.
+ *
+ * Usage:
+ *   const { metrics, isLeaking, trend } = useMemoryMonitor({ enabled: true });
+ *
+ * The hook samples memory at regular intervals and calculates:
+ * - Current heap usage
+ * - Heap growth trend (MB/min)
+ * - Leak detection based on sustained growth
+ */
+export interface MemoryMetrics {
+    /** Current used JS heap size in bytes */
+    usedHeapSize: number;
+    /** Total JS heap size in bytes */
+    totalHeapSize: number;
+    /** JS heap size limit in bytes */
+    heapSizeLimit: number;
+    /** Heap usage as percentage of limit */
+    usagePercent: number;
+    /** Timestamp of measurement */
+    timestamp: number;
+}
+export interface MemorySample {
+    usedHeapSize: number;
+    timestamp: number;
+}
+export interface MemoryTrend {
+    /** Growth rate in bytes per minute (positive = growing) */
+    bytesPerMinute: number;
+    /** Growth rate in MB per minute */
+    mbPerMinute: number;
+    /** Number of samples in the analysis window */
+    sampleCount: number;
+    /** Duration of analysis window in minutes */
+    windowMinutes: number;
+}
+export interface UseMemoryMonitorOptions {
+    /** Enable memory monitoring (default: true in dev mode) */
+    enabled?: boolean;
+    /** Sampling interval in milliseconds (default: 5000) */
+    sampleInterval?: number;
+    /** Number of samples to keep for trend analysis (default: 60) */
+    maxSamples?: number;
+    /** Threshold in MB/min to consider a leak (default: 1.0) */
+    leakThresholdMbPerMin?: number;
+    /** Minimum samples before detecting leaks (default: 12) */
+    minSamplesForDetection?: number;
+    /** Callback when a potential leak is detected */
+    onLeakDetected?: (trend: MemoryTrend, metrics: MemoryMetrics) => void;
+}
+export interface UseMemoryMonitorResult {
+    /** Whether memory API is supported in this browser */
+    supported: boolean;
+    /** Current memory metrics (null if not supported) */
+    metrics: MemoryMetrics | null;
+    /** Memory growth trend analysis */
+    trend: MemoryTrend | null;
+    /** Whether a potential memory leak is detected */
+    isLeaking: boolean;
+    /** Historical samples for charting */
+    samples: MemorySample[];
+    /** Force garbage collection (if available) */
+    forceGC: () => void;
+    /** Clear sample history */
+    clearHistory: () => void;
+    /** Get formatted memory stats for display */
+    getFormattedStats: () => string;
+}
+export declare function useMemoryMonitor(options?: UseMemoryMonitorOptions): UseMemoryMonitorResult;
+/**
+ * Lightweight memory leak detector that logs warnings to console.
+ * Can be used as a standalone function without React.
+ */
+export declare function startMemoryLeakDetector(options?: {
+    intervalMs?: number;
+    thresholdMbPerMin?: number;
+    onLeak?: (info: {
+        mbPerMinute: number;
+        currentMb: number;
+    }) => void;
+}): () => void;
+//# sourceMappingURL=useMemoryMonitor.d.ts.map

package/hooks/useMemoryMonitor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useMemoryMonitor.d.ts","sourceRoot":"","sources":["../../src/hooks/useMemoryMonitor.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAeH,MAAM,WAAW,aAAa;IAC5B,yCAAyC;IACzC,YAAY,EAAE,MAAM,CAAC;IACrB,kCAAkC;IAClC,aAAa,EAAE,MAAM,CAAC;IACtB,kCAAkC;IAClC,aAAa,EAAE,MAAM,CAAC;IACtB,wCAAwC;IACxC,YAAY,EAAE,MAAM,CAAC;IACrB,+BAA+B;IAC/B,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,YAAY;IAC3B,YAAY,EAAE,MAAM,CAAC;IACrB,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,WAAW;IAC1B,2DAA2D;IAC3D,cAAc,EAAE,MAAM,CAAC;IACvB,mCAAmC;IACnC,WAAW,EAAE,MAAM,CAAC;IACpB,+CAA+C;IAC/C,WAAW,EAAE,MAAM,CAAC;IACpB,6CAA6C;IAC7C,aAAa,EAAE,MAAM,CAAC;CACvB;AAED,MAAM,WAAW,uBAAuB;IACtC,2DAA2D;IAC3D,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,wDAAwD;IACxD,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,iEAAiE;IACjE,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,4DAA4D;IAC5D,qBAAqB,CAAC,EAAE,MAAM,CAAC;IAC/B,2DAA2D;IAC3D,sBAAsB,CAAC,EAAE,MAAM,CAAC;IAChC,iDAAiD;IACjD,cAAc,CAAC,EAAE,CAAC,KAAK,EAAE,WAAW,EAAE,OAAO,EAAE,aAAa,KAAK,IAAI,CAAC;CACvE;AAED,MAAM,WAAW,sBAAsB;IACrC,sDAAsD;IACtD,SAAS,EAAE,OAAO,CAAC;IACnB,qDAAqD;IACrD,OAAO,EAAE,aAAa,GAAG,IAAI,CAAC;IAC9B,mCAAmC;IACnC,KAAK,EAAE,WAAW,GAAG,IAAI,CAAC;IAC1B,kDAAkD;IAClD,SAAS,EAAE,OAAO,CAAC;IACnB,sCAAsC;IACtC,OAAO,EAAE,YAAY,EAAE,CAAC;IACxB,8CAA8C;IAC9C,OAAO,EAAE,MAAM,IAAI,CAAC;IACpB,2BAA2B;IAC3B,YAAY,EAAE,MAAM,IAAI,CAAC;IACzB,6CAA6C;IAC7C,iBAAiB,EAAE,MAAM,MAAM,CAAC;CACjC;AA+CD,wBAAgB,gBAAgB,CAC9B,OAAO,GAAE,uBAA4B,GACpC,sBAAsB,CAiJxB;AAED;;;GAGG;AACH,wBAAgB,uBAAuB,CAAC,OAAO,CAAC,EAAE;IAChD,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,MAAM,CAAC,EAAE,CAAC,IAAI,EAAE;QAAE,WAAW,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAE,KAAK,IAAI,CAAC;CACrE,GAAG,MAAM,IAAI,CAuCb"}