@happyvertical/smrt-svelte 0.30.0 → 0.31.1

package/dist/state/app-state.svelte.js

@@ -7,6 +7,34 @@
 import { canEnableSmrtMode, detectCapabilities, getLLM, getSTT, getTTS, } from '../browser-ai/index.js';
 import { createInitialState, } from './app-state.js';
 import { getCachedLLM, getCachedSTT, getCachedTTS, setCachedLLM, setCachedSTT, setCachedTTS, updateLLMCacheState, updateSTTCacheState, updateTTSCacheState, } from './warm-clients.js';
+/**
+ * Module-scope record of the single active listener teardown for each warm
+ * adapter. Warm adapters live in the module-level cache and survive Provider
+ * remounts, so their event-listener `Set`s would otherwise accumulate one
+ * closure set per manager that ever subscribed (R1 leak). Keying the teardown
+ * by **adapter identity at module scope** (not a per-manager `WeakSet`)
+ * guarantees at most one live subscription per shared adapter: before a new
+ * manager subscribes, the previous owner's listeners are removed.
+ */
+const sttAdapterTeardowns = new WeakMap();
+const ttsAdapterTeardowns = new WeakMap();
+/**
+ * Structural equality for two AI configs (R3). Used to no-op `setAIConfig` when
+ * an inline `ai={{…}}` literal re-renders with the same effective settings but a
+ * new object identity. A shallow JSON compare is sufficient: AIConfig is a flat
+ * tree of plain primitives/objects with no functions or class instances.
+ */
+function configsEqual(a, b) {
+    if (a === b)
+        return true;
+    try {
+        return JSON.stringify(a) === JSON.stringify(b);
+    }
+    catch {
+        // Non-serializable (shouldn't happen for AIConfig) — treat as different.
+        return false;
+    }
+}
 /**
  * Reactive app state manager for Svelte 5
  */
@@ -19,13 +47,23 @@ export class SmrtAppStateManager {
     _aiConfig = null;
     _preloadScheduled = false;
     _idleCallbackId = null;
+    // Guards a single executePreload() pass from running concurrently. The
+    // Provider's `ai` $effect can re-fire setAIConfig on every parent render
+    // (inline `ai={{…}}` literal => new identity), and an `idle`/`eager` strategy
+    // would otherwise launch overlapping preloads that interleave aiLoading
+    // writes and double-download models (R3).
+    _preloadInFlight = false;
     // Socket management
     _socket = null;
     _socketConfig = null;
     _reconnectTimeout = null;
-    // Track adapters we've already subscribed to (prevents duplicate listeners)
-    _subscribedSTTAdapters = new WeakSet();
-    _subscribedTTSAdapters = new WeakSet();
+    // Adapters this manager currently owns a subscription on, mapped to the
+    // teardown that removes its listeners. Used both for dedup (skip re-subscribe
+    // when this manager already owns the adapter) and to unsubscribe on dispose()
+    // so a destroyed Provider stops pinning its `_state` proxy via the adapter's
+    // module-surviving listener `Set`s (R1).
+    _sttSubscriptions = new Map();
+    _ttsSubscriptions = new Map();
     constructor(options = {}) {
         this.options = options;
         this._aiConfig = options.ai ?? null;
@@ -98,9 +136,22 @@ export class SmrtAppStateManager {
     }
     // === AI Preloading Methods ===
     /**
-     * Set or update AI configuration
+     * Set or update AI configuration.
+     *
+     * No-ops when the incoming config is deep-equal to the current one. The
+     * Provider's `ai` $effect depends on the prop's identity, and the documented
+     * usage passes an inline `ai={{…}}` object literal — a fresh identity on every
+     * parent render. Without this guard each render would cancel the idle
+     * callback, reset `_preloadScheduled`, and re-schedule (and, for `eager`,
+     * re-launch a full preload), thrashing the scheduler and double-downloading
+     * models (R3).
      */
     setAIConfig(config) {
+        if (this._aiConfig && configsEqual(this._aiConfig, config)) {
+            // Same effective config (different object identity) — nothing to do.
+            this._aiConfig = config;
+            return;
+        }
         this._aiConfig = config;
         // Cancel any pending preload scheduling so we can re-schedule with new config
         if (this._idleCallbackId !== null &&
@@ -154,9 +205,30 @@ export class SmrtAppStateManager {
         this.executePreload();
     }
     /**
-     * Execute the preloading of configured adapters
+     * Execute the preloading of configured adapters.
+     *
+     * Re-entrancy guarded: an `idle`/`eager` strategy can be re-scheduled while a
+     * pass is still awaiting model downloads. Without the guard the overlapping
+     * passes interleave their aiLoading writes and double-download models (R3).
      */
     async executePreload() {
+        if (!this._aiConfig)
+            return;
+        if (this._preloadInFlight)
+            return;
+        this._preloadInFlight = true;
+        try {
+            await this.runPreload();
+        }
+        finally {
+            this._preloadInFlight = false;
+        }
+    }
+    /**
+     * The actual preload pass. Always invoked behind the `_preloadInFlight` guard
+     * in {@link executePreload}.
+     */
+    async runPreload() {
         if (!this._aiConfig)
             return;
         const adaptersToLoad = [];
@@ -174,7 +246,10 @@ export class SmrtAppStateManager {
             adaptersToLoad.push(`llm:${modelKey}`);
         }
         if (adaptersToLoad.length === 0) {
-            this.updateLoadingState({ phase: 'idle' });
+            // Reset loaded/failed too (R7) — the main path clears them via the
+            // 'checking' update below, so the early-return must not leave stale
+            // entries from a prior pass behind.
+            this.updateLoadingState({ phase: 'idle', loaded: [], failed: [] });
             return;
         }
         this.updateLoadingState({
@@ -482,41 +557,61 @@ export class SmrtAppStateManager {
         }
     }
     /**
-     * Subscribe to STT adapter events
-     * Only subscribes once per adapter instance to prevent duplicate listeners
+     * Subscribe to STT adapter events.
+     *
+     * Captures every unsubscribe handle the adapter returns and stores a single
+     * teardown both per-manager (called on dispose()) and at module scope keyed
+     * by adapter identity. Because warm adapters are shared singletons, any
+     * previous owner's listeners are torn down first — guaranteeing exactly one
+     * live listener set per adapter, with the latest manager owning it (R1).
      */
     subscribeToSTTEvents(adapter) {
-        // Prevent duplicate subscriptions
-        if (this._subscribedSTTAdapters.has(adapter)) {
+        // Dedup: this manager already owns the adapter's subscription.
+        if (this._sttSubscriptions.has(adapter)) {
             return;
         }
-        this._subscribedSTTAdapters.add(adapter);
-        adapter.onResult((result) => {
-            if (result.isFinal) {
-                // Accumulate final results (for continuous mode where multiple phrases are spoken)
-                const existing = this._state.ai.stt.lastResult;
-                if (existing) {
-                    this._state.ai.stt.lastResult = `${existing} ${result.text}`;
+        // Evict any prior owner (e.g. a destroyed Provider that failed to dispose)
+        // so the adapter never fires more than one manager's listeners.
+        sttAdapterTeardowns.get(adapter)?.();
+        const unsubs = [
+            adapter.onResult((result) => {
+                if (result.isFinal) {
+                    // Accumulate final results (continuous mode emits multiple phrases)
+                    const existing = this._state.ai.stt.lastResult;
+                    if (existing) {
+                        this._state.ai.stt.lastResult = `${existing} ${result.text}`;
+                    }
+                    else {
+                        this._state.ai.stt.lastResult = result.text;
+                    }
+                    this._state.ai.stt.interimResult = '';
                 }
                 else {
-                    this._state.ai.stt.lastResult = result.text;
+                    // Interim result - update live
+                    this._state.ai.stt.interimResult = result.text;
                 }
-                this._state.ai.stt.interimResult = '';
+            }),
+            adapter.onStart(() => {
+                this._state.ai.stt.isListening = true;
+            }),
+            adapter.onEnd(() => {
+                this._state.ai.stt.isListening = false;
+            }),
+            adapter.onError((error) => {
+                this._state.ai.stt.error = error;
+            }),
+        ];
+        const teardown = () => {
+            for (const unsub of unsubs) {
+                unsub();
             }
-            else {
-                // Interim result - update live
-                this._state.ai.stt.interimResult = result.text;
+            this._sttSubscriptions.delete(adapter);
+            if (sttAdapterTeardowns.get(adapter) === teardown) {
+                sttAdapterTeardowns.delete(adapter);
             }
-        });
-        adapter.onStart(() => {
-            this._state.ai.stt.isListening = true;
-        });
-        adapter.onEnd(() => {
-            this._state.ai.stt.isListening = false;
-        });
-        adapter.onError((error) => {
-            this._state.ai.stt.error = error;
-        });
+        };
+        this._sttSubscriptions.set(adapter, teardown);
+        sttAdapterTeardowns.set(adapter, teardown);
     }
     /**
      * Start STT listening
@@ -585,27 +680,44 @@ export class SmrtAppStateManager {
         }
     }
     /**
-     * Subscribe to TTS adapter events
-     * Only subscribes once per adapter instance to prevent duplicate listeners
+     * Subscribe to TTS adapter events.
+     *
+     * Mirrors {@link subscribeToSTTEvents}: captures unsubscribe handles, dedups
+     * per-manager, and evicts any prior owner so a shared warm adapter never
+     * pins more than one manager's `_state` proxy (R1).
      */
     subscribeToTTSEvents(adapter) {
-        // Prevent duplicate subscriptions
-        if (this._subscribedTTSAdapters.has(adapter)) {
+        // Dedup: this manager already owns the adapter's subscription.
+        if (this._ttsSubscriptions.has(adapter)) {
             return;
         }
-        this._subscribedTTSAdapters.add(adapter);
-        adapter.onStart(() => {
-            this._state.ai.tts.isSpeaking = true;
-            this._state.ai.tts.isPaused = false;
-        });
-        adapter.onEnd(() => {
-            this._state.ai.tts.isSpeaking = false;
-            this._state.ai.tts.isPaused = false;
-        });
-        adapter.onError((error) => {
-            this._state.ai.tts.error = error;
-            this._state.ai.tts.isSpeaking = false;
-        });
+        // Evict any prior owner so the adapter fires only this manager's listeners.
+        ttsAdapterTeardowns.get(adapter)?.();
+        const unsubs = [
+            adapter.onStart(() => {
+                this._state.ai.tts.isSpeaking = true;
+                this._state.ai.tts.isPaused = false;
+            }),
+            adapter.onEnd(() => {
+                this._state.ai.tts.isSpeaking = false;
+                this._state.ai.tts.isPaused = false;
+            }),
+            adapter.onError((error) => {
+                this._state.ai.tts.error = error;
+                this._state.ai.tts.isSpeaking = false;
+            }),
+        ];
+        const teardown = () => {
+            for (const unsub of unsubs) {
+                unsub();
+            }
+            this._ttsSubscriptions.delete(adapter);
+            if (ttsAdapterTeardowns.get(adapter) === teardown) {
+                ttsAdapterTeardowns.delete(adapter);
+            }
+        };
+        this._ttsSubscriptions.set(adapter, teardown);
+        ttsAdapterTeardowns.set(adapter, teardown);
     }
     /**
      * Speak text using TTS
@@ -726,12 +838,44 @@ export class SmrtAppStateManager {
      * Unload LLM model to free memory
      */
     async unloadLLM() {
-        await this._state.ai.llm.adapter?.unloadModel();
+        const adapter = this._state.ai.llm.adapter;
+        // Capture the model id BEFORE unloadModel(): a real WebLLM adapter clears
+        // `currentModel` on unload, so reading it afterward would key the cache
+        // downgrade off `undefined` and leave the actual `'ready'` entry stale (R2).
+        const unloadedModel = adapter?.currentModel ?? undefined;
+        await adapter?.unloadModel();
+        // Downgrade (or remove) the warm-cache entry for the unloaded model so a
+        // later initializeLLM() re-runs ensureInitialized() — re-downloading and
+        // reporting progress — instead of cache-hitting a `'ready'` entry whose
+        // model is now gone (R2). `unloadModel()` keeps the adapter instance
+        // reusable, so downgrade to `'uninitialized'` rather than dispose it.
+        if (adapter) {
+            updateLLMCacheState(adapter.type, unloadedModel, {
+                initState: 'uninitialized',
+                downloadProgress: null,
+                error: null,
+            });
+        }
         this._state.ai.llm.adapter = null;
         this._state.ai.llm.initState = 'uninitialized';
         this._state.ai.llm.currentModel = null;
     }
     // === Cleanup ===
+    /**
+     * Unsubscribe every adapter-event listener this manager owns (R1). Called on
+     * dispose() so a destroyed Provider stops being pinned by the shared warm
+     * adapters' module-surviving listener `Set`s.
+     */
+    unsubscribeAllAdapterEvents() {
+        for (const teardown of [...this._sttSubscriptions.values()]) {
+            teardown();
+        }
+        for (const teardown of [...this._ttsSubscriptions.values()]) {
+            teardown();
+        }
+        this._sttSubscriptions.clear();
+        this._ttsSubscriptions.clear();
+    }
     /**
      * Dispose of all resources
      */
@@ -742,12 +886,38 @@ export class SmrtAppStateManager {
             cancelIdleCallback(this._idleCallbackId);
             this._idleCallbackId = null;
         }
+        // Stop any in-flight preload so it can't write to a torn-down state (R3).
+        this._preloadInFlight = false;
         // Disconnect socket
         this.disconnectSocket();
-        // Dispose AI adapters (but don't clear the cache - they survive navigation)
-        await this._state.ai.stt.adapter?.dispose();
-        await this._state.ai.tts.adapter?.dispose();
-        await this._state.ai.llm.adapter?.dispose();
+        // Remove this manager's adapter-event listeners (R1).
+        this.unsubscribeAllAdapterEvents();
+        // Adapter lifecycle is owned by the warm cache (it survives navigation by
+        // design). For adapters this manager holds that the cache no longer tracks
+        // — e.g. an instance orphaned by a mid-session type switch — dispose them
+        // directly so they don't leak. Adapters still backed by a warm-cache entry
+        // are left intact and genuinely `'ready'`; previously they were disposed
+        // here yet left cached as `'ready'`, so the next init cache-hit restored a
+        // dead engine with no download progress (R2). Full teardown remains
+        // available via `clearAllCaches()`.
+        //
+        // NOTE: state adapters are `$state` proxies, so identity (`!==`) comparison
+        // against the raw cached instance is unreliable (Svelte proxy-equality
+        // gotcha). Gate on whether the cache *has* a live entry for the adapter's
+        // type/model instead of comparing instances.
+        const sttAdapter = this._state.ai.stt.adapter;
+        if (sttAdapter && !getCachedSTT(sttAdapter.type)) {
+            await sttAdapter.dispose?.();
+        }
+        const ttsAdapter = this._state.ai.tts.adapter;
+        if (ttsAdapter && !getCachedTTS(ttsAdapter.type)) {
+            await ttsAdapter.dispose?.();
+        }
+        const llmAdapter = this._state.ai.llm.adapter;
+        if (llmAdapter &&
+            !getCachedLLM(llmAdapter.type, llmAdapter.currentModel ?? undefined)) {
+            await llmAdapter.dispose?.();
+        }
         this._state = createInitialState();
     }
     /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@happyvertical/smrt-svelte",
-  "version": "0.30.0",
+  "version": "0.31.1",
   "description": "Svelte 5 components for SMRT user management - auth, users, tenants, roles, permissions, groups",
   "type": "module",
   "main": "./dist/index.js",
@@ -81,11 +81,12 @@
     "access": "public"
   },
   "dependencies": {
+    "@happyvertical/logger": "^0.74.7",
     "esm-env": "^1.2.2",
-    "@happyvertical/smrt-languages": "0.30.0",
-    "@happyvertical/smrt-types": "0.30.0",
-    "@happyvertical/smrt-ui": "0.30.0",
-    "@happyvertical/smrt-agents": "0.30.0"
+    "@happyvertical/smrt-agents": "0.31.1",
+    "@happyvertical/smrt-types": "0.31.1",
+    "@happyvertical/smrt-languages": "0.31.1",
+    "@happyvertical/smrt-ui": "0.31.1"
   },
   "peerDependencies": {
     "@huggingface/transformers": ">=3.0.0",