@happyvertical/smrt-svelte 0.30.0

package/dist/hooks/useLLM.svelte.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Hook for LLM (Large Language Model) functionality
+ */
+/**
+ * Options for useLLM hook
+ */
+export interface UseLLMOptions {
+    /** Auto-initialize on mount */
+    autoInit?: boolean;
+    /** Model ID to load */
+    model?: string;
+    /** Default system prompt */
+    systemPrompt?: string;
+}
+/**
+ * Return type for useLLM hook
+ */
+export interface UseLLMReturn {
+    /** Send a message and get response */
+    chat: (text: string, options?: {
+        systemPrompt?: string;
+        onToken?: (token: string) => void;
+    }) => Promise<string>;
+    /** Initialize the adapter */
+    initialize: (modelId?: string) => Promise<void>;
+    /** Unload model to free memory */
+    unload: () => Promise<void>;
+    /** Current state (reactive) */
+    readonly isReady: boolean;
+    readonly isInitializing: boolean;
+    readonly isGenerating: boolean;
+    readonly currentModel: string | null;
+    readonly error: Error | null;
+    readonly downloadProgress: number;
+}
+/**
+ * Hook for LLM chat
+ *
+ * @example
+ * ```svelte
+ * <script>
+ *   import { useLLM } from '@happyvertical/smrt-svelte';
+ *
+ *   const llm = useLLM({ systemPrompt: 'You are a helpful assistant.' });
+ *
+ *   let input = $state('');
+ *   let response = $state('');
+ *
+ *   async function handleSubmit() {
+ *     response = '';
+ *     response = await llm.chat(input, {
+ *       onToken: (token) => { response += token; }
+ *     });
+ *   }
+ * </script>
+ *
+ * {#if llm.isInitializing}
+ *   <p>Loading model... {llm.downloadProgress}%</p>
+ * {:else}
+ *   <form onsubmit={handleSubmit}>
+ *     <input bind:value={input} />
+ *     <button disabled={llm.isGenerating}>Send</button>
+ *   </form>
+ *   <p>{response}</p>
+ * {/if}
+ * ```
+ */
+export declare function useLLM(options?: UseLLMOptions): UseLLMReturn;
+//# sourceMappingURL=useLLM.svelte.d.ts.map

package/dist/hooks/useLLM.svelte.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useLLM.svelte.d.ts","sourceRoot":"","sources":["../../src/hooks/useLLM.svelte.ts"],"names":[],"mappings":"AAAA;;GAEG;AAKH;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B,+BAA+B;IAC/B,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,uBAAuB;IACvB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,4BAA4B;IAC5B,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAED;;GAEG;AACH,MAAM,WAAW,YAAY;IAC3B,sCAAsC;IACtC,IAAI,EAAE,CACJ,IAAI,EAAE,MAAM,EACZ,OAAO,CAAC,EAAE;QAAE,YAAY,CAAC,EAAE,MAAM,CAAC;QAAC,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAA;KAAE,KACnE,OAAO,CAAC,MAAM,CAAC,CAAC;IACrB,6BAA6B;IAC7B,UAAU,EAAE,CAAC,OAAO,CAAC,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAChD,kCAAkC;IAClC,MAAM,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IAC5B,+BAA+B;IAC/B,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,QAAQ,CAAC,cAAc,EAAE,OAAO,CAAC;IACjC,QAAQ,CAAC,YAAY,EAAE,OAAO,CAAC;IAC/B,QAAQ,CAAC,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;IACrC,QAAQ,CAAC,KAAK,EAAE,KAAK,GAAG,IAAI,CAAC;IAC7B,QAAQ,CAAC,gBAAgB,EAAE,MAAM,CAAC;CACnC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,wBAAgB,MAAM,CAAC,OAAO,GAAE,aAAkB,GAAG,YAAY,CAwDhE"}

package/dist/hooks/useLLM.svelte.js

@@ -0,0 +1,85 @@
+/**
+ * Hook for LLM (Large Language Model) functionality
+ */
+import { onDestroy } from 'svelte';
+import { getAppStateContext } from '../state/context.js';
+/**
+ * Hook for LLM chat
+ *
+ * @example
+ * ```svelte
+ * <script>
+ *   import { useLLM } from '@happyvertical/smrt-svelte';
+ *
+ *   const llm = useLLM({ systemPrompt: 'You are a helpful assistant.' });
+ *
+ *   let input = $state('');
+ *   let response = $state('');
+ *
+ *   async function handleSubmit() {
+ *     response = '';
+ *     response = await llm.chat(input, {
+ *       onToken: (token) => { response += token; }
+ *     });
+ *   }
+ * </script>
+ *
+ * {#if llm.isInitializing}
+ *   <p>Loading model... {llm.downloadProgress}%</p>
+ * {:else}
+ *   <form onsubmit={handleSubmit}>
+ *     <input bind:value={input} />
+ *     <button disabled={llm.isGenerating}>Send</button>
+ *   </form>
+ *   <p>{response}</p>
+ * {/if}
+ * ```
+ */
+export function useLLM(options = {}) {
+    const app = getAppStateContext();
+    // Auto-initialize if requested
+    if (options.autoInit) {
+        app.initializeLLM(options.model).catch(() => {
+            // Error is stored in state
+        });
+    }
+    const chat = async (text, chatOptions) => {
+        return app.chat(text, {
+            systemPrompt: chatOptions?.systemPrompt ?? options.systemPrompt,
+            onToken: chatOptions?.onToken,
+        });
+    };
+    const initialize = async (modelId) => {
+        await app.initializeLLM(modelId ?? options.model);
+    };
+    const unload = async () => {
+        await app.unloadLLM();
+    };
+    // Cleanup on destroy - don't unload by default as model download is expensive
+    onDestroy(() => {
+        // Could add option to auto-unload here
+    });
+    return {
+        chat,
+        initialize,
+        unload,
+        get isReady() {
+            return app.state.ai.llm.initState === 'ready';
+        },
+        get isInitializing() {
+            return app.state.ai.llm.initState === 'initializing';
+        },
+        get isGenerating() {
+            return app.state.ai.llm.isGenerating;
+        },
+        get currentModel() {
+            return app.state.ai.llm.currentModel;
+        },
+        get error() {
+            return app.state.ai.llm.error;
+        },
+        get downloadProgress() {
+            return app.state.ai.llm.downloadProgress?.percent ?? 0;
+        },
+    };
+}

package/dist/hooks/useSTT.svelte.d.ts

@@ -0,0 +1,68 @@
+/**
+ * Hook for Speech-to-Text functionality
+ */
+import type { GetSTTOptions, STTOptions } from '../browser-ai/index.js';
+/**
+ * Options for useSTT hook
+ */
+export interface UseSTTOptions {
+    /** Auto-initialize on mount */
+    autoInit?: boolean;
+    /** Default STT options */
+    defaultOptions?: STTOptions;
+}
+/**
+ * Return type for useSTT hook
+ */
+export interface UseSTTReturn {
+    /** Start listening */
+    start: (options?: STTOptions) => Promise<void>;
+    /** Stop listening */
+    stop: () => Promise<void>;
+    /** Initialize the adapter (called automatically if autoInit) */
+    initialize: (options?: GetSTTOptions) => Promise<void>;
+    /** Current state (reactive) */
+    readonly isListening: boolean;
+    readonly isReady: boolean;
+    readonly isInitializing: boolean;
+    /** Final transcribed text (updates on speech completion) */
+    readonly lastResult: string;
+    /** Interim transcribed text (updates live during speech) */
+    readonly interimResult: string;
+    /** Current result - interim while listening, last result otherwise */
+    readonly currentResult: string;
+    readonly error: Error | null;
+    readonly downloadProgress: number;
+    /** Current adapter type (e.g., 'browser', 'whisper-wasm', 'whisper-cpp') */
+    readonly adapterType: string | null;
+}
+/**
+ * Hook for Speech-to-Text
+ *
+ * @example
+ * ```svelte
+ * <script>
+ *   import { useSTT } from '@happyvertical/smrt-svelte';
+ *
+ *   const stt = useSTT();
+ *
+ *   async function handleClick() {
+ *     if (stt.isListening) {
+ *       await stt.stop();
+ *     } else {
+ *       await stt.start();
+ *     }
+ *   }
+ * </script>
+ *
+ * <button onclick={handleClick}>
+ *   {stt.isListening ? 'Stop' : 'Start'} Listening
+ * </button>
+ *
+ * {#if stt.lastResult}
+ *   <p>You said: {stt.lastResult}</p>
+ * {/if}
+ * ```
+ */
+export declare function useSTT(options?: UseSTTOptions): UseSTTReturn;
+//# sourceMappingURL=useSTT.svelte.d.ts.map

package/dist/hooks/useSTT.svelte.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useSTT.svelte.d.ts","sourceRoot":"","sources":["../../src/hooks/useSTT.svelte.ts"],"names":[],"mappings":"AAAA;;GAEG;AAGH,OAAO,KAAK,EAAE,aAAa,EAAE,UAAU,EAAE,MAAM,wBAAwB,CAAC;AAGxE;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B,+BAA+B;IAC/B,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,0BAA0B;IAC1B,cAAc,CAAC,EAAE,UAAU,CAAC;CAC7B;AAED;;GAEG;AACH,MAAM,WAAW,YAAY;IAC3B,sBAAsB;IACtB,KAAK,EAAE,CAAC,OAAO,CAAC,EAAE,UAAU,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAC/C,qBAAqB;IACrB,IAAI,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IAC1B,gEAAgE;IAChE,UAAU,EAAE,CAAC,OAAO,CAAC,EAAE,aAAa,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IACvD,+BAA+B;IAC/B,QAAQ,CAAC,WAAW,EAAE,OAAO,CAAC;IAC9B,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,QAAQ,CAAC,cAAc,EAAE,OAAO,CAAC;IACjC,4DAA4D;IAC5D,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,4DAA4D;IAC5D,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,sEAAsE;IACtE,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,QAAQ,CAAC,KAAK,EAAE,KAAK,GAAG,IAAI,CAAC;IAC7B,QAAQ,CAAC,gBAAgB,EAAE,MAAM,CAAC;IAClC,4EAA4E;IAC5E,QAAQ,CAAC,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;CACrC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,MAAM,CAAC,OAAO,GAAE,aAAkB,GAAG,YAAY,CAqEhE"}

package/dist/hooks/useSTT.svelte.js

@@ -0,0 +1,97 @@
+/**
+ * Hook for Speech-to-Text functionality
+ */
+import { onDestroy } from 'svelte';
+import { getAppStateContext } from '../state/context.js';
+/**
+ * Hook for Speech-to-Text
+ *
+ * @example
+ * ```svelte
+ * <script>
+ *   import { useSTT } from '@happyvertical/smrt-svelte';
+ *
+ *   const stt = useSTT();
+ *
+ *   async function handleClick() {
+ *     if (stt.isListening) {
+ *       await stt.stop();
+ *     } else {
+ *       await stt.start();
+ *     }
+ *   }
+ * </script>
+ *
+ * <button onclick={handleClick}>
+ *   {stt.isListening ? 'Stop' : 'Start'} Listening
+ * </button>
+ *
+ * {#if stt.lastResult}
+ *   <p>You said: {stt.lastResult}</p>
+ * {/if}
+ * ```
+ */
+export function useSTT(options = {}) {
+    const app = getAppStateContext();
+    // Auto-initialize if requested
+    if (options.autoInit) {
+        app.initializeSTT().catch(() => {
+            // Error is stored in state
+        });
+    }
+    const start = async (sttOptions) => {
+        await app.startListening({
+            ...options.defaultOptions,
+            ...sttOptions,
+        });
+    };
+    const stop = async () => {
+        await app.stopListening();
+    };
+    const initialize = async (initOptions) => {
+        await app.initializeSTT(initOptions);
+    };
+    // Cleanup on destroy
+    onDestroy(() => {
+        if (app.state.ai.stt.isListening) {
+            app.stopListening().catch(() => { });
+        }
+    });
+    return {
+        start,
+        stop,
+        initialize,
+        get isListening() {
+            return app.state.ai.stt.isListening;
+        },
+        get isReady() {
+            return app.state.ai.stt.initState === 'ready';
+        },
+        get isInitializing() {
+            return app.state.ai.stt.initState === 'initializing';
+        },
+        get lastResult() {
+            return app.state.ai.stt.lastResult;
+        },
+        get interimResult() {
+            return app.state.ai.stt.interimResult;
+        },
+        get currentResult() {
+            // Return interim while listening, otherwise last result
+            const { isListening, interimResult, lastResult } = app.state.ai.stt;
+            if (isListening && interimResult) {
+                return interimResult;
+            }
+            return lastResult;
+        },
+        get error() {
+            return app.state.ai.stt.error;
+        },
+        get downloadProgress() {
+            return app.state.ai.stt.downloadProgress?.percent ?? 0;
+        },
+        get adapterType() {
+            return app.state.ai.stt.adapter?.type ?? null;
+        },
+    };
+}

package/dist/hooks/useSocket.svelte.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Hook to access WebSocket state and methods
+ */
+import type { SocketStatus } from '../state/app-state.js';
+/**
+ * Access WebSocket state and methods
+ *
+ * @example
+ * ```svelte
+ * <script>
+ *   import { useSocket } from '@happyvertical/smrt-svelte';
+ *
+ *   const socket = useSocket();
+ *
+ *   function sendPing() {
+ *     socket.send({ type: 'ping' });
+ *   }
+ * </script>
+ *
+ * <p>Status: {socket.status}</p>
+ * <p>Connected: {socket.isConnected}</p>
+ * <button onclick={sendPing} disabled={!socket.isConnected}>
+ *   Ping
+ * </button>
+ * ```
+ */
+export declare function useSocket(): {
+    /** Current connection status */
+    readonly status: SocketStatus;
+    /** Whether the socket is connected */
+    readonly isConnected: boolean;
+    /** Whether the socket is reconnecting */
+    readonly isReconnecting: boolean;
+    /** Number of reconnection attempts */
+    readonly reconnectAttempts: number;
+    /** Last connection error */
+    readonly lastError: Event | null;
+    /** Send a message through the socket */
+    send: (data: unknown) => void;
+    /** Manually trigger reconnection */
+    reconnect: () => void;
+    /** Disconnect from the server */
+    disconnect: () => void;
+};
+//# sourceMappingURL=useSocket.svelte.d.ts.map

package/dist/hooks/useSocket.svelte.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useSocket.svelte.d.ts","sourceRoot":"","sources":["../../src/hooks/useSocket.svelte.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAG1D;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,SAAS,IAAI;IAC3B,gCAAgC;IAChC,QAAQ,CAAC,MAAM,EAAE,YAAY,CAAC;IAC9B,sCAAsC;IACtC,QAAQ,CAAC,WAAW,EAAE,OAAO,CAAC;IAC9B,yCAAyC;IACzC,QAAQ,CAAC,cAAc,EAAE,OAAO,CAAC;IACjC,sCAAsC;IACtC,QAAQ,CAAC,iBAAiB,EAAE,MAAM,CAAC;IACnC,4BAA4B;IAC5B,QAAQ,CAAC,SAAS,EAAE,KAAK,GAAG,IAAI,CAAC;IACjC,wCAAwC;IACxC,IAAI,EAAE,CAAC,IAAI,EAAE,OAAO,KAAK,IAAI,CAAC;IAC9B,oCAAoC;IACpC,SAAS,EAAE,MAAM,IAAI,CAAC;IACtB,iCAAiC;IACjC,UAAU,EAAE,MAAM,IAAI,CAAC;CACxB,CA4BA"}

package/dist/hooks/useSocket.svelte.js

@@ -0,0 +1,54 @@
+/**
+ * Hook to access WebSocket state and methods
+ */
+import { getAppStateContext } from '../state/context.js';
+/**
+ * Access WebSocket state and methods
+ *
+ * @example
+ * ```svelte
+ * <script>
+ *   import { useSocket } from '@happyvertical/smrt-svelte';
+ *
+ *   const socket = useSocket();
+ *
+ *   function sendPing() {
+ *     socket.send({ type: 'ping' });
+ *   }
+ * </script>
+ *
+ * <p>Status: {socket.status}</p>
+ * <p>Connected: {socket.isConnected}</p>
+ * <button onclick={sendPing} disabled={!socket.isConnected}>
+ *   Ping
+ * </button>
+ * ```
+ */
+export function useSocket() {
+    const app = getAppStateContext();
+    return {
+        get status() {
+            return app.state.socket.status;
+        },
+        get isConnected() {
+            return app.state.socket.status === 'connected';
+        },
+        get isReconnecting() {
+            return app.state.socket.status === 'reconnecting';
+        },
+        get reconnectAttempts() {
+            return app.state.socket.reconnectAttempts;
+        },
+        get lastError() {
+            return app.state.socket.lastError;
+        },
+        send: (data) => app.sendMessage(data),
+        reconnect: () => {
+            const config = app.socketConfig;
+            if (config) {
+                app.connectSocket(config);
+            }
+        },
+        disconnect: () => app.disconnectSocket(),
+    };
+}

package/dist/hooks/useTTS.svelte.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Hook for Text-to-Speech functionality
+ */
+import type { TTSOptions, TTSVoice } from '../browser-ai/index.js';
+/**
+ * Options for useTTS hook
+ */
+export interface UseTTSOptions {
+    /** Auto-initialize on mount */
+    autoInit?: boolean;
+    /** Default TTS options */
+    defaultOptions?: TTSOptions;
+}
+/**
+ * Return type for useTTS hook
+ */
+export interface UseTTSReturn {
+    /** Speak text */
+    speak: (text: string, options?: TTSOptions) => Promise<void>;
+    /** Stop speaking */
+    stop: () => void;
+    /** Pause speaking */
+    pause: () => void;
+    /** Resume speaking */
+    resume: () => void;
+    /** Initialize the adapter (called automatically if autoInit) */
+    initialize: () => Promise<void>;
+    /** Get available voices */
+    getVoices: () => TTSVoice[];
+    /** Current state (reactive) */
+    readonly isSpeaking: boolean;
+    readonly isPaused: boolean;
+    readonly isReady: boolean;
+    readonly isInitializing: boolean;
+    readonly error: Error | null;
+    readonly downloadProgress: number;
+}
+/**
+ * Hook for Text-to-Speech
+ *
+ * @example
+ * ```svelte
+ * <script>
+ *   import { useTTS } from '@happyvertical/smrt-svelte';
+ *
+ *   const tts = useTTS();
+ *   let text = 'Hello, world!';
+ *
+ *   async function handleSpeak() {
+ *     if (tts.isSpeaking) {
+ *       tts.stop();
+ *     } else {
+ *       await tts.speak(text);
+ *     }
+ *   }
+ * </script>
+ *
+ * <input bind:value={text} />
+ * <button onclick={handleSpeak}>
+ *   {tts.isSpeaking ? 'Stop' : 'Speak'}
+ * </button>
+ * ```
+ */
+export declare function useTTS(options?: UseTTSOptions): UseTTSReturn;
+//# sourceMappingURL=useTTS.svelte.d.ts.map

package/dist/hooks/useTTS.svelte.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useTTS.svelte.d.ts","sourceRoot":"","sources":["../../src/hooks/useTTS.svelte.ts"],"names":[],"mappings":"AAAA;;GAEG;AAGH,OAAO,KAAK,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,wBAAwB,CAAC;AAGnE;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B,+BAA+B;IAC/B,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,0BAA0B;IAC1B,cAAc,CAAC,EAAE,UAAU,CAAC;CAC7B;AAED;;GAEG;AACH,MAAM,WAAW,YAAY;IAC3B,iBAAiB;IACjB,KAAK,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,UAAU,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAC7D,oBAAoB;IACpB,IAAI,EAAE,MAAM,IAAI,CAAC;IACjB,qBAAqB;IACrB,KAAK,EAAE,MAAM,IAAI,CAAC;IAClB,sBAAsB;IACtB,MAAM,EAAE,MAAM,IAAI,CAAC;IACnB,gEAAgE;IAChE,UAAU,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IAChC,2BAA2B;IAC3B,SAAS,EAAE,MAAM,QAAQ,EAAE,CAAC;IAC5B,+BAA+B;IAC/B,QAAQ,CAAC,UAAU,EAAE,OAAO,CAAC;IAC7B,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC;IAC3B,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,QAAQ,CAAC,cAAc,EAAE,OAAO,CAAC;IACjC,QAAQ,CAAC,KAAK,EAAE,KAAK,GAAG,IAAI,CAAC;IAC7B,QAAQ,CAAC,gBAAgB,EAAE,MAAM,CAAC;CACnC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,MAAM,CAAC,OAAO,GAAE,aAAkB,GAAG,YAAY,CAsEhE"}

package/dist/hooks/useTTS.svelte.js

@@ -0,0 +1,93 @@
+/**
+ * Hook for Text-to-Speech functionality
+ */
+import { onDestroy } from 'svelte';
+import { getAppStateContext } from '../state/context.js';
+/**
+ * Hook for Text-to-Speech
+ *
+ * @example
+ * ```svelte
+ * <script>
+ *   import { useTTS } from '@happyvertical/smrt-svelte';
+ *
+ *   const tts = useTTS();
+ *   let text = 'Hello, world!';
+ *
+ *   async function handleSpeak() {
+ *     if (tts.isSpeaking) {
+ *       tts.stop();
+ *     } else {
+ *       await tts.speak(text);
+ *     }
+ *   }
+ * </script>
+ *
+ * <input bind:value={text} />
+ * <button onclick={handleSpeak}>
+ *   {tts.isSpeaking ? 'Stop' : 'Speak'}
+ * </button>
+ * ```
+ */
+export function useTTS(options = {}) {
+    const app = getAppStateContext();
+    // Auto-initialize if requested
+    if (options.autoInit) {
+        app.initializeTTS().catch(() => {
+            // Error is stored in state
+        });
+    }
+    const speak = async (text, ttsOptions) => {
+        await app.speak(text, {
+            ...options.defaultOptions,
+            ...ttsOptions,
+        });
+    };
+    const stop = () => {
+        app.stopSpeaking();
+    };
+    const pause = () => {
+        app.pauseSpeaking();
+    };
+    const resume = () => {
+        app.resumeSpeaking();
+    };
+    const initialize = async () => {
+        await app.initializeTTS();
+    };
+    const getVoices = () => {
+        return app.getTTSVoices();
+    };
+    // Cleanup on destroy
+    onDestroy(() => {
+        if (app.state.ai.tts.isSpeaking) {
+            app.stopSpeaking();
+        }
+    });
+    return {
+        speak,
+        stop,
+        pause,
+        resume,
+        initialize,
+        getVoices,
+        get isSpeaking() {
+            return app.state.ai.tts.isSpeaking;
+        },
+        get isPaused() {
+            return app.state.ai.tts.isPaused;
+        },
+        get isReady() {
+            return app.state.ai.tts.initState === 'ready';
+        },
+        get isInitializing() {
+            return app.state.ai.tts.initState === 'initializing';
+        },
+        get error() {
+            return app.state.ai.tts.error;
+        },
+        get downloadProgress() {
+            return app.state.ai.tts.downloadProgress?.percent ?? 0;
+        },
+    };
+}

package/dist/hooks/useTheme.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Hook for accessing theme context
+ */
+import { type ThemeContext } from '@happyvertical/smrt-ui/theme';
+/**
+ * Get theme context (throws if not available)
+ */
+export declare function useTheme(): ThemeContext;
+/**
+ * Try to get theme context (returns null if not available)
+ */
+export declare function useTryTheme(): ThemeContext | null;
+//# sourceMappingURL=useTheme.d.ts.map

package/dist/hooks/useTheme.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useTheme.d.ts","sourceRoot":"","sources":["../../src/hooks/useTheme.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAEL,KAAK,YAAY,EAElB,MAAM,8BAA8B,CAAC;AAEtC;;GAEG;AACH,wBAAgB,QAAQ,IAAI,YAAY,CAEvC;AAED;;GAEG;AACH,wBAAgB,WAAW,IAAI,YAAY,GAAG,IAAI,CAEjD"}

package/dist/hooks/useTheme.js

@@ -0,0 +1,16 @@
+/**
+ * Hook for accessing theme context
+ */
+import { getThemeContext, tryGetThemeContext, } from '@happyvertical/smrt-ui/theme';
+/**
+ * Get theme context (throws if not available)
+ */
+export function useTheme() {
+    return getThemeContext();
+}
+/**
+ * Try to get theme context (returns null if not available)
+ */
+export function useTryTheme() {
+    return tryGetThemeContext();
+}

package/dist/i18n/__tests__/server.spec.js

@@ -0,0 +1,50 @@
+/**
+ * Integration coverage for the server snapshot builder (S13 #1418): it seeds the
+ * languages registry from smrt-svelte's English defaults and resolves them into
+ * a template dictionary the client renders synchronously. Exercises the real
+ * `@happyvertical/smrt-languages` resolver (no DB → code-default layer only).
+ *
+ * `server.ts` imports the languages package root, whose `__smrt-register__`
+ * manifest side-effect throws under vitest's source-alias (it resolves
+ * `manifest.json` via the dev-server URL, not a file). That manifest is the
+ * ObjectRegistry's, unrelated to string resolution (which uses the separate
+ * LanguageRegistry), so we record-not-throw via SMRT_STRICT_REGISTRY=false set
+ * before a dynamic import of the module under test.
+ */
+import { afterEach, beforeAll, describe, expect, it, vi } from 'vitest';
+let buildI18nSnapshot;
+let defineMessages;
+let clearRegisteredMessages;
+beforeAll(async () => {
+    vi.stubEnv('SMRT_STRICT_REGISTRY', 'false');
+    ({ buildI18nSnapshot } = await import('../server.js'));
+    ({ defineMessages, clearRegisteredMessages } = await import('@happyvertical/smrt-ui/i18n'));
+});
+afterEach(() => {
+    clearRegisteredMessages();
+});
+describe('buildI18nSnapshot', () => {
+    it('resolves registered English defaults into a template dictionary', async () => {
+        defineMessages({
+            'ui.snapshot_test.empty': 'No data available',
+            'ui.snapshot_test.range': 'Showing {count} of {total}',
+        });
+        const snapshot = await buildI18nSnapshot({ locale: 'en' });
+        expect(snapshot.locale).toBe('en');
+        expect(snapshot.messages['ui.snapshot_test.empty']).toBe('No data available');
+        // Templates are shipped un-rendered; the client interpolates at call time.
+        expect(snapshot.messages['ui.snapshot_test.range']).toBe('Showing {count} of {total}');
+    });
+    it('honors an explicit key subset', async () => {
+        defineMessages({
+            'ui.snapshot_test.a': 'Alpha',
+            'ui.snapshot_test.b': 'Beta',
+        });
+        const snapshot = await buildI18nSnapshot({
+            locale: 'en',
+            keys: ['ui.snapshot_test.a'],
+        });
+        expect(snapshot.messages['ui.snapshot_test.a']).toBe('Alpha');
+        expect(snapshot.messages['ui.snapshot_test.b']).toBeUndefined();
+    });
+});