@elizaos/app-core 2.0.0-alpha.85 → 2.0.0-beta.2

package/hooks/useLifoSync.js

@@ -1,113 +0,0 @@
-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

@@ -1,87 +0,0 @@
-/**
- * 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

@@ -1 +0,0 @@
-{"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"}

package/hooks/useMemoryMonitor.js

@@ -1,209 +0,0 @@
-/**
- * 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
- */
-import { useCallback, useEffect, useRef, useState } from "react";
-const DEFAULT_OPTIONS = {
-    enabled: Boolean(import.meta.env.DEV),
-    sampleInterval: 5000,
-    maxSamples: 60,
-    leakThresholdMbPerMin: 1.0,
-    minSamplesForDetection: 12,
-};
-function getMemoryInfo() {
-    const perf = performance;
-    return perf.memory ?? null;
-}
-function formatBytes(bytes) {
-    if (bytes < 1024)
-        return `${bytes} B`;
-    if (bytes < 1024 * 1024)
-        return `${(bytes / 1024).toFixed(1)} KB`;
-    if (bytes < 1024 * 1024 * 1024)
-        return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
-    return `${(bytes / (1024 * 1024 * 1024)).toFixed(2)} GB`;
-}
-function calculateTrend(samples) {
-    if (samples.length < 2)
-        return null;
-    const firstSample = samples[0];
-    const lastSample = samples[samples.length - 1];
-    const durationMs = lastSample.timestamp - firstSample.timestamp;
-    if (durationMs <= 0)
-        return null;
-    const durationMinutes = durationMs / (1000 * 60);
-    const heapChange = lastSample.usedHeapSize - firstSample.usedHeapSize;
-    const bytesPerMinute = heapChange / durationMinutes;
-    const mbPerMinute = bytesPerMinute / (1024 * 1024);
-    return {
-        bytesPerMinute,
-        mbPerMinute,
-        sampleCount: samples.length,
-        windowMinutes: durationMinutes,
-    };
-}
-export function useMemoryMonitor(options = {}) {
-    const opts = { ...DEFAULT_OPTIONS, ...options };
-    const { enabled, sampleInterval, maxSamples, leakThresholdMbPerMin, minSamplesForDetection, } = opts;
-    const [supported, setSupported] = useState(false);
-    const [metrics, setMetrics] = useState(null);
-    const [samples, setSamples] = useState([]);
-    const [trend, setTrend] = useState(null);
-    const [isLeaking, setIsLeaking] = useState(false);
-    const onLeakDetectedRef = useRef(options.onLeakDetected);
-    onLeakDetectedRef.current = options.onLeakDetected;
-    const lastLeakNotifyRef = useRef(0);
-    // Check browser support
-    useEffect(() => {
-        const memInfo = getMemoryInfo();
-        setSupported(memInfo !== null);
-    }, []);
-    // Sample memory at intervals
-    useEffect(() => {
-        if (!enabled || !supported)
-            return;
-        const sample = () => {
-            const memInfo = getMemoryInfo();
-            if (!memInfo)
-                return;
-            const now = Date.now();
-            const currentMetrics = {
-                usedHeapSize: memInfo.usedJSHeapSize,
-                totalHeapSize: memInfo.totalJSHeapSize,
-                heapSizeLimit: memInfo.jsHeapSizeLimit,
-                usagePercent: (memInfo.usedJSHeapSize / memInfo.jsHeapSizeLimit) * 100,
-                timestamp: now,
-            };
-            setMetrics(currentMetrics);
-            setSamples((prev) => {
-                const newSample = {
-                    usedHeapSize: memInfo.usedJSHeapSize,
-                    timestamp: now,
-                };
-                const updated = [...prev, newSample];
-                if (updated.length > maxSamples) {
-                    updated.splice(0, updated.length - maxSamples);
-                }
-                return updated;
-            });
-        };
-        // Initial sample
-        sample();
-        const intervalId = setInterval(sample, sampleInterval);
-        return () => clearInterval(intervalId);
-    }, [enabled, supported, sampleInterval, maxSamples]);
-    // Calculate trend and detect leaks
-    useEffect(() => {
-        if (samples.length < 2) {
-            setTrend(null);
-            setIsLeaking(false);
-            return;
-        }
-        const currentTrend = calculateTrend(samples);
-        setTrend(currentTrend);
-        if (!currentTrend || samples.length < minSamplesForDetection) {
-            setIsLeaking(false);
-            return;
-        }
-        // Detect sustained memory growth
-        const leaking = currentTrend.mbPerMinute > leakThresholdMbPerMin;
-        setIsLeaking(leaking);
-        // Notify callback (throttled to once per minute)
-        if (leaking && metrics && onLeakDetectedRef.current) {
-            const now = Date.now();
-            if (now - lastLeakNotifyRef.current > 60000) {
-                lastLeakNotifyRef.current = now;
-                onLeakDetectedRef.current(currentTrend, metrics);
-            }
-        }
-    }, [samples, minSamplesForDetection, leakThresholdMbPerMin, metrics]);
-    const forceGC = useCallback(() => {
-        // gc() is only available when Chrome is started with --js-flags="--expose-gc"
-        const win = window;
-        if (typeof win.gc === "function") {
-            win.gc();
-        }
-    }, []);
-    const clearHistory = useCallback(() => {
-        setSamples([]);
-        setTrend(null);
-        setIsLeaking(false);
-    }, []);
-    const getFormattedStats = useCallback(() => {
-        if (!metrics)
-            return "Memory monitoring not available";
-        const lines = [
-            `Heap Used: ${formatBytes(metrics.usedHeapSize)}`,
-            `Heap Total: ${formatBytes(metrics.totalHeapSize)}`,
-            `Heap Limit: ${formatBytes(metrics.heapSizeLimit)}`,
-            `Usage: ${metrics.usagePercent.toFixed(1)}%`,
-        ];
-        if (trend) {
-            const trendSign = trend.mbPerMinute >= 0 ? "+" : "";
-            lines.push(`Trend: ${trendSign}${trend.mbPerMinute.toFixed(2)} MB/min`, `Samples: ${trend.sampleCount} (${trend.windowMinutes.toFixed(1)} min)`);
-        }
-        if (isLeaking) {
-            lines.push("WARNING: Potential memory leak detected!");
-        }
-        return lines.join("\n");
-    }, [metrics, trend, isLeaking]);
-    return {
-        supported,
-        metrics,
-        trend,
-        isLeaking,
-        samples,
-        forceGC,
-        clearHistory,
-        getFormattedStats,
-    };
-}
-/**
- * Lightweight memory leak detector that logs warnings to console.
- * Can be used as a standalone function without React.
- */
-export function startMemoryLeakDetector(options) {
-    const intervalMs = options?.intervalMs ?? 10000;
-    const thresholdMbPerMin = options?.thresholdMbPerMin ?? 2.0;
-    const samples = [];
-    const maxSamples = 30;
-    const intervalId = setInterval(() => {
-        const memInfo = getMemoryInfo();
-        if (!memInfo)
-            return;
-        const now = Date.now();
-        samples.push({
-            usedHeapSize: memInfo.usedJSHeapSize,
-            timestamp: now,
-        });
-        if (samples.length > maxSamples) {
-            samples.shift();
-        }
-        if (samples.length >= 6) {
-            const trend = calculateTrend(samples);
-            if (trend && trend.mbPerMinute > thresholdMbPerMin) {
-                const currentMb = memInfo.usedJSHeapSize / (1024 * 1024);
-                console.warn(`[MemoryLeakDetector] Potential memory leak detected!\n` +
-                    `  Growth rate: +${trend.mbPerMinute.toFixed(2)} MB/min\n` +
-                    `  Current heap: ${currentMb.toFixed(1)} MB\n` +
-                    `  Window: ${trend.windowMinutes.toFixed(1)} min (${trend.sampleCount} samples)`);
-                options?.onLeak?.({
-                    mbPerMinute: trend.mbPerMinute,
-                    currentMb,
-                });
-            }
-        }
-    }, intervalMs);
-    return () => clearInterval(intervalId);
-}

package/hooks/useRenderGuard.d.ts

@@ -1,17 +0,0 @@
-/**
- * Development-only render-rate guard.
- *
- * Tracks render timestamps for the named component and logs a console warning
- * when the component re-renders {@link THRESHOLD} or more times within
- * {@link WINDOW_MS} ms.  No-op in production builds.
- *
- * Usage:
- * ```ts
- * function MyComponent() {
- *   useRenderGuard("MyComponent");
- *   // …
- * }
- * ```
- */
-export declare function useRenderGuard(name: string): void;
-//# sourceMappingURL=useRenderGuard.d.ts.map

package/hooks/useRenderGuard.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"useRenderGuard.d.ts","sourceRoot":"","sources":["../../src/hooks/useRenderGuard.ts"],"names":[],"mappings":"AAQA;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAmBjD"}

package/hooks/useRenderGuard.js

@@ -1,36 +0,0 @@
-import { useRef } from "react";
-const THRESHOLD = 3;
-const WINDOW_MS = 1000;
-const IS_DEV = typeof process !== "undefined" &&
-    (process.env.NODE_ENV === "development" || process.env.NODE_ENV === "test");
-/**
- * Development-only render-rate guard.
- *
- * Tracks render timestamps for the named component and logs a console warning
- * when the component re-renders {@link THRESHOLD} or more times within
- * {@link WINDOW_MS} ms.  No-op in production builds.
- *
- * Usage:
- * ```ts
- * function MyComponent() {
- *   useRenderGuard("MyComponent");
- *   // …
- * }
- * ```
- */
-export function useRenderGuard(name) {
-    // Always call the hook (preserve hook call order) but skip work in prod.
-    const timestamps = useRef([]);
-    if (!IS_DEV)
-        return;
-    const now = Date.now();
-    const ts = timestamps.current;
-    ts.push(now);
-    // Prune old entries outside the window
-    while (ts.length > 0 && ts[0] < now - WINDOW_MS) {
-        ts.shift();
-    }
-    if (ts.length >= THRESHOLD) {
-        console.warn(`[RenderGuard] "${name}" rendered ${ts.length}× in the last ${WINDOW_MS}ms`);
-    }
-}

package/hooks/useRetakeCapture.d.ts

@@ -1,12 +0,0 @@
-/**
- * Hook that controls desktop native frame capture for retake.tv streaming.
- *
- * Uses the native desktop capture path through the renderer bridge — this captures
- * the full compositor output including cross-origin iframes (unlike the old canvas approach
- * which was blocked by same-origin policy).
- *
- * The main process handles capture + HTTP POST to /api/stream/frame directly.
- * This hook just sends start/stop signals.
- */
-export declare function useRetakeCapture(_iframeRef: React.RefObject<HTMLIFrameElement | null>, active: boolean, fps?: number): void;
-//# sourceMappingURL=useRetakeCapture.d.ts.map

package/hooks/useRetakeCapture.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"useRetakeCapture.d.ts","sourceRoot":"","sources":["../../src/hooks/useRetakeCapture.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AASH,wBAAgB,gBAAgB,CAC9B,UAAU,EAAE,KAAK,CAAC,SAAS,CAAC,iBAAiB,GAAG,IAAI,CAAC,EACrD,MAAM,EAAE,OAAO,EACf,GAAG,SAAc,QA8ClB"}

package/hooks/useRetakeCapture.js

@@ -1,60 +0,0 @@
-/**
- * Hook that controls desktop native frame capture for retake.tv streaming.
- *
- * Uses the native desktop capture path through the renderer bridge — this captures
- * the full compositor output including cross-origin iframes (unlike the old canvas approach
- * which was blocked by same-origin policy).
- *
- * The main process handles capture + HTTP POST to /api/stream/frame directly.
- * This hook just sends start/stop signals.
- */
-import { useEffect, useRef } from "react";
-import { invokeDesktopBridgeRequest } from "../bridge";
-import { getElizaApiBase } from "../utils/eliza-globals";
-const DEFAULT_FPS = 15;
-const JPEG_QUALITY = 70;
-export function useRetakeCapture(_iframeRef, active, fps = DEFAULT_FPS) {
-    const activeRef = useRef(false);
-    useEffect(() => {
-        if (active && !activeRef.current) {
-            activeRef.current = true;
-            void invokeDesktopBridgeRequest({
-                rpcMethod: "screencaptureStartFrameCapture",
-                ipcChannel: "screencapture:startFrameCapture",
-                params: {
-                    fps,
-                    quality: JPEG_QUALITY,
-                    apiBase: getElizaApiBase() ?? "http://localhost:2138",
-                    endpoint: "/api/stream/frame",
-                },
-            })
-                .then((result) => {
-                if (result === null) {
-                    activeRef.current = false;
-                }
-            })
-                .catch((err) => {
-                console.warn("[retake] Failed to start frame capture:", err);
-                activeRef.current = false;
-            });
-        }
-        else if (!active && activeRef.current) {
-            activeRef.current = false;
-            void invokeDesktopBridgeRequest({
-                rpcMethod: "screencaptureStopFrameCapture",
-                ipcChannel: "screencapture:stopFrameCapture",
-            }).catch((err) => {
-                console.warn("[retake] Failed to stop frame capture:", err);
-            });
-        }
-        return () => {
-            if (activeRef.current) {
-                activeRef.current = false;
-                void invokeDesktopBridgeRequest({
-                    rpcMethod: "screencaptureStopFrameCapture",
-                    ipcChannel: "screencapture:stopFrameCapture",
-                }).catch(() => { });
-            }
-        };
-    }, [active, fps]);
-}

package/hooks/useStreamPopoutNavigation.d.ts

@@ -1,3 +0,0 @@
-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

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

package/hooks/useStreamPopoutNavigation.js

@@ -1,17 +0,0 @@
-import { useEffect } from "react";
-export function getNextTabForStreamPopoutEvent(_detail) {
-    return null;
-}
-export function useStreamPopoutNavigation(setTab) {
-    useEffect(() => {
-        const target = typeof window !== "undefined" ? window : globalThis;
-        const handler = (event) => {
-            const nextTab = getNextTabForStreamPopoutEvent(event.detail);
-            if (nextTab) {
-                setTab(nextTab);
-            }
-        };
-        target.addEventListener("stream-popout", handler);
-        return () => target.removeEventListener("stream-popout", handler);
-    }, [setTab]);
-}

package/hooks/useTimeout.d.ts

@@ -1,11 +0,0 @@
-/**
- * Custom hook to safely manage `setTimeout` calls within React components.
- * Automatically clears the timeout if the component unmounts before it fires.
- *
- * Returns `{ setTimeout, clearTimeout }` which mimic the global functions.
- */
-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

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

package/hooks/useTimeout.js

@@ -1,32 +0,0 @@
-import { useCallback, useEffect, useRef } from "react";
-/**
- * Custom hook to safely manage `setTimeout` calls within React components.
- * Automatically clears the timeout if the component unmounts before it fires.
- *
- * Returns `{ setTimeout, clearTimeout }` which mimic the global functions.
- */
-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 };
-}