glirastes 0.3.2 → 0.5.0

package/dist/cjs/react/components/voice-input-addon.d.ts

@@ -1,13 +1,28 @@
+import type { SttProviderAdapter } from '../stt/controller.js';
+import type { VoicePushToTalkConfig } from '../types.js';
 interface VoiceInputAddonProps {
     disabled: boolean;
     language: string;
     baseUrl?: string;
     /** Returns the current auth token for WebSocket authentication */
     getToken?: () => string | null | undefined;
+    /** Speech provider; defaults to the Deepgram speech-stream adapter. */
+    adapter?: SttProviderAdapter;
     onTranscript: (text: string) => void;
     onError?: (error: string) => void;
     showRecordingBar?: boolean;
     recordingBarVariant?: 'trigger' | 'inline';
+    /** Hold the button or hotkey to talk; false keeps tap-to-toggle only. */
+    pushToTalk?: VoicePushToTalkConfig | false;
+    /** A changed value (e.g. the pathname) stops and keeps speech as draft. */
+    routeKey?: string;
+    /** Clock for hold detection; tests inject a fake one. */
+    now?: () => number;
 }
-export declare function VoiceInputAddon({ disabled, language, baseUrl, getToken, onTranscript, onError, showRecordingBar, recordingBarVariant, }: VoiceInputAddonProps): import("react/jsx-runtime").JSX.Element;
+/**
+ * The composer's single STT controller and microphone stream. Stop inserts
+ * the transcript into the draft for editing; nothing is sent automatically.
+ * Hide, route change, session switch and unmount release the microphone.
+ */
+export declare function VoiceInputAddon({ disabled, language, baseUrl, getToken, adapter, onTranscript, onError, showRecordingBar, recordingBarVariant, pushToTalk, routeKey, now, }: VoiceInputAddonProps): import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/cjs/react/components/voice-input-addon.js

@@ -3,29 +3,266 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.VoiceInputAddon = VoiceInputAddon;
 const jsx_runtime_1 = require("react/jsx-runtime");
 const react_1 = require("react");
-const use_deepgram_transcription_js_1 = require("../hooks/use-deepgram-transcription.js");
+const deepgram_js_1 = require("../stt/deepgram.js");
+const use_stt_js_1 = require("../stt/use-stt.js");
+const chat_context_js_1 = require("../provider/chat-context.js");
+const use_push_to_talk_hotkey_js_1 = require("../hooks/use-push-to-talk-hotkey.js");
 const recording_bar_js_1 = require("./recording-bar.js");
-function VoiceInputAddon({ disabled, language, baseUrl, getToken, onTranscript, onError, showRecordingBar = true, recordingBarVariant = 'inline', }) {
-    const { isRecording, isConnecting, startRecording, stopRecording, } = (0, use_deepgram_transcription_js_1.useDeepgramTranscription)({
-        language,
+const chat_window_visibility_js_1 = require("./chat-window-visibility.js");
+const DEFAULT_HOLD_THRESHOLD_MS = 350;
+// One owner per hotkey for the whole page. A second composer (another
+// provider, an embedded chat next to the host's own) listens on the same
+// window, so without a claim one key press would open two microphone streams.
+// The first claimant owns the key until it unmounts or stops wanting it; the
+// next one in line takes over. Later claimants are ignored while it holds.
+const hotkeyClaims = new Map();
+const hotkeyClaimListeners = new Set();
+function notifyHotkeyClaims() {
+    for (const listener of [...hotkeyClaimListeners])
+        listener();
+}
+function subscribeToHotkeyClaims(listener) {
+    hotkeyClaimListeners.add(listener);
+    return () => { hotkeyClaimListeners.delete(listener); };
+}
+function claimHotkey(combo, owner) {
+    hotkeyClaims.set(combo, [...(hotkeyClaims.get(combo) ?? []), owner]);
+    notifyHotkeyClaims();
+    return () => {
+        const rest = (hotkeyClaims.get(combo) ?? []).filter((claimant) => claimant !== owner);
+        if (rest.length > 0)
+            hotkeyClaims.set(combo, rest);
+        else
+            hotkeyClaims.delete(combo);
+        notifyHotkeyClaims();
+    };
+}
+/** Spelling-independent identity of a combo, e.g. `Shift+Mod+Space`. */
+function hotkeyIdentity(hotkey) {
+    if (!hotkey)
+        return null;
+    const combo = (0, use_push_to_talk_hotkey_js_1.parseHoldCombo)(hotkey);
+    return combo ? `${combo.mod}:${combo.shift}:${combo.alt}:${combo.key}` : null;
+}
+function useHotkeyOwnership(hotkey, wanted) {
+    const [owner] = (0, react_1.useState)(() => Symbol('push-to-talk'));
+    const combo = hotkeyIdentity(hotkey);
+    (0, react_1.useEffect)(() => {
+        if (!wanted || combo === null)
+            return;
+        return claimHotkey(combo, owner);
+    }, [wanted, combo, owner]);
+    return (0, react_1.useSyncExternalStore)(subscribeToHotkeyClaims, () => combo !== null && hotkeyClaims.get(combo)?.[0] === owner, () => false);
+}
+/**
+ * The composer's single STT controller and microphone stream. Stop inserts
+ * the transcript into the draft for editing; nothing is sent automatically.
+ * Hide, route change, session switch and unmount release the microphone.
+ */
+function VoiceInputAddon({ disabled, language, baseUrl, getToken, adapter, onTranscript, onError, showRecordingBar = true, recordingBarVariant = 'inline', pushToTalk, routeKey, now = Date.now, }) {
+    const visible = (0, react_1.useContext)(chat_window_visibility_js_1.ChatWindowVisibilityContext);
+    const chat = (0, react_1.useContext)(chat_context_js_1.ChatContext);
+    const transcriptCallback = (0, react_1.useRef)(onTranscript);
+    transcriptCallback.current = onTranscript;
+    const getTokenRef = (0, react_1.useRef)(getToken);
+    getTokenRef.current = getToken;
+    const pendingStop = (0, react_1.useRef)(null);
+    const resolvedAdapter = (0, react_1.useMemo)(() => adapter ?? new deepgram_js_1.DeepgramSttAdapter({
         baseUrl,
-        getToken,
-        onError,
-    });
+        getToken: () => getTokenRef.current?.(),
+    }), [adapter, baseUrl]);
+    const { phase, isRecording, isConnecting, displayTranscript, stream, startRecording, stopRecording, cancelRecording, retry, } = (0, use_stt_js_1.useStt)({ adapter: resolvedAdapter, language, onError });
+    const active = isRecording || isConnecting;
+    const activeRef = (0, react_1.useRef)(active);
+    activeRef.current = active;
+    // Multiple controls and a visibility change may stop the same recording.
+    // The controller coalesces cleanup; this boundary also inserts text once.
     const stopAndSubmit = (0, react_1.useCallback)(() => {
-        const transcript = stopRecording().trim();
-        if (transcript.length > 0) {
-            onTranscript(transcript);
+        if (pendingStop.current)
+            return pendingStop.current;
+        const pending = Promise.resolve().then(async () => {
+            const transcript = (await stopRecording()).trim();
+            if (transcript.length > 0)
+                transcriptCallback.current(transcript);
+        }).catch(() => {
+            // The shared controller has already reported the provider error through
+            // onError and released its resources. No unhandled event promise.
+        }).finally(() => { if (pendingStop.current === pending)
+            pendingStop.current = null; });
+        pendingStop.current = pending;
+        return pending;
+    }, [stopRecording]);
+    const stopAndSubmitRef = (0, react_1.useRef)(stopAndSubmit);
+    stopAndSubmitRef.current = stopAndSubmit;
+    const start = (0, react_1.useCallback)(() => {
+        // Failures surface through onError and the failed phase (retry button).
+        void startRecording().catch(() => { });
+    }, [startRecording]);
+    (0, react_1.useEffect)(() => {
+        if (!visible && active)
+            void stopAndSubmit();
+    }, [visible, active, stopAndSubmit]);
+    // Route and session changes end the recording; the speech stays as draft.
+    const routeRef = (0, react_1.useRef)(routeKey);
+    (0, react_1.useEffect)(() => {
+        if (routeRef.current === routeKey)
+            return;
+        routeRef.current = routeKey;
+        if (activeRef.current)
+            void stopAndSubmitRef.current();
+    }, [routeKey]);
+    const sessionId = chat?.activeSessionId;
+    const sessionRef = (0, react_1.useRef)(sessionId);
+    (0, react_1.useEffect)(() => {
+        if (sessionRef.current === sessionId)
+            return;
+        sessionRef.current = sessionId;
+        if (activeRef.current)
+            void stopAndSubmitRef.current();
+    }, [sessionId]);
+    (0, react_1.useEffect)(() => {
+        const onHistory = () => {
+            if (activeRef.current)
+                void stopAndSubmitRef.current();
+        };
+        window.addEventListener('popstate', onHistory);
+        window.addEventListener('hashchange', onHistory);
+        return () => {
+            window.removeEventListener('popstate', onHistory);
+            window.removeEventListener('hashchange', onHistory);
+        };
+    }, []);
+    // Push-to-talk: a hold of at least the threshold stops on release; a
+    // shorter tap keeps recording (toggle). Keyboard activation toggles.
+    const pushToTalkEnabled = pushToTalk !== false;
+    const configuredThreshold = pushToTalk === false ? undefined : pushToTalk?.holdThresholdMs;
+    const holdThresholdMs = typeof configuredThreshold === 'number'
+        && Number.isFinite(configuredThreshold) && configuredThreshold >= 0
+        ? configuredThreshold
+        : DEFAULT_HOLD_THRESHOLD_MS;
+    const nowRef = (0, react_1.useRef)(now);
+    nowRef.current = now;
+    const holdThresholdRef = (0, react_1.useRef)(holdThresholdMs);
+    holdThresholdRef.current = holdThresholdMs;
+    const suppressClick = (0, react_1.useRef)(false);
+    const releasedOverButton = (0, react_1.useRef)(false);
+    const suppressTimer = (0, react_1.useRef)(null);
+    const touchStartedRecording = (0, react_1.useRef)(false);
+    const stopWatchingPress = (0, react_1.useRef)(null);
+    const hotkeyHeld = (0, react_1.useRef)(false);
+    const cancelSuppressTimer = () => {
+        if (suppressTimer.current === null)
+            return;
+        clearTimeout(suppressTimer.current);
+        suppressTimer.current = null;
+    };
+    const handlePointerDown = (event) => {
+        touchStartedRecording.current = false;
+        if (!pushToTalkEnabled || disabled || activeRef.current)
+            return;
+        if (typeof event.button === 'number' && event.button !== 0)
+            return;
+        stopWatchingPress.current?.();
+        cancelSuppressTimer();
+        const startedAt = nowRef.current();
+        suppressClick.current = true;
+        releasedOverButton.current = false;
+        touchStartedRecording.current = event.pointerType === 'touch';
+        const stopWatching = () => {
+            window.removeEventListener('pointerup', release);
+            window.removeEventListener('pointercancel', release);
+            if (stopWatchingPress.current === stopWatching)
+                stopWatchingPress.current = null;
+        };
+        const release = () => {
+            stopWatching();
+            // A release over the button is followed by a click that handleClick
+            // swallows. A release elsewhere or a cancelled pointer is followed by
+            // none, and the flag would swallow the next, unrelated click instead.
+            if (!releasedOverButton.current) {
+                suppressClick.current = false;
+            }
+            else {
+                // Touch capture reports every release as "over the button", even one
+                // that ends away from it with no click at all. The click of a press
+                // is dispatched in the task of its pointerup, before any timer, so
+                // the flag outlives it by no more than a timer turn.
+                suppressTimer.current = setTimeout(() => {
+                    suppressTimer.current = null;
+                    suppressClick.current = false;
+                }, 0);
+            }
+            releasedOverButton.current = false;
+            if (nowRef.current() - startedAt >= holdThresholdRef.current) {
+                void stopAndSubmitRef.current();
+            }
+        };
+        stopWatchingPress.current = stopWatching;
+        window.addEventListener('pointerup', release);
+        window.addEventListener('pointercancel', release);
+        start();
+    };
+    // React handles the event before the window listener above sees it.
+    const handlePointerUp = () => {
+        releasedOverButton.current = true;
+    };
+    // The end of a finger's tap is followed by a click, which the browser
+    // hit-tests against the layout of that moment. Recording began on
+    // pointerdown and the inline recording bar has since moved its controls
+    // under the finger, so that click would press Stop and end the recording
+    // the tap just started. The press has done its work; no click is wanted.
+    const handleTouchEnd = (event) => {
+        if (!touchStartedRecording.current)
+            return;
+        touchStartedRecording.current = false;
+        if (event.cancelable)
+            event.preventDefault();
+    };
+    const handleTouchCancel = () => {
+        touchStartedRecording.current = false;
+    };
+    (0, react_1.useEffect)(() => () => {
+        stopWatchingPress.current?.();
+        cancelSuppressTimer();
+    }, []);
+    const handleClick = () => {
+        if (suppressClick.current) {
+            suppressClick.current = false;
+            return;
         }
-    }, [onTranscript, stopRecording]);
-    const handleClick = (0, react_1.useCallback)(async () => {
         if (isRecording) {
-            stopAndSubmit();
+            void stopAndSubmit();
             return;
         }
-        await startRecording();
-    }, [isRecording, startRecording, stopAndSubmit]);
-    return ((0, jsx_runtime_1.jsxs)(jsx_runtime_1.Fragment, { children: [(0, jsx_runtime_1.jsx)("button", { type: "button", onClick: () => {
-                    void handleClick();
-                }, disabled: disabled || isConnecting, "data-component": "voice-input-addon", "data-state": isConnecting ? 'connecting' : isRecording ? 'recording' : 'idle', children: isRecording ? 'stop' : 'mic' }), showRecordingBar && isRecording && ((0, jsx_runtime_1.jsx)(recording_bar_js_1.RecordingBar, { isConnecting: isConnecting, onCancel: stopRecording, onStop: stopAndSubmit, variant: recordingBarVariant }))] }));
+        if (!isConnecting)
+            start();
+    };
+    const hotkey = pushToTalk === false
+        ? false
+        : pushToTalk?.hotkey ?? use_push_to_talk_hotkey_js_1.DEFAULT_PUSH_TO_TALK_HOTKEY;
+    const ownsHotkey = useHotkeyOwnership(hotkey, pushToTalkEnabled && visible && !disabled);
+    (0, use_push_to_talk_hotkey_js_1.usePushToTalkHotkey)({
+        hotkey,
+        enabled: ownsHotkey,
+        onPress: () => {
+            if (activeRef.current)
+                return;
+            hotkeyHeld.current = true;
+            start();
+        },
+        onRelease: () => {
+            if (!hotkeyHeld.current)
+                return;
+            hotkeyHeld.current = false;
+            void stopAndSubmitRef.current();
+        },
+    });
+    const state = phase === 'failed'
+        ? 'failed'
+        : isConnecting
+            ? 'connecting'
+            : isRecording
+                ? 'recording'
+                : 'idle';
+    return ((0, jsx_runtime_1.jsxs)(jsx_runtime_1.Fragment, { children: [(0, jsx_runtime_1.jsx)("button", { type: "button", onPointerDown: handlePointerDown, onPointerUp: handlePointerUp, onTouchEnd: handleTouchEnd, onTouchCancel: handleTouchCancel, onClick: handleClick, disabled: disabled, "aria-busy": isConnecting, "data-component": "voice-input-addon", "data-state": state, children: isRecording ? 'stop' : 'mic' }), phase === 'failed' && ((0, jsx_runtime_1.jsx)("button", { type: "button", onClick: () => { void retry().catch(() => { }); }, disabled: disabled, "aria-label": chat?.locale.retryRecordingAriaLabel ?? 'Retry recording', "data-action": "retry-recording", children: "retry" })), showRecordingBar && active && ((0, jsx_runtime_1.jsx)(recording_bar_js_1.RecordingBar, { isConnecting: isConnecting, stream: stream, transcript: displayTranscript, onCancel: () => { void cancelRecording().catch(() => { }); }, onStop: () => { void stopAndSubmit(); }, variant: recordingBarVariant }))] }));
 }

package/dist/cjs/react/components/voice-input-button.js

@@ -41,7 +41,7 @@ function VoiceInputButton({ onTranscript, disabled = false, className, language
     });
     const handleClick = (0, react_1.useCallback)(async () => {
         if (isRecording) {
-            const finalText = stopRecording();
+            const finalText = await stopRecording();
             if (finalText.trim()) {
                 onTranscript(finalText);
             }

package/dist/cjs/react/hooks/use-chat-shortcuts.d.ts

@@ -0,0 +1,33 @@
+/** What a keyboard shortcut can do to the chat window. */
+export type ChatShortcutAction = 'toggle' | 'toggleLayout' | 'toggleCollapse' | 'newChat' | 'focusInput' | 'close';
+/** A combination such as `mod+i` or `alt+shift+d` per action; `false` switches the action off. */
+export type ChatShortcutMap = Partial<Record<ChatShortcutAction, string | false>>;
+/**
+ * Defaults that stay clear of the common browser and system shortcuts on
+ * macOS, Windows and Linux. `mod` is Command on Apple platforms and Control
+ * elsewhere. An app that already uses one of them passes its own.
+ */
+export declare const DEFAULT_CHAT_SHORTCUTS: Record<ChatShortcutAction, string | false>;
+export declare function resolveChatShortcuts(overrides?: ChatShortcutMap): Record<ChatShortcutAction, string | false>;
+/**
+ * Whether a key press is exactly this combination. Letters and digits match
+ * by physical key too, because Option on macOS turns them into symbols.
+ * A press with further modifiers (AltGr reports Control+Alt) does not match.
+ */
+export declare function matchesShortcut(event: KeyboardEvent, combo: string | false | null | undefined): boolean;
+/** `⌘I` on Apple platforms, `Ctrl+I` elsewhere; empty for a switched-off action. */
+export declare function formatShortcut(combo: string | false | null | undefined): string;
+export interface UseChatShortcutsOptions {
+    /** The app's own combinations; anything left out keeps its default. */
+    shortcuts?: ChatShortcutMap;
+    /** Default: true. */
+    enabled?: boolean;
+    /** Return true to let a key press pass, for example while a dialog owns the keyboard. */
+    shouldIgnore?: (event: KeyboardEvent) => boolean;
+}
+/**
+ * Keyboard control of the chat window, the same on macOS, Windows and Linux.
+ * Only actions with a handler listen. Returns the combinations in effect,
+ * for tooltips via `formatShortcut`.
+ */
+export declare function useChatShortcuts(handlers: Partial<Record<ChatShortcutAction, () => void>>, options?: UseChatShortcutsOptions): Record<ChatShortcutAction, string | false>;

package/dist/cjs/react/hooks/use-chat-shortcuts.js

@@ -0,0 +1,139 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_CHAT_SHORTCUTS = void 0;
+exports.resolveChatShortcuts = resolveChatShortcuts;
+exports.matchesShortcut = matchesShortcut;
+exports.formatShortcut = formatShortcut;
+exports.useChatShortcuts = useChatShortcuts;
+const react_1 = require("react");
+/**
+ * Defaults that stay clear of the common browser and system shortcuts on
+ * macOS, Windows and Linux. `mod` is Command on Apple platforms and Control
+ * elsewhere. An app that already uses one of them passes its own.
+ */
+exports.DEFAULT_CHAT_SHORTCUTS = Object.freeze({
+    toggle: 'mod+i',
+    toggleLayout: 'alt+shift+d',
+    toggleCollapse: 'alt+shift+c',
+    newChat: 'alt+shift+n',
+    focusInput: 'alt+shift+i',
+    close: false,
+});
+function resolveChatShortcuts(overrides) {
+    const resolved = { ...exports.DEFAULT_CHAT_SHORTCUTS };
+    for (const [action, combo] of Object.entries(overrides ?? {})) {
+        if (combo !== undefined && action in resolved)
+            resolved[action] = combo;
+    }
+    return resolved;
+}
+const KEY_ALIASES = { esc: 'escape', return: 'enter', space: ' ', period: '.', comma: ',', slash: '/' };
+const KEY_CODES = { ' ': 'Space', '.': 'Period', ',': 'Comma', '/': 'Slash' };
+function isApplePlatform() {
+    if (typeof navigator === 'undefined')
+        return false;
+    return /Mac|iPhone|iPad|iPod/.test(navigator.platform || navigator.userAgent || '');
+}
+function parse(combo) {
+    const result = { key: '', mod: false, shift: false, alt: false };
+    for (const part of combo.toLowerCase().split('+').map((p) => p.trim()).filter(Boolean)) {
+        if (['mod', 'cmd', 'ctrl', 'meta', 'control'].includes(part))
+            result.mod = true;
+        else if (part === 'shift')
+            result.shift = true;
+        else if (['alt', 'option', 'opt'].includes(part))
+            result.alt = true;
+        else
+            result.key = KEY_ALIASES[part] ?? part;
+    }
+    return result.key ? result : null;
+}
+/** The physical key of a combination, where it has one that is the same on every layout we care about. */
+function codeOf(key) {
+    if (/^[a-z]$/.test(key))
+        return `Key${key.toUpperCase()}`;
+    if (/^[0-9]$/.test(key))
+        return `Digit${key}`;
+    return KEY_CODES[key] ?? null;
+}
+/**
+ * Whether a key press is exactly this combination. Letters and digits match
+ * by physical key too, because Option on macOS turns them into symbols.
+ * A press with further modifiers (AltGr reports Control+Alt) does not match.
+ */
+function matchesShortcut(event, combo) {
+    const parsed = combo ? parse(combo) : null;
+    if (!parsed)
+        return false;
+    const apple = isApplePlatform();
+    const mod = apple ? event.metaKey : event.ctrlKey;
+    const otherMod = apple ? event.ctrlKey : event.metaKey;
+    if (mod !== parsed.mod || otherMod || event.shiftKey !== parsed.shift || event.altKey !== parsed.alt)
+        return false;
+    const key = typeof event.key === 'string' ? event.key.toLowerCase() : '';
+    if (key === parsed.key)
+        return true;
+    const code = codeOf(parsed.key);
+    return code !== null && event.code === code;
+}
+/** `⌘I` on Apple platforms, `Ctrl+I` elsewhere; empty for a switched-off action. */
+function formatShortcut(combo) {
+    const parsed = combo ? parse(combo) : null;
+    if (!parsed)
+        return '';
+    const apple = isApplePlatform();
+    const key = parsed.key === ' ' ? 'Space' : parsed.key.length === 1 ? parsed.key.toUpperCase() : parsed.key.charAt(0).toUpperCase() + parsed.key.slice(1);
+    const parts = [
+        parsed.mod ? (apple ? '⌘' : 'Ctrl') : '',
+        parsed.alt ? (apple ? '⌥' : 'Alt') : '',
+        parsed.shift ? (apple ? '⇧' : 'Shift') : '',
+        key,
+    ].filter(Boolean);
+    return parts.join(apple ? '' : '+');
+}
+function isEditable(target) {
+    if (!(target instanceof HTMLElement))
+        return false;
+    return ['INPUT', 'TEXTAREA', 'SELECT'].includes(target.tagName) || target.isContentEditable;
+}
+/**
+ * Keyboard control of the chat window, the same on macOS, Windows and Linux.
+ * Only actions with a handler listen. Returns the combinations in effect,
+ * for tooltips via `formatShortcut`.
+ */
+function useChatShortcuts(handlers, options = {}) {
+    const { shortcuts, enabled = true, shouldIgnore } = options;
+    const key = JSON.stringify(shortcuts ?? {});
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    const resolved = (0, react_1.useMemo)(() => resolveChatShortcuts(shortcuts), [key]);
+    const handlersRef = (0, react_1.useRef)(handlers);
+    handlersRef.current = handlers;
+    const ignoreRef = (0, react_1.useRef)(shouldIgnore);
+    ignoreRef.current = shouldIgnore;
+    (0, react_1.useEffect)(() => {
+        if (!enabled)
+            return;
+        const listener = (event) => {
+            if (event.defaultPrevented || event.repeat)
+                return;
+            for (const action of Object.keys(resolved)) {
+                const combo = resolved[action];
+                const handler = handlersRef.current[action];
+                if (!combo || !handler || !matchesShortcut(event, combo))
+                    continue;
+                // A bare key belongs to the text field it is typed into; Escape does not.
+                const bare = !event.ctrlKey && !event.metaKey && !event.altKey && event.key !== 'Escape';
+                if (bare && isEditable(event.target))
+                    return;
+                if (ignoreRef.current?.(event))
+                    return;
+                event.preventDefault();
+                handler();
+                return;
+            }
+        };
+        window.addEventListener('keydown', listener);
+        return () => window.removeEventListener('keydown', listener);
+    }, [enabled, resolved]);
+    return resolved;
+}

package/dist/cjs/react/hooks/use-deepgram-transcription.d.ts

@@ -1,2 +1,6 @@
 import type { UseDeepgramTranscriptionOptions, UseDeepgramTranscriptionReturn } from '../types.js';
+/**
+ * Compatibility entry point backed by the provider-neutral STT controller.
+ * New integrations may use `useStt` with their own provider adapter.
+ */
 export declare function useDeepgramTranscription(options?: UseDeepgramTranscriptionOptions): UseDeepgramTranscriptionReturn;