Upload 59 files

CHANGELOG.md

@@ -1,5 +1,12 @@
 # Virtual Kimi App Changelog
 
+# [1.1.6] - 2025-09-04
+
+### Bug Fixes
+
+- Fixed a bug where sliders refused the value 0 (0 was treated as falsy and reset to defaults).
+- Removed crossfade transition from video playback to avoid visual glitches during video changes.
+
 # [1.1.5] - 2025-09-03
 
 ### Bug Fixes

index.html

@@ -37,44 +37,25 @@
         content="Virtual AI companion with evolving personality and advanced voice recognition.">
     <meta property="twitter:image" content="kimi-icons/virtualkimi-logo.png">
 
-    <!-- Schema.org consolidated JSON-LD (WebPage + mainEntity SoftwareApplication) -->
+    <!-- Minimal Schema.org JSON-LD for SoftwareApplication -->
     <script type="application/ld+json">
-        {
-            "@context": "https://schema.org",
-            "@type": "WebPage",
-            "name": "Virtual Kimi - Virtual AI Companion",
-            "description": "Virtual Kimi, your virtual AI girlfriend and companion with an evolving personality, multi-provider AI support, advanced voice recognition and immersive interface.",
-            "url": "https://virtualkimi.com/virtual-kimi-app/index.html",
-            "mainEntity": {
+            {
+                "@context": "https://schema.org",
                 "@type": "SoftwareApplication",
-                "@id": "https://virtualkimi.com/virtual-kimi-app/#app",
                 "name": "Virtual Kimi",
-                "description": "Virtual Kimi, your virtual AI girlfriend and companion with an evolving personality, multi-provider AI support, voice recognition and immersive interface",
+                "url": "https://virtualkimi.com/virtual-kimi-app/index.html",
+                "description": "Virtual AI girlfriend and companion with evolving personality and voice interface.",
                 "applicationCategory": "AI Companion",
                 "operatingSystem": "Web Browser",
-                "offers": {
-                    "@type": "Offer",
-                    "price": "0",
-                    "priceCurrency": "USD"
-                },
-                "creator": {
-                    "@type": "Person",
-                    "name": "Jean & Kimi"
-                },
+                "author": { "@type": "Person", "name": "Jean & Kimi" },
                 "dateCreated": "2025-07-16",
-                "dateModified": "2025-09-03",
-                "version": "v1.1.5",
-                "features": [
-                    "Advanced voice recognition",
-                    "Evolving personality with 6 adjustable traits",
-                    "Premium LLM integration",
-                    "5 customizable visual themes",
-                    "Persistent memory",
-                    "Intelligent affection system"
-                ]
+                "dateModified": "2025-09-04",
+                "version": "v1.1.6",
+                "logo": { "@type": "ImageObject", "url": "https://virtualkimi.com/kimi-icons/virtualkimi-logo.png" },
+                "screenshot": ["https://virtualkimi.com/kimi-icons/virtualkimi-preview1.jpg","https://virtualkimi.com/kimi-icons/virtualkimi-preview2.jpg"],
+                "sameAs": ["https://x.com/virtualkimi","https://www.youtube.com/@VirtualKimi","https://github.com/virtualkimi"]
             }
-        }
-        </script>
+            </script>
 
     <!-- Favicon -->
     <link rel="icon" type="image/x-icon" href="favicon.ico">
@@ -1087,8 +1068,8 @@
                     <h3><i class="fas fa-code"></i> Technical Information</h3>
                     <div class="tech-info">
                         <p><strong>Created date :</strong> July 16, 2025</p>
-                        <p><strong>Version :</strong> v1.1.5</p>
-                        <p><strong>Last update :</strong> September 03, 2025</p>
+                        <p><strong>Version :</strong> v1.1.6</p>
+                        <p><strong>Last update :</strong> September 04, 2025</p>
                         <p><strong>Technologies :</strong> HTML5, CSS3, JavaScript ES6+, IndexedDB, Web Speech
                             API</p>
                         <p><strong>Status :</strong> ✅ Stable and functional</p>

kimi-css/kimi-style.css

@@ -119,9 +119,6 @@
     --mic-pulse-color: rgba(39, 174, 96, 0.5);
     --mic-pulse-listening-color: rgba(39, 174, 96, 0.4);
 
-    /* Video crossfade timing */
-    --video-fade-duration: 400ms;
-
     /* Cards & Stats */
     --card-bg: rgba(255, 255, 255, 0.02);
     --card-border: rgba(255, 255, 255, 0.05);
@@ -899,16 +896,9 @@ body {
     height: 100%;
     object-fit: contain;
     opacity: 0;
-    transition: opacity var(--video-fade-duration) cubic-bezier(0.4, 0, 0.2, 1);
     background-color: #1a1a1a;
-    will-change: opacity;
     backface-visibility: hidden;
-}
-
-.bg-video.transitioning {
-    opacity: 0;
-    transition: opacity var(--video-fade-duration) cubic-bezier(0.4, 0, 0.2, 1);
-    pointer-events: none;
+    transition: opacity 300ms cubic-bezier(0.4, 0, 0.2, 1);
 }
 
 .content-overlay {

kimi-js/kimi-config.js

@@ -113,10 +113,8 @@ window.KIMI_CONFIG.validate = function (value, type) {
     try {
         const range = this.RANGES[type];
         if (!range) return { valid: true, value };
-
         const numValue = parseFloat(value);
         if (isNaN(numValue)) return { valid: false, value: this.DEFAULTS[type] };
-
         const clampedValue = Math.max(range.min, Math.min(range.max, numValue));
         return { valid: true, value: clampedValue };
     } catch (error) {

kimi-js/kimi-module.js

@@ -1442,6 +1442,23 @@ async function sendMessage() {
 }
 
 function setupSettingsListeners(kimiDB, kimiMemory) {
+    // ---------------------------------------------------------------------------
+    // Slider value coercion utilities
+    // Ensures that numeric sliders preserve explicit 0 instead of falling back
+    // to defaults via the logical OR (||) operator. We only fall back when the
+    // parsed value is NaN or validation returns undefined (never when value === 0).
+    // Use coerceFloat / coerceInt in all handlers to standardize behavior.
+    // ---------------------------------------------------------------------------
+    const coerceFloat = (raw, fallback, validationValue) => {
+        if (validationValue !== undefined) return validationValue;
+        const parsed = parseFloat(raw);
+        return Number.isNaN(parsed) ? fallback : parsed;
+    };
+    const coerceInt = (raw, fallback, validationValue) => {
+        if (validationValue !== undefined) return validationValue;
+        const parsed = parseInt(raw, 10);
+        return Number.isNaN(parsed) ? fallback : parsed;
+    };
     const voiceRateSlider = document.getElementById("voice-rate");
     const voicePitchSlider = document.getElementById("voice-pitch");
     const voiceVolumeSlider = document.getElementById("voice-volume");
@@ -1526,7 +1543,7 @@ function setupSettingsListeners(kimiDB, kimiMemory) {
     if (voiceRateSlider) {
         const listener = e => {
             const validation = window.KimiValidationUtils?.validateRange(e.target.value, "voiceRate");
-            const value = validation?.value || parseFloat(e.target.value) || 1.1;
+            const value = coerceFloat(e.target.value, 1.1, validation?.value);
 
             document.getElementById("voice-rate-value").textContent = value;
             e.target.value = value; // Ensure slider shows validated value
@@ -1538,7 +1555,7 @@ function setupSettingsListeners(kimiDB, kimiMemory) {
     if (voicePitchSlider) {
         const listener = e => {
             const validation = window.KimiValidationUtils?.validateRange(e.target.value, "voicePitch");
-            const value = validation?.value || parseFloat(e.target.value) || 1.1;
+            const value = coerceFloat(e.target.value, 1.1, validation?.value);
 
             document.getElementById("voice-pitch-value").textContent = value;
             e.target.value = value;
@@ -1550,7 +1567,7 @@ function setupSettingsListeners(kimiDB, kimiMemory) {
     if (voiceVolumeSlider) {
         const listener = e => {
             const validation = window.KimiValidationUtils?.validateRange(e.target.value, "voiceVolume");
-            const value = validation?.value || parseFloat(e.target.value) || 0.8;
+            const value = coerceFloat(e.target.value, 0.8, validation?.value);
 
             document.getElementById("voice-volume-value").textContent = value;
             e.target.value = value;
@@ -1613,7 +1630,7 @@ function setupSettingsListeners(kimiDB, kimiMemory) {
     if (llmTemperatureSlider) {
         const listener = e => {
             const validation = window.KimiValidationUtils?.validateRange(e.target.value, "llmTemperature");
-            const value = validation?.value || parseFloat(e.target.value) || 0.9;
+            const value = coerceFloat(e.target.value, 0.9, validation?.value);
 
             document.getElementById("llm-temperature-value").textContent = value;
             e.target.value = value;
@@ -1625,7 +1642,7 @@ function setupSettingsListeners(kimiDB, kimiMemory) {
     if (llmMaxTokensSlider) {
         const listener = e => {
             const validation = window.KimiValidationUtils?.validateRange(e.target.value, "llmMaxTokens");
-            const value = validation?.value || parseInt(e.target.value) || 400;
+            const value = coerceInt(e.target.value, 400, validation?.value);
 
             document.getElementById("llm-max-tokens-value").textContent = value;
             e.target.value = value;
@@ -1637,7 +1654,7 @@ function setupSettingsListeners(kimiDB, kimiMemory) {
     if (llmTopPSlider) {
         const listener = e => {
             const validation = window.KimiValidationUtils?.validateRange(e.target.value, "llmTopP");
-            const value = validation?.value || parseFloat(e.target.value) || 0.9;
+            const value = coerceFloat(e.target.value, 0.9, validation?.value);
 
             document.getElementById("llm-top-p-value").textContent = value;
             e.target.value = value;
@@ -1649,7 +1666,7 @@ function setupSettingsListeners(kimiDB, kimiMemory) {
     if (llmFrequencyPenaltySlider) {
         const listener = e => {
             const validation = window.KimiValidationUtils?.validateRange(e.target.value, "llmFrequencyPenalty");
-            const value = validation?.value || parseFloat(e.target.value) || 0.9;
+            const value = coerceFloat(e.target.value, 0.9, validation?.value);
 
             document.getElementById("llm-frequency-penalty-value").textContent = value;
             e.target.value = value;
@@ -1661,7 +1678,7 @@ function setupSettingsListeners(kimiDB, kimiMemory) {
     if (llmPresencePenaltySlider) {
         const listener = e => {
             const validation = window.KimiValidationUtils?.validateRange(e.target.value, "llmPresencePenalty");
-            const value = validation?.value || parseFloat(e.target.value) || 0.8;
+            const value = coerceFloat(e.target.value, 0.8, validation?.value);
 
             document.getElementById("llm-presence-penalty-value").textContent = value;
             e.target.value = value;
@@ -1697,7 +1714,7 @@ function setupSettingsListeners(kimiDB, kimiMemory) {
     if (interfaceOpacitySlider) {
         const listener = e => {
             const validation = window.KimiValidationUtils?.validateRange(e.target.value, "interfaceOpacity");
-            const value = validation?.value || parseFloat(e.target.value) || 0.8;
+            const value = coerceFloat(e.target.value, 0.8, validation?.value);
 
             document.getElementById("interface-opacity-value").textContent = value;
             e.target.value = value;

kimi-js/kimi-plugin-manager.js

@@ -15,6 +15,16 @@ class KimiPluginManager {
             path.startsWith("kimi-plugins/")
         );
     }
+    // New: validate file name inside a plugin directory (relative path only)
+    isValidPluginFileName(file) {
+        return (
+            typeof file === "string" &&
+            /^[-a-zA-Z0-9_\/.]+$/.test(file) &&
+            !file.startsWith("/") &&
+            !file.includes("..") &&
+            !/^https?:\/:/i.test(file)
+        );
+    }
     async loadPlugins() {
         const pluginDirs = await this.getPluginDirs();
         this.plugins = [];
@@ -27,22 +37,17 @@ class KimiPluginManager {
 
                 // Basic manifest validation and path sanitization (deny external or absolute URLs)
                 const validTypes = new Set(["theme", "voice", "behavior"]);
-                const isSafePath = p =>
-                    typeof p === "string" &&
-                    /^[-a-zA-Z0-9_\/.]+$/.test(p) &&
-                    !p.startsWith("/") &&
-                    !p.includes("..") &&
-                    !/^https?:\/\//i.test(p);
+                // DEPRECATION: inlined isSafePath replaced by isValidPluginFileName()
 
                 if (!manifest.name || !manifest.type || !validTypes.has(manifest.type)) {
                     console.warn(`Invalid plugin manifest in ${dir}: missing name or invalid type`);
                     continue;
                 }
-                if (manifest.style && !isSafePath(manifest.style)) {
+                if (manifest.style && !this.isValidPluginFileName(manifest.style)) {
                     console.warn(`Blocked unsafe style path in ${dir}: ${manifest.style}`);
                     delete manifest.style;
                 }
-                if (manifest.main && !isSafePath(manifest.main)) {
+                if (manifest.main && !this.isValidPluginFileName(manifest.main)) {
                     console.warn(`Blocked unsafe main path in ${dir}: ${manifest.main}`);
                     delete manifest.main;
                 }

kimi-js/kimi-utils.js

@@ -20,24 +20,10 @@ window.KimiValidationUtils = {
         return div.innerHTML;
     },
     validateRange(value, key) {
-        const bounds = {
-            voiceRate: { min: 0.5, max: 2, def: 1.1 },
-            voicePitch: { min: 0.5, max: 2, def: 1.1 },
-            voiceVolume: { min: 0, max: 1, def: 0.8 },
-            llmTemperature: { min: 0, max: 1, def: 0.9 },
-            llmMaxTokens: { min: 1, max: 8192, def: 400 },
-            llmTopP: { min: 0, max: 1, def: 0.9 },
-            llmFrequencyPenalty: { min: 0, max: 2, def: 0.9 },
-            llmPresencePenalty: { min: 0, max: 2, def: 0.8 },
-            interfaceOpacity: { min: 0.1, max: 1, def: 0.8 }
-        };
-        const b = bounds[key] || { min: 0, max: 100, def: 0 };
-        const v = window.KimiSecurityUtils
-            ? window.KimiSecurityUtils.validateRange(value, b.min, b.max, b.def)
-            : isNaN(parseFloat(value))
-              ? b.def
-              : Math.max(b.min, Math.min(b.max, parseFloat(value)));
-        return { value: v, clamped: v !== parseFloat(value) };
+        if (!window.KimiRange) {
+            throw new Error("KimiRange not initialized before validateRange call");
+        }
+        return window.KimiRange.clamp(key, value);
     }
 };
 
@@ -90,6 +76,40 @@ const KimiProviderPlaceholders = {
 window.KimiProviderPlaceholders = KimiProviderPlaceholders;
 export { KimiProviderUtils, KimiProviderPlaceholders };
 
+// Unified range management (central source of truth for numeric clamping)
+// Keys map UI/logic identifiers to CONFIG constant names.
+window.KimiRange = {
+    KEY_MAP: {
+        voiceRate: "VOICE_RATE",
+        voicePitch: "VOICE_PITCH",
+        voiceVolume: "VOICE_VOLUME",
+        llmTemperature: "LLM_TEMPERATURE",
+        llmMaxTokens: "LLM_MAX_TOKENS",
+        llmTopP: "LLM_TOP_P",
+        llmFrequencyPenalty: "LLM_FREQUENCY_PENALTY",
+        llmPresencePenalty: "LLM_PRESENCE_PENALTY",
+        interfaceOpacity: "INTERFACE_OPACITY"
+    },
+    getBounds(key) {
+        try {
+            const configKey = this.KEY_MAP[key];
+            if (configKey && window.KIMI_CONFIG && window.KIMI_CONFIG.RANGES && window.KIMI_CONFIG.RANGES[configKey]) {
+                const range = window.KIMI_CONFIG.RANGES[configKey];
+                const def = window.KIMI_CONFIG.DEFAULTS?.[configKey] ?? range.min;
+                return { min: range.min, max: range.max, def };
+            }
+        } catch {}
+        return { min: 0, max: 100, def: 0 };
+    },
+    clamp(key, value) {
+        const b = this.getBounds(key);
+        const num = parseFloat(value);
+        if (isNaN(num)) return { value: b.def, clamped: true };
+        const v = Math.max(b.min, Math.min(b.max, num));
+        return { value: v, clamped: v !== num };
+    }
+};
+
 // Performance utility functions for debouncing and throttling
 window.KimiPerformanceUtils = {
     debounce: function (func, wait, immediate = false, context = null) {
@@ -201,12 +221,8 @@ class KimiSecurityUtils {
 
         switch (type) {
             case "html":
-                return input
-                    .replace(/&/g, "&")
-                    .replace(/</g, "&lt;")
-                    .replace(/>/g, "&gt;")
-                    .replace(/"/g, "&quot;")
-                    .replace(/'/g, "&#x27;");
+                // Reuse centralized escape logic (removes duplication with KimiValidationUtils.escapeHtml)
+                return window.KimiValidationUtils?.escapeHtml(input) || input;
             case "number":
                 const num = parseFloat(input);
                 return isNaN(num) ? 0 : num;
@@ -225,12 +241,6 @@ class KimiSecurityUtils {
         }
     }
 
-    static validateRange(value, min, max, defaultValue = 0) {
-        const num = parseFloat(value);
-        if (isNaN(num)) return defaultValue;
-        return Math.max(min, Math.min(max, num));
-    }
-
     static validateApiKey(key) {
         if (!key || typeof key !== "string") return false;
         if (window.KIMI_VALIDATORS && typeof window.KIMI_VALIDATORS.validateApiKey === "function") {
@@ -521,6 +531,42 @@ class KimiOverlayManager {
     open(name) {
         const el = this.overlays[name];
         if (el) el.classList.add("visible");
+        // Special handling: opening settings overlay sometimes causes active video to freeze (browser rendering stall)
+        if (name === "settings-overlay") {
+            const kv = window.kimiVideo;
+            if (kv && kv.activeVideo) {
+                // Short delay so layout / repaint settles before forcing playback
+                setTimeout(() => {
+                    try {
+                        const v = kv.activeVideo;
+                        if (!v) return;
+                        // If ended -> immediately cycle neutral to avoid static frame
+                        if (v.ended) {
+                            if (typeof kv.returnToNeutral === "function") kv.returnToNeutral();
+                        } else {
+                            // Near-end ( <400ms rest ) -> preemptively rotate to avoid stuck on last frame
+                            if (v.duration && !isNaN(v.duration) && v.duration - v.currentTime < 0.4) {
+                                if (typeof kv.returnToNeutral === "function") kv.returnToNeutral();
+                            } else if (v.paused) {
+                                v.play().catch(() => {});
+                            }
+                        }
+                        // Restart freeze watchdog if available
+                        if (typeof kv._startFreezeWatchdog === "function") kv._startFreezeWatchdog();
+                    } catch {}
+                }, 50);
+                // Deferred recheck (covers cases where autoplay is blocked after overlay animation)
+                setTimeout(() => {
+                    try {
+                        const v = kv.activeVideo;
+                        if (!v) return;
+                        if (!v.ended && (v.paused || v.readyState < 2)) {
+                            v.play().catch(() => {});
+                        }
+                    } catch {}
+                }, 600);
+            }
+        }
     }
     close(name) {
         const el = this.overlays[name];

kimi-js/kimi-videos.js

@@ -60,54 +60,13 @@ class KimiVideoManager {
         this._consecutiveErrorCount = 0;
         // Track per-video load attempts to adapt timeouts & avoid faux échecs
         this._videoAttempts = new Map();
-    }
 
-    //Centralized crossfade transition between two videos.
-    static crossfadeVideos(fromVideo, toVideo, duration = 300, onComplete) {
-        // Resolve duration from CSS variable if present
+        // Ensure the initially active video is visible (remove any stale inline opacity)
         try {
-            const cssDur = getComputedStyle(document.documentElement).getPropertyValue("--video-fade-duration").trim();
-            if (cssDur) {
-                // Convert CSS time to ms number if needed (e.g., '300ms' or '0.3s')
-                if (cssDur.endsWith("ms")) duration = parseFloat(cssDur);
-                else if (cssDur.endsWith("s")) duration = Math.round(parseFloat(cssDur) * 1000);
+            if (this.activeVideo && this.activeVideo.style && this.activeVideo.classList.contains("active")) {
+                this.activeVideo.style.opacity = ""; // rely purely on CSS class
             }
         } catch {}
-
-        // Preload and strict synchronization
-        const easing = "ease-in-out";
-        fromVideo.style.transition = `opacity ${duration}ms ${easing}`;
-        toVideo.style.transition = `opacity ${duration}ms ${easing}`;
-        // Prepare target video (opacity 0, top z-index)
-        toVideo.style.opacity = "0";
-        toVideo.style.zIndex = "2";
-        fromVideo.style.zIndex = "1";
-
-        // Start target video slightly before the crossfade
-        const startTarget = () => {
-            if (toVideo.paused) toVideo.play().catch(() => {});
-            // Lance le fondu croisé
-            setTimeout(() => {
-                fromVideo.style.opacity = "0";
-                toVideo.style.opacity = "1";
-            }, 20);
-            // After transition, adjust z-index and call the callback
-            setTimeout(() => {
-                fromVideo.style.zIndex = "1";
-                toVideo.style.zIndex = "2";
-                if (onComplete) onComplete();
-            }, duration + 30);
-        };
-
-        // If target video is not ready, wait for canplay
-        if (toVideo.readyState < 3) {
-            toVideo.addEventListener("canplay", startTarget, { once: true });
-            toVideo.load();
-        } else {
-            startTarget();
-        }
-        // Ensure source video is playing
-        if (fromVideo.paused) fromVideo.play().catch(() => {});
     }
 
     //Centralized video element creation utility.
@@ -119,7 +78,6 @@ class KimiVideoManager {
         video.muted = true;
         video.playsinline = true;
         video.preload = "auto";
-        video.style.opacity = "0";
         video.innerHTML =
             '<source src="" type="video/mp4" /><span data-i18n="video_not_supported">Your browser does not support the video tag.</span>';
         return video;
@@ -1376,10 +1334,11 @@ class KimiVideoManager {
         const fromVideo = this.activeVideo;
         const toVideo = this.inactiveVideo;
 
-        // Perform a JS-managed crossfade for smoother transitions
-        // Let crossfadeVideos resolve duration from CSS variable (--video-fade-duration)
-        this.constructor.crossfadeVideos(fromVideo, toVideo, undefined, () => {
-            // After crossfade completion, finalize state and classes
+        const finalizeSwap = () => {
+            // Clear any inline opacity to rely solely on class-based visibility
+            fromVideo.style.opacity = "";
+            toVideo.style.opacity = "";
+
             fromVideo.classList.remove("active");
             toVideo.classList.add("active");
 
@@ -1397,22 +1356,20 @@ class KimiVideoManager {
                             const src = this.activeVideo?.querySelector("source")?.getAttribute("src");
                             const info = { context: this.currentContext, emotion: this.currentEmotion };
                             console.log("🎬 VideoManager: Now playing:", src, info);
-                            // Recompute autoTransitionDuration from actual duration if available (C)
                             try {
                                 const d = this.activeVideo.duration;
                                 if (!isNaN(d) && d > 0.5) {
-                                    // Keep 1s headroom before natural end for auto scheduling
                                     const target = Math.max(1000, d * 1000 - 1100);
                                     this.autoTransitionDuration = target;
                                 } else {
-                                    this.autoTransitionDuration = 9900; // fallback for 10s clips
+                                    this.autoTransitionDuration = 9900;
                                 }
-                                // Dynamic neutral prefetch to widen diversity without burst
                                 this._prefetchNeutralDynamic();
                             } catch {}
                         } catch {}
                         this._switchInProgress = false;
                         this.setupEventListenersForContext(this.currentContext);
+                        this._startFreezeWatchdog();
                     })
                     .catch(error => {
                         console.warn("Failed to play video:", error);
@@ -1428,7 +1385,7 @@ class KimiVideoManager {
                         this.setupEventListenersForContext(this.currentContext);
                     });
             } else {
-                // Non-promise play fallback
+                // Non-promise fallback
                 this._switchInProgress = false;
                 try {
                     const d = this.activeVideo.duration;
@@ -1441,8 +1398,82 @@ class KimiVideoManager {
                     this._prefetchNeutralDynamic();
                 } catch {}
                 this.setupEventListenersForContext(this.currentContext);
+                this._startFreezeWatchdog();
             }
-        });
+        };
+
+        // Ensure target video is at start and attempt playback ahead of swap
+        try {
+            toVideo.currentTime = 0;
+        } catch {}
+        const ready = toVideo.readyState >= 2; // HAVE_CURRENT_DATA
+        if (!ready) {
+            const onReady = () => {
+                toVideo.removeEventListener("canplay", onReady);
+                finalizeSwap();
+            };
+            toVideo.addEventListener("canplay", onReady, { once: true });
+            // Trigger load if not already
+            try {
+                toVideo.load();
+            } catch {}
+            // Also try to play (some browsers will start buffering more aggressively)
+            toVideo.play().catch(() => {});
+        } else {
+            // Already ready -> swap immediately
+            toVideo.play().catch(() => {});
+            finalizeSwap();
+        }
+    }
+
+    // Watchdog to detect freeze when a 10s clip reaches end but 'ended' listener may not fire (browser quirk)
+    _startFreezeWatchdog() {
+        clearInterval(this._freezeInterval);
+        const v = this.activeVideo;
+        if (!v) return;
+        const CHECK_MS = 1000;
+        this._lastProgressTime = Date.now();
+        let lastTime = v.currentTime;
+        // Stalled detection via progress event
+        const onStalled = () => {
+            this._lastProgressTime = Date.now();
+        };
+        v.addEventListener("timeupdate", onStalled);
+        v.addEventListener("progress", onStalled);
+        this._freezeInterval = setInterval(() => {
+            if (v !== this.activeVideo) return; // switched
+            const dur = v.duration || 9.9; // assume 9.9s
+            const nearEnd = v.currentTime >= dur - 0.25; // last 250ms
+            const progressed = v.currentTime !== lastTime;
+            if (progressed) {
+                lastTime = v.currentTime;
+                this._lastProgressTime = Date.now();
+            }
+            // If near end and not auto-transitioned within 500ms, trigger manual neutral
+            if (nearEnd && Date.now() - this._lastProgressTime > 600) {
+                // Ensure we are not already neutral cycling
+                if (this.currentContext === "neutral") {
+                    // Pick another neutral to animate
+                    try {
+                        this.returnToNeutral();
+                    } catch {}
+                } else {
+                    if (!this._processPendingSwitches()) this.returnToNeutral();
+                }
+            }
+            // Extra safety: if video paused unexpectedly before end
+            if (!v.paused && !v.ended && Date.now() - this._lastProgressTime > 4000) {
+                try {
+                    v.play().catch(() => {});
+                } catch {}
+            }
+            // Cleanup if naturally ended (ended handler will schedule next)
+            if (v.ended) {
+                clearInterval(this._freezeInterval);
+                v.removeEventListener("timeupdate", onStalled);
+                v.removeEventListener("progress", onStalled);
+            }
+        }, CHECK_MS);
     }
 
     _prefetchNeutralDynamic() {

kimi-js/kimi-voices.js

@@ -498,9 +498,10 @@ class KimiVoiceManager {
     getVoicePreference(paramType, options = {}) {
         // Hierarchy: options > memory.preferences > kimiMemory.preferences > DOM element > default
         const defaults = {
-            rate: window.KIMI_CONFIG?.DEFAULTS?.VOICE_RATE || 1.1,
-            pitch: window.KIMI_CONFIG?.DEFAULTS?.VOICE_PITCH || 1.1,
-            volume: window.KIMI_CONFIG?.DEFAULTS?.VOICE_VOLUME || 0.8
+            // Use nullish coalescing to preserve explicit 0 values in config
+            rate: window.KIMI_CONFIG?.DEFAULTS?.VOICE_RATE ?? 1.1,
+            pitch: window.KIMI_CONFIG?.DEFAULTS?.VOICE_PITCH ?? 1.1,
+            volume: window.KIMI_CONFIG?.DEFAULTS?.VOICE_VOLUME ?? 0.8
         };
 
         const elementIds = {