@kawaijs/renderer-dom 0.1.10 → 0.1.12

package/dist/renderer.js

@@ -1,645 +1,879 @@
-export function defaultAssetResolver(path, type) {
-    if (path.startsWith('http://') ||
-        path.startsWith('https://') ||
-        path.startsWith('data:') ||
-        path.startsWith('/') ||
-        path.startsWith('./')) {
-        return path;
-    }
-    if (type === 'background') {
-        const clean = path.replace(/^bg[\s_]+/i, '').trim();
-        return clean.includes('.') ? `assets/backgrounds/${clean}` : `assets/backgrounds/${clean}.svg`;
-    }
-    if (type === 'character') {
-        const clean = path.replace(/_/g, '/').replace(/\s+/g, '/').trim();
-        return clean.includes('.') ? `assets/characters/${clean}` : `assets/characters/${clean}.svg`;
-    }
-    if (type === 'audio') {
-        return path.includes('.') ? `assets/audio/${path}` : `assets/audio/${path}.mp3`;
-    }
-    return path;
-}
-/**
- * Preload all background and character assets mentioned in a story to eliminate visual flashes.
- */
-export function preloadStoryAssets(story, assetResolver = defaultAssetResolver) {
-    if (typeof window === 'undefined')
-        return;
-    const bgSet = new Set();
-    const charSet = new Set();
+import { AudioManager } from '@kawaijs/audio';
+import { SVG_ICONS } from './icons.js';
+import { defaultAssetResolver } from './types.js';
+import { StageLayerComponent } from './components/stage-layer.js';
+import { DialogueBoxComponent } from './components/dialogue-box.js';
+import { ChoiceMenuComponent } from './components/choice-menu.js';
+import { QuickMenuComponent } from './components/quick-menu.js';
+import { MainMenuComponent } from './components/main-menu.js';
+import { HotspotLayerComponent } from './components/hotspot-layer.js';
+import { showSaveLoadModal } from './modals/save-load-modal.js';
+import { showSettingsModal } from './modals/settings-modal.js';
+import { showHistoryModal } from './modals/history-modal.js';
+import { showAboutModal } from './modals/about-modal.js';
+import { showGalleryModal } from './modals/gallery-modal.js';
+import { showInputModal } from './modals/input-modal.js';
+import { escapeHtml } from './utils/rich-text.js';
+import { ViewportAdapter } from './layout/viewport-adapter.js';
+import { applyDocumentShareMeta, buildSceneShareMeta, resolveShareAssetUrl } from './share-meta.js';
+import { bindSwipeControls } from './touch.js';
+export * from './icons.js';
+export * from './types.js';
+export * from './asset-fallbacks.js';
+export * from './utils/rich-text.js';
+export * from './utils/focus-trap.js';
+export * from './layout/viewport-adapter.js';
+export * from './modals/save-load-modal.js';
+export * from './modals/settings-modal.js';
+export * from './modals/history-modal.js';
+export * from './modals/about-modal.js';
+export * from './modals/gallery-modal.js';
+export * from './modals/achievements-modal.js';
+export * from './modals/confirm-modal.js';
+export * from './modals/input-modal.js';
+export * from './components/main-menu.js';
+export * from './components/dialogue-box.js';
+export * from './components/choice-menu.js';
+export * from './components/quick-menu.js';
+export * from './components/stage-layer.js';
+export * from './components/vfx-layer.js';
+export * from './share-meta.js';
+export * from './embed.js';
+export * from './touch.js';
+export function extractGalleryItems(story) {
+    if (!story || !story.labels)
+        return [];
+    const itemsMap = new Map();
     for (const label of Object.values(story.labels)) {
         for (const inst of label) {
-            if (inst.type === 'scene' && inst.background) {
-                const clean = inst.background.replace(/^bg[\s_]+/i, '').trim();
-                bgSet.add(clean);
-            }
-            else if (inst.type === 'show') {
-                const key = inst.expression ? `${inst.character}/${inst.expression}` : inst.character;
-                charSet.add(key);
+            if (inst.type === 'cg' && inst.image) {
+                const id = inst.unlockId ?? inst.image;
+                if (!itemsMap.has(id)) {
+                    const rawBase = (inst.unlockId || inst.image).split(/[/\\]/).pop() || '';
+                    const cleanName = rawBase.replace(/^cg[\s_]+/i, '').replace(/\.[^/.]+$/, '').replace(/[_-]+/g, ' ');
+                    const title = cleanName ? cleanName.charAt(0).toUpperCase() + cleanName.slice(1) : 'Event CG';
+                    itemsMap.set(id, {
+                        id,
+                        title,
+                        image: inst.image
+                    });
+                }
             }
         }
     }
-    for (const bg of bgSet) {
-        const img = new Image();
-        img.src = assetResolver(bg, 'background');
-    }
-    for (const char of charSet) {
-        const img = new Image();
-        img.src = assetResolver(char, 'character');
-    }
+    return Array.from(itemsMap.values());
 }
 export class DOMRenderer {
     vm;
     container;
+    options;
     typewriterSpeed;
+    autoDelayMs;
+    musicVolume;
+    soundVolume;
     assetResolver;
+    mainMenuOptions;
+    audioManager;
     rootEl;
-    stageEl;
-    backgroundEl;
-    bgLayerA;
-    bgLayerB;
-    activeBgLayer = 'A';
-    currentBgUrl = '';
-    charactersEl;
-    activeCharacters = new Map();
-    dialogueBoxEl;
-    speakerTagEl;
-    dialogueTextEl;
-    choiceContainerEl;
-    backBtnEl;
-    currentTypewriterInterval = null;
-    isTypewriting = false;
-    fullCurrentText = '';
-    isChoicePending = false;
+    stageLayer;
+    dialogueBox;
+    choiceMenu;
+    hotspotLayer;
+    quickMenu;
+    mainMenu;
+    viewportAdapter;
+    appliedStyleTargets = new Set();
+    isAutoMode = false;
+    isSkipMode = false;
+    autoTimer = null;
+    skipInterval = null;
+    pauseTimer = null;
+    errorToastTimer = null;
+    advanceLockUntil = 0;
+    destroyed = false;
     unsubscribeVMState;
+    unsubscribeCamera;
+    unsubscribeAudio;
+    unsubscribeError;
     boundKeyHandler;
+    touchControls;
     constructor(vm, options) {
         this.vm = vm;
         this.container = options.container;
+        this.options = options;
         this.typewriterSpeed = options.typewriterSpeed ?? 20;
+        this.autoDelayMs = options.autoDelayMs ?? 1800;
         this.assetResolver = options.assetResolver ?? defaultAssetResolver;
+        let finalMainMenu = options.mainMenu;
+        if (options.embed) {
+            finalMainMenu = { ...finalMainMenu, enabled: false };
+        }
+        if (finalMainMenu?.enabled !== false && (!finalMainMenu?.galleryItems || finalMainMenu.galleryItems.length === 0)) {
+            const autoItems = extractGalleryItems(this.vm.getStory());
+            if (autoItems.length > 0) {
+                finalMainMenu = {
+                    ...finalMainMenu,
+                    galleryItems: autoItems
+                };
+            }
+        }
+        this.mainMenuOptions = finalMainMenu;
+        this.audioManager = options.audioManager ?? (typeof window !== 'undefined' ? new AudioManager() : undefined);
+        this.musicVolume = this.audioManager?.getMusicVolume?.() ?? 0.8;
+        this.soundVolume = this.audioManager?.getSoundVolume?.() ?? 1.0;
+        // Load saved settings if present
+        if (typeof localStorage !== 'undefined') {
+            try {
+                const saved = localStorage.getItem('kawaijs_settings');
+                if (saved) {
+                    const parsed = JSON.parse(saved);
+                    if (typeof parsed.typewriterSpeed === 'number')
+                        this.typewriterSpeed = parsed.typewriterSpeed;
+                    if (typeof parsed.autoDelayMs === 'number')
+                        this.autoDelayMs = parsed.autoDelayMs;
+                    if (typeof parsed.musicVolume === 'number') {
+                        this.musicVolume = parsed.musicVolume;
+                        this.audioManager?.setMusicVolume(this.musicVolume);
+                    }
+                    if (typeof parsed.soundVolume === 'number') {
+                        this.soundVolume = parsed.soundVolume;
+                        this.audioManager?.setSoundVolume(this.soundVolume);
+                    }
+                }
+            }
+            catch { }
+        }
         this.buildDOM();
         this.bindEvents();
         this.unsubscribeVMState = this.vm.onStateChange((state) => {
             this.render(state);
+            this.syncUrlLabel(state);
+            this.syncShareMeta(state);
+        });
+        this.unsubscribeCamera = this.vm.onCameraEvent((e) => {
+            if (e.action === 'flash') {
+                this.flashScreen();
+            }
+            else {
+                this.shakeScreen(e.action);
+            }
         });
-        // Render current initial state
-        this.render(this.vm.getState());
+        this.unsubscribeAudio = this.vm.onAudioEvent((event) => {
+            if (!this.audioManager)
+                return;
+            if (event.action === 'play' && event.track) {
+                const url = this.assetResolver(event.track, 'audio');
+                if (event.channel === 'music') {
+                    this.audioManager.playMusic?.(url, { fadein: event.fade, loop: event.loop });
+                }
+                else if (event.channel === 'sound') {
+                    this.audioManager.playSound?.(url);
+                }
+                else if (event.channel === 'voice') {
+                    this.audioManager.playVoice?.(url);
+                }
+            }
+            else if (event.action === 'stop') {
+                if (event.channel === 'music') {
+                    this.audioManager.stopMusic?.({ fadeout: event.fade });
+                }
+                else if (event.channel === 'sound') {
+                    this.audioManager.stopSound?.();
+                }
+                else if (event.channel === 'voice') {
+                    this.audioManager.stopVoice?.();
+                }
+            }
+        });
+        this.unsubscribeError = this.vm.onError((err) => {
+            this.showErrorToast(err.message);
+            this.options.onError?.(err);
+        });
+        // Default: Show Ren'Py-style Main Menu before entering story, unless explicitly disabled
+        if (this.mainMenuOptions?.enabled !== false) {
+            this.showMainMenu();
+        }
+        else {
+            this.render(this.vm.getState());
+        }
     }
     destroy() {
+        if (this.destroyed)
+            return;
+        this.destroyed = true;
         if (this.unsubscribeVMState) {
             this.unsubscribeVMState();
+            this.unsubscribeVMState = undefined;
+        }
+        if (this.unsubscribeCamera) {
+            this.unsubscribeCamera();
+            this.unsubscribeCamera = undefined;
+        }
+        if (this.unsubscribeAudio) {
+            this.unsubscribeAudio();
+            this.unsubscribeAudio = undefined;
+        }
+        if (this.audioManager && typeof this.audioManager.destroy === 'function') {
+            this.audioManager.destroy();
+        }
+        if (this.unsubscribeError) {
+            this.unsubscribeError();
+            this.unsubscribeError = undefined;
+        }
+        if (this.dialogueBox) {
+            this.dialogueBox.destroy();
         }
-        if (this.currentTypewriterInterval) {
-            clearInterval(this.currentTypewriterInterval);
+        if (this.hotspotLayer) {
+            this.hotspotLayer.destroy();
+        }
+        if (this.stageLayer) {
+            this.stageLayer.destroy();
+        }
+        if (this.viewportAdapter) {
+            this.viewportAdapter.destroy();
+            this.viewportAdapter = undefined;
+        }
+        if (this.autoTimer) {
+            clearTimeout(this.autoTimer);
+            this.autoTimer = null;
+        }
+        if (this.skipInterval) {
+            clearInterval(this.skipInterval);
+            this.skipInterval = null;
+        }
+        if (this.pauseTimer) {
+            clearTimeout(this.pauseTimer);
+            this.pauseTimer = null;
+        }
+        if (this.errorToastTimer) {
+            clearTimeout(this.errorToastTimer);
+            this.errorToastTimer = null;
         }
         if (this.boundKeyHandler && typeof window !== 'undefined') {
             window.removeEventListener('keydown', this.boundKeyHandler);
+            this.boundKeyHandler = undefined;
+        }
+        if (this.touchControls) {
+            this.touchControls.destroy();
+            this.touchControls = undefined;
         }
         this.container.innerHTML = '';
     }
-    shakeScreen() {
-        if (!this.stageEl)
-            return;
-        this.stageEl.classList.remove('kawa-shake');
-        // Trigger reflow to restart animation
-        void this.stageEl.offsetWidth;
-        this.stageEl.classList.add('kawa-shake');
+    showErrorToast(message) {
+        const existing = this.rootEl.querySelector('.kawa-error-toast');
+        if (existing)
+            existing.remove();
+        if (this.errorToastTimer) {
+            clearTimeout(this.errorToastTimer);
+            this.errorToastTimer = null;
+        }
+        const toast = document.createElement('div');
+        toast.className = 'kawa-error-toast';
+        toast.setAttribute('role', 'alert');
+        toast.innerHTML = `
+      <span>⚠️</span>
+      <span class="kawa-error-toast-msg">${escapeHtml(message)}</span>
+      <button type="button" class="kawa-error-toast-close" aria-label="Dismiss error">${SVG_ICONS.close}</button>
+    `;
+        toast.querySelector('.kawa-error-toast-close')?.addEventListener('click', () => {
+            toast.remove();
+        });
+        this.rootEl.appendChild(toast);
+        this.errorToastTimer = window.setTimeout(() => {
+            this.errorToastTimer = null;
+            if (toast.parentElement)
+                toast.remove();
+        }, 8000);
+    }
+    getViewportAdapter() {
+        return this.viewportAdapter;
+    }
+    shakeScreen(type = 'shake') {
+        this.stageLayer.shakeScreen(type);
     }
     flashScreen() {
-        if (!this.stageEl)
+        this.stageLayer.flashScreen();
+    }
+    toggleAutoMode(force) {
+        this.isAutoMode = force !== undefined ? force : !this.isAutoMode;
+        if (this.isAutoMode && this.isSkipMode) {
+            this.toggleSkipMode(false);
+        }
+        this.updateModeUI();
+        if (this.isAutoMode && !this.dialogueBox.getIsTypewriting()) {
+            this.scheduleAutoAdvance();
+        }
+        else if (!this.isAutoMode && this.autoTimer) {
+            clearTimeout(this.autoTimer);
+            this.autoTimer = null;
+        }
+    }
+    toggleSkipMode(force) {
+        this.isSkipMode = force !== undefined ? force : !this.isSkipMode;
+        if (this.isSkipMode && this.isAutoMode) {
+            this.toggleAutoMode(false);
+        }
+        this.updateModeUI();
+        // Suspend decorative particle loops while skipping to cut CPU during fast-forward.
+        this.stageLayer.vfxLayer.setSuspended(this.isSkipMode);
+        if (this.isSkipMode) {
+            if (this.autoTimer) {
+                clearTimeout(this.autoTimer);
+                this.autoTimer = null;
+            }
+            if (!this.skipInterval) {
+                // Coalesce advances (~10/s) instead of hammering every 55ms.
+                this.skipInterval = window.setInterval(() => {
+                    if (this.destroyed) {
+                        this.toggleSkipMode(false);
+                        return;
+                    }
+                    const state = this.vm.getState();
+                    if (state.isFinished ||
+                        (state.choices && state.choices.length > 0) ||
+                        (state.hotspots && state.hotspots.length > 0) ||
+                        state.pendingInput) {
+                        this.toggleSkipMode(false);
+                        return;
+                    }
+                    if (this.dialogueBox.getIsTypewriting()) {
+                        this.dialogueBox.finishTypewriter();
+                    }
+                    this.vm.next();
+                }, 100);
+            }
+        }
+        else {
+            if (this.skipInterval) {
+                clearInterval(this.skipInterval);
+                this.skipInterval = null;
+            }
+        }
+    }
+    showMainMenu() {
+        if (this.isAutoMode)
+            this.toggleAutoMode(false);
+        if (this.isSkipMode)
+            this.toggleSkipMode(false);
+        this.mainMenu.show();
+    }
+    hideMainMenu() {
+        this.mainMenu.hide();
+    }
+    isMainMenuActive() {
+        return this.mainMenu.isActive();
+    }
+    startNewGame() {
+        // Ignore residual click-through from the Start button onto the stage (Opera / touchpads).
+        this.advanceLockUntil = Date.now() + 350;
+        this.vm.start();
+        this.hideMainMenu();
+        this.mainMenuOptions?.onStart?.();
+    }
+    async continueLatestGame() {
+        const saveManager = this.vm.getSaveManager();
+        const slots = await saveManager.listSlots(10);
+        const validSlots = slots.filter((s) => s !== null);
+        if (validSlots.length === 0)
+            return false;
+        validSlots.sort((a, b) => b.timestamp - a.timestamp);
+        const latest = validSlots[0];
+        const ok = await this.vm.load(latest.id);
+        if (ok) {
+            this.hideMainMenu();
+            return true;
+        }
+        return false;
+    }
+    async showSaveLoadModal(mode) {
+        await showSaveLoadModal(this.rootEl, this.vm, mode, () => {
+            this.hideMainMenu();
+        });
+    }
+    showSettingsModal() {
+        showSettingsModal(this.rootEl, {
+            typewriterSpeed: this.typewriterSpeed,
+            autoDelayMs: this.autoDelayMs,
+            musicVolume: this.musicVolume,
+            soundVolume: this.soundVolume,
+            onSettingsChange: (s) => {
+                this.typewriterSpeed = s.typewriterSpeed;
+                this.autoDelayMs = s.autoDelayMs;
+                if (s.musicVolume !== undefined) {
+                    this.musicVolume = s.musicVolume;
+                    this.audioManager?.setMusicVolume(this.musicVolume);
+                }
+                if (s.soundVolume !== undefined) {
+                    this.soundVolume = s.soundVolume;
+                    this.audioManager?.setSoundVolume(this.soundVolume);
+                }
+                this.dialogueBox.setTypewriterSpeed(this.typewriterSpeed);
+                this.saveSettings();
+            }
+        });
+    }
+    showHistoryModal() {
+        showHistoryModal(this.rootEl, this.vm);
+    }
+    showAboutModal() {
+        showAboutModal(this.rootEl, this.mainMenuOptions);
+    }
+    showGalleryModal() {
+        const galleryItems = this.mainMenuOptions?.galleryItems ?? [];
+        showGalleryModal(this.rootEl, this.vm, galleryItems, (path) => this.assetResolver(path, 'background'));
+    }
+    updateModeUI() {
+        this.quickMenu.setAutoActive(this.isAutoMode);
+        this.quickMenu.setSkipActive(this.isSkipMode);
+        if (this.isSkipMode) {
+            this.stageLayer.modeBadgeEl.innerHTML = `${SVG_ICONS.skip} SKIP`;
+            this.stageLayer.modeBadgeEl.style.display = 'inline-flex';
+        }
+        else if (this.isAutoMode) {
+            this.stageLayer.modeBadgeEl.innerHTML = `${SVG_ICONS.auto} AUTO`;
+            this.stageLayer.modeBadgeEl.style.display = 'inline-flex';
+        }
+        else {
+            this.stageLayer.modeBadgeEl.style.display = 'none';
+        }
+    }
+    scheduleAutoAdvance() {
+        if (this.autoTimer) {
+            clearTimeout(this.autoTimer);
+            this.autoTimer = null;
+        }
+        if (!this.isAutoMode)
             return;
-        const existing = this.stageEl.querySelector('.kawa-flash-overlay');
-        if (existing)
-            existing.remove();
-        const flash = document.createElement('div');
-        flash.className = 'kawa-flash-overlay';
-        this.stageEl.appendChild(flash);
-        setTimeout(() => flash.remove(), 600);
+        const state = this.vm.getState();
+        if (state.isFinished ||
+            (state.choices && state.choices.length > 0) ||
+            (state.hotspots && state.hotspots.length > 0) ||
+            state.pendingInput) {
+            return;
+        }
+        const duration = Math.max(800, this.autoDelayMs + (state.dialogue?.text.length ?? 0) * 15);
+        this.autoTimer = window.setTimeout(() => {
+            if (this.isAutoMode) {
+                const cur = this.vm.getState();
+                if (!cur.isFinished &&
+                    (!cur.choices || cur.choices.length === 0) &&
+                    (!cur.hotspots || cur.hotspots.length === 0) &&
+                    !cur.pendingInput) {
+                    this.vm.next();
+                }
+            }
+        }, duration);
     }
     buildDOM() {
         this.container.innerHTML = '';
         this.rootEl = document.createElement('div');
         this.rootEl.className = 'kawa-root';
-        this.stageEl = document.createElement('div');
-        this.stageEl.className = 'kawa-stage';
-        this.stageEl.setAttribute('role', 'main');
-        this.stageEl.setAttribute('aria-label', 'Visual Novel Stage');
-        this.backgroundEl = document.createElement('div');
-        this.backgroundEl.className = 'kawa-background';
-        this.backgroundEl.setAttribute('aria-hidden', 'true');
-        this.bgLayerA = document.createElement('div');
-        this.bgLayerA.className = 'kawa-bg-layer active';
-        this.bgLayerB = document.createElement('div');
-        this.bgLayerB.className = 'kawa-bg-layer';
-        this.backgroundEl.appendChild(this.bgLayerA);
-        this.backgroundEl.appendChild(this.bgLayerB);
-        this.charactersEl = document.createElement('div');
-        this.charactersEl.className = 'kawa-characters kawa-sprites';
-        this.charactersEl.setAttribute('aria-hidden', 'true');
+        this.rootEl.style.touchAction = 'manipulation';
+        if (this.options.embed) {
+            this.rootEl.classList.add('kawa-embed');
+            this.rootEl.dataset.kawaEmbed = '1';
+        }
+        this.stageLayer = new StageLayerComponent(this.assetResolver);
         const uiLayerEl = document.createElement('div');
         uiLayerEl.className = 'kawa-ui-layer';
-        // Choice Container
-        this.choiceContainerEl = document.createElement('div');
-        this.choiceContainerEl.className = 'kawa-choice-container kawa-choices';
-        this.choiceContainerEl.setAttribute('role', 'group');
-        this.choiceContainerEl.setAttribute('aria-label', 'Choices');
-        this.choiceContainerEl.style.display = 'none';
-        // Dialogue Box
-        this.dialogueBoxEl = document.createElement('div');
-        this.dialogueBoxEl.className = 'kawa-dialogue-box kawa-dialogue';
-        this.dialogueBoxEl.setAttribute('role', 'region');
-        this.dialogueBoxEl.setAttribute('aria-label', 'Dialogue');
-        this.dialogueBoxEl.setAttribute('tabindex', '0');
-        this.speakerTagEl = document.createElement('div');
-        this.speakerTagEl.className = 'kawa-speaker-tag kawa-speaker';
-        this.dialogueTextEl = document.createElement('div');
-        this.dialogueTextEl.className = 'kawa-dialogue-text kawa-text';
-        this.dialogueTextEl.setAttribute('aria-live', 'polite');
-        const indicatorEl = document.createElement('div');
-        indicatorEl.className = 'kawa-continue-indicator';
-        indicatorEl.setAttribute('aria-hidden', 'true');
-        indicatorEl.innerHTML = '&#9660;';
-        this.dialogueBoxEl.appendChild(this.speakerTagEl);
-        this.dialogueBoxEl.appendChild(this.dialogueTextEl);
-        this.dialogueBoxEl.appendChild(indicatorEl);
-        // Quick Menu
-        const quickMenuEl = document.createElement('nav');
-        quickMenuEl.className = 'kawa-quick-menu';
-        quickMenuEl.setAttribute('role', 'toolbar');
-        quickMenuEl.setAttribute('aria-label', 'Game Menu');
-        this.backBtnEl = document.createElement('button');
-        this.backBtnEl.className = 'kawa-btn';
-        this.backBtnEl.textContent = 'Back';
-        this.backBtnEl.setAttribute('aria-label', 'Rollback to previous dialogue');
-        const histBtn = document.createElement('button');
-        histBtn.className = 'kawa-btn';
-        histBtn.textContent = 'History';
-        histBtn.setAttribute('aria-label', 'Open dialogue history log');
-        histBtn.addEventListener('click', (e) => {
-            e.stopPropagation();
-            this.showHistoryModal();
+        this.choiceMenu = this.options.components?.createChoiceMenu
+            ? this.options.components.createChoiceMenu({
+                onSelect: (index) => {
+                    this.vm.choose(index);
+                }
+            })
+            : new ChoiceMenuComponent({
+                onSelect: (index) => {
+                    this.vm.choose(index);
+                }
+            });
+        this.hotspotLayer = new HotspotLayerComponent((id) => {
+            this.vm.selectHotspot(id);
         });
-        const saveBtn = document.createElement('button');
-        saveBtn.className = 'kawa-btn';
-        saveBtn.textContent = 'Save';
-        saveBtn.setAttribute('aria-label', 'Open save game menu');
-        saveBtn.addEventListener('click', (e) => {
-            e.stopPropagation();
-            this.showSaveLoadModal('save');
+        this.dialogueBox = this.options.components?.createDialogueBox
+            ? this.options.components.createDialogueBox(this.typewriterSpeed)
+            : new DialogueBoxComponent(this.typewriterSpeed);
+        this.quickMenu = new QuickMenuComponent({
+            onTitle: () => this.showMainMenu(),
+            onBack: () => {
+                if (this.isAutoMode)
+                    this.toggleAutoMode(false);
+                if (this.isSkipMode)
+                    this.toggleSkipMode(false);
+                this.vm.rollback();
+            },
+            onHistory: () => this.showHistoryModal(),
+            onAuto: () => this.toggleAutoMode(),
+            onSkip: () => this.toggleSkipMode(),
+            onSave: () => void this.showSaveLoadModal('save'),
+            onLoad: () => void this.showSaveLoadModal('load'),
+            onSettings: () => this.showSettingsModal()
         });
-        const loadBtn = document.createElement('button');
-        loadBtn.className = 'kawa-btn';
-        loadBtn.textContent = 'Load';
-        loadBtn.setAttribute('aria-label', 'Open load game menu');
-        loadBtn.addEventListener('click', (e) => {
-            e.stopPropagation();
-            this.showSaveLoadModal('load');
+        if (this.options.features?.quickMenu === false || this.options.embed) {
+            this.quickMenu.el.style.display = 'none';
+        }
+        uiLayerEl.appendChild(this.choiceMenu.el);
+        uiLayerEl.appendChild(this.dialogueBox.el);
+        uiLayerEl.appendChild(this.quickMenu.el);
+        this.stageLayer.stageEl.appendChild(uiLayerEl);
+        this.stageLayer.stageEl.appendChild(this.hotspotLayer.el);
+        this.mainMenu = new MainMenuComponent(this.rootEl, this.vm, this.mainMenuOptions, {
+            onStartNewGame: () => this.startNewGame(),
+            onContinueGame: () => this.continueLatestGame(),
+            assetResolver: this.assetResolver,
+            getSettingsConfig: () => ({
+                typewriterSpeed: this.typewriterSpeed,
+                autoDelayMs: this.autoDelayMs,
+                musicVolume: this.musicVolume,
+                soundVolume: this.soundVolume,
+                onSettingsChange: (s) => {
+                    this.typewriterSpeed = s.typewriterSpeed;
+                    this.autoDelayMs = s.autoDelayMs;
+                    if (s.musicVolume !== undefined) {
+                        this.musicVolume = s.musicVolume;
+                        this.audioManager?.setMusicVolume(this.musicVolume);
+                    }
+                    if (s.soundVolume !== undefined) {
+                        this.soundVolume = s.soundVolume;
+                        this.audioManager?.setSoundVolume(this.soundVolume);
+                    }
+                    this.dialogueBox.setTypewriterSpeed(this.typewriterSpeed);
+                    this.saveSettings();
+                }
+            })
         });
-        quickMenuEl.appendChild(this.backBtnEl);
-        quickMenuEl.appendChild(histBtn);
-        quickMenuEl.appendChild(saveBtn);
-        quickMenuEl.appendChild(loadBtn);
-        uiLayerEl.appendChild(this.choiceContainerEl);
-        uiLayerEl.appendChild(this.dialogueBoxEl);
-        uiLayerEl.appendChild(quickMenuEl);
-        this.stageEl.appendChild(this.backgroundEl);
-        this.stageEl.appendChild(this.charactersEl);
-        this.stageEl.appendChild(uiLayerEl);
-        this.rootEl.appendChild(this.stageEl);
+        this.mainMenu.mount(this.stageLayer.stageEl);
+        this.rootEl.appendChild(this.stageLayer.stageEl);
         this.container.appendChild(this.rootEl);
+        this.viewportAdapter = new ViewportAdapter(this.container, this.stageLayer.stageEl, this.options.virtualCanvas);
     }
     bindEvents() {
-        // Clicking on dialogue advances or finishes typewriter
-        this.dialogueBoxEl.addEventListener('click', () => {
+        // Clicking on stage or dialogue box advances or finishes typewriter
+        this.stageLayer.stageEl.addEventListener('click', (e) => {
+            if (this.isMainMenuActive())
+                return;
+            const target = e.target;
+            if (target.closest('button') ||
+                target.closest('.kawa-quick-menu') ||
+                target.closest('.kawa-choice-container') ||
+                target.closest('.kawa-hotspot-layer') ||
+                target.closest('.kawa-modal-overlay') ||
+                target.closest('.kawa-ending-card')) {
+                return;
+            }
+            if (this.isAutoMode)
+                this.toggleAutoMode(false);
+            if (this.isSkipMode)
+                this.toggleSkipMode(false);
             this.handleUserAdvance();
         });
-        this.backBtnEl.addEventListener('click', (e) => {
-            e.stopPropagation();
-            this.vm.rollback();
-        });
         // Keyboard controls
         this.boundKeyHandler = (e) => {
-            // If modal is open, let Escape close it
+            const confirm = this.rootEl.querySelector('.kawa-confirm-overlay');
+            if (confirm) {
+                if (e.key === 'Escape') {
+                    e.preventDefault();
+                    confirm.remove();
+                }
+                return;
+            }
+            const lightbox = this.rootEl.querySelector('.kawa-gallery-lightbox');
+            if (lightbox) {
+                if (e.key === 'Escape') {
+                    e.preventDefault();
+                    lightbox.remove();
+                }
+                return;
+            }
             const modal = this.rootEl.querySelector('.kawa-modal-overlay');
             if (modal) {
                 if (e.key === 'Escape')
                     modal.remove();
                 return;
             }
+            if (this.isMainMenuActive()) {
+                return;
+            }
             if (e.code === 'Space' || e.code === 'Enter') {
-                // If focusing a button, let the default click happen
-                if (document.activeElement && document.activeElement.tagName === 'BUTTON') {
+                if (document.activeElement &&
+                    (document.activeElement.tagName === 'BUTTON' ||
+                        document.activeElement.tagName === 'INPUT' ||
+                        document.activeElement.tagName === 'TEXTAREA')) {
                     return;
                 }
                 e.preventDefault();
+                if (this.isAutoMode)
+                    this.toggleAutoMode(false);
+                if (this.isSkipMode)
+                    this.toggleSkipMode(false);
                 this.handleUserAdvance();
             }
             else if (e.code === 'Backspace') {
                 e.preventDefault();
+                if (this.isAutoMode)
+                    this.toggleAutoMode(false);
+                if (this.isSkipMode)
+                    this.toggleSkipMode(false);
                 this.vm.rollback();
             }
+            else if (e.key === 'a' || e.key === 'A') {
+                this.toggleAutoMode();
+            }
+            else if (e.key === 'Control') {
+                // Ctrl toggles skip (Ren'Py-style). Tab is left for accessibility focus navigation.
+                e.preventDefault();
+                this.toggleSkipMode();
+            }
             else if (e.key === 's' || e.key === 'S') {
-                this.showSaveLoadModal('save');
+                void this.showSaveLoadModal('save');
             }
             else if (e.key === 'l' || e.key === 'L') {
-                this.showSaveLoadModal('load');
+                void this.showSaveLoadModal('load');
             }
             else if (e.key === 'h' || e.key === 'H') {
                 this.showHistoryModal();
             }
+            else if (e.key === 'p' || e.key === 'P' || e.key === 'o' || e.key === 'O') {
+                this.showSettingsModal();
+            }
+            else if (e.key === 'Escape') {
+                this.showMainMenu();
+            }
         };
         if (typeof window !== 'undefined') {
             window.addEventListener('keydown', this.boundKeyHandler);
         }
+        // Mobile: swipe left = advance, swipe right = rollback
+        if (this.options.features?.touchGestures !== false) {
+            this.touchControls = bindSwipeControls(this.stageLayer.stageEl, {
+                onSwipeLeft: () => {
+                    if (this.isMainMenuActive())
+                        return;
+                    if (this.isAutoMode)
+                        this.toggleAutoMode(false);
+                    if (this.isSkipMode)
+                        this.toggleSkipMode(false);
+                    this.handleUserAdvance();
+                },
+                onSwipeRight: () => {
+                    if (this.isMainMenuActive())
+                        return;
+                    if (this.isAutoMode)
+                        this.toggleAutoMode(false);
+                    if (this.isSkipMode)
+                        this.toggleSkipMode(false);
+                    if (this.vm.canRollback())
+                        this.vm.rollback();
+                }
+            });
+        }
     }
     handleUserAdvance() {
-        if (this.isTypewriting) {
-            this.finishTypewriter();
+        if (this.isMainMenuActive())
+            return;
+        if (this.vm.getState().pendingInput)
+            return;
+        if (this.dialogueBox.getIsTypewriting()) {
+            this.dialogueBox.finishTypewriter();
+            const debounce = this.options.features?.advanceDebounceMs ?? 220;
+            this.advanceLockUntil = Date.now() + Math.max(0, debounce);
+            return;
         }
-        else {
-            this.vm.next();
+        if (Date.now() < this.advanceLockUntil) {
+            return;
         }
+        const state = this.vm.getState();
+        if (state.choices && state.choices.length > 0) {
+            return;
+        }
+        if (state.hotspots && state.hotspots.length > 0) {
+            return;
+        }
+        this.vm.next();
     }
-    render(state) {
-        this.isChoicePending = false;
-        this.backBtnEl.disabled = !this.vm.canRollback();
-        // 1. Dual-Layer Background Crossfading
-        if (state.visual.background) {
-            this.backgroundEl.dataset.transition = state.visual.transition ?? 'none';
-            const rawBg = state.visual.background;
-            const cleanBg = rawBg.replace(/^bg[\s_]+/i, '').trim();
-            const baseName = cleanBg.replace(/\.(svg|png|jpg|jpeg|webp)$/i, '');
-            const primaryUrl = this.assetResolver(cleanBg, 'background');
-            if (primaryUrl !== this.currentBgUrl) {
-                this.currentBgUrl = primaryUrl;
-                const incomingLayer = this.activeBgLayer === 'A' ? this.bgLayerB : this.bgLayerA;
-                const outgoingLayer = this.activeBgLayer === 'A' ? this.bgLayerA : this.bgLayerB;
-                incomingLayer.style.backgroundImage = `url("${primaryUrl}")`;
-                incomingLayer.classList.add('active');
-                outgoingLayer.classList.remove('active');
-                this.activeBgLayer = this.activeBgLayer === 'A' ? 'B' : 'A';
-                // Verify and fallback if image fails to load
-                const testImg = new Image();
-                testImg.onerror = () => {
-                    const fallbackPng = this.assetResolver(`${baseName}.png`, 'background');
-                    const img2 = new Image();
-                    img2.onload = () => {
-                        incomingLayer.style.backgroundImage = `url("${fallbackPng}")`;
-                    };
-                    img2.onerror = () => {
-                        incomingLayer.style.backgroundImage = 'radial-gradient(ellipse at center, #334155 0%, #0f172a 100%)';
-                    };
-                    img2.src = fallbackPng;
-                };
-                testImg.src = primaryUrl;
-            }
+    syncUrlLabel(state) {
+        if (!this.options.syncUrlLabel || typeof window === 'undefined' || typeof history === 'undefined') {
+            return;
+        }
+        const label = state.currentLabel;
+        if (!label || label.startsWith('__'))
+            return;
+        try {
+            const url = new URL(window.location.href);
+            if (url.searchParams.get('at') === label)
+                return;
+            url.searchParams.delete('label');
+            url.searchParams.set('at', label);
+            history.replaceState(null, '', `${url.pathname}${url.search}${url.hash}`);
+        }
+        catch {
+            // ignore malformed URL environments
+        }
+    }
+    syncShareMeta(state) {
+        const share = this.options.share;
+        if (!share && !this.options.syncUrlLabel)
+            return;
+        const pageUrl = typeof window !== 'undefined' ? window.location.href : undefined;
+        const meta = buildSceneShareMeta(this.vm.getStory(), state, share, pageUrl);
+        applyDocumentShareMeta({
+            ...meta,
+            image: meta.image ? resolveShareAssetUrl(meta.image) : undefined
+        }, share);
+    }
+    applyThemeAndStyles(state) {
+        if (state.theme) {
+            this.rootEl.dataset.kawaTheme = state.theme;
         }
         else {
-            this.currentBgUrl = '';
-            this.bgLayerA.classList.remove('active');
-            this.bgLayerB.classList.remove('active');
-        }
-        // 2. Character Sprites DOM Reconciliation
-        const currentChars = state.visual.characters;
-        const currentIds = new Set(Object.keys(currentChars));
-        // Remove sprites no longer active
-        for (const [id, record] of this.activeCharacters.entries()) {
-            if (!currentIds.has(id)) {
-                record.div.remove();
-                this.activeCharacters.delete(id);
-            }
+            delete this.rootEl.dataset.kawaTheme;
         }
-        // Add or update active sprites
-        for (const [charId, charState] of Object.entries(currentChars)) {
-            const posClass = `kawa-pos-${charState.position ?? 'center'}`;
-            const charAssetKey = charState.expression ? `${charId}/${charState.expression}` : charId;
-            const primarySpriteUrl = this.assetResolver(charAssetKey, 'character');
-            let existing = this.activeCharacters.get(charId);
-            if (!existing) {
-                const spriteDiv = document.createElement('div');
-                spriteDiv.className = `kawa-sprite ${posClass}`;
-                spriteDiv.dataset.character = charId;
-                if (charState.expression) {
-                    spriteDiv.dataset.expression = charState.expression;
-                }
-                const img = document.createElement('img');
-                img.src = primarySpriteUrl;
-                img.alt = `${charId} ${charState.expression ?? ''}`;
-                let fallbackStep = 0;
-                img.onerror = () => {
-                    fallbackStep++;
-                    if (fallbackStep === 1) {
-                        img.src = this.assetResolver(`${charAssetKey}.svg`, 'character');
-                    }
-                    else if (fallbackStep === 2 && charState.expression) {
-                        img.src = this.assetResolver(`${charId}_${charState.expression}`, 'character');
-                    }
-                    else if (fallbackStep === 3 && charState.expression) {
-                        img.src = this.assetResolver(`${charId}_${charState.expression}.svg`, 'character');
+        const nextTargets = new Set(Object.keys(state.styleClasses ?? {}));
+        for (const target of this.appliedStyleTargets) {
+            if (!nextTargets.has(target)) {
+                this.rootEl.classList.forEach((cls) => {
+                    if (cls.startsWith(`kawa-style-${target}-`)) {
+                        this.rootEl.classList.remove(cls);
                     }
-                    else {
-                        img.style.display = 'none';
-                        spriteDiv.style.width = '220px';
-                        spriteDiv.style.height = '420px';
-                        spriteDiv.style.background = 'rgba(244, 63, 94, 0.25)';
-                        spriteDiv.style.border = '2px dashed #f43f5e';
-                        spriteDiv.style.borderRadius = '16px';
-                        spriteDiv.style.display = 'flex';
-                        spriteDiv.style.alignItems = 'center';
-                        spriteDiv.style.justifyContent = 'center';
-                        spriteDiv.style.color = '#ffffff';
-                        spriteDiv.style.fontWeight = '600';
-                        spriteDiv.style.fontSize = '1.1rem';
-                        spriteDiv.textContent = `${charId}\n(${charState.expression ?? 'normal'})`;
-                    }
-                };
-                spriteDiv.appendChild(img);
-                this.charactersEl.appendChild(spriteDiv);
-                existing = {
-                    div: spriteDiv,
-                    img,
-                    expression: charState.expression,
-                    position: charState.position
-                };
-                this.activeCharacters.set(charId, existing);
+                });
             }
-            else {
-                // Update existing sprite classes and image if changed
-                existing.div.className = `kawa-sprite ${posClass}`;
-                if (charState.expression) {
-                    existing.div.dataset.expression = charState.expression;
-                }
-                else {
-                    delete existing.div.dataset.expression;
-                }
-                if (existing.expression !== charState.expression) {
-                    existing.expression = charState.expression;
-                    existing.img.style.display = 'block';
-                    existing.img.src = primarySpriteUrl;
+        }
+        for (const [target, name] of Object.entries(state.styleClasses ?? {})) {
+            const prefix = `kawa-style-${target}-`;
+            this.rootEl.classList.forEach((cls) => {
+                if (cls.startsWith(prefix) && cls !== `${prefix}${name}`) {
+                    this.rootEl.classList.remove(cls);
                 }
-            }
+            });
+            this.rootEl.classList.add(`${prefix}${name}`);
         }
-        // Render dialogue
-        if (state.dialogue) {
-            this.dialogueBoxEl.style.display = 'block';
-            if (state.dialogue.speakerDisplayName) {
-                this.speakerTagEl.style.display = 'inline-block';
-                this.speakerTagEl.textContent = state.dialogue.speakerDisplayName;
-                if (state.dialogue.speakerColor) {
-                    this.speakerTagEl.style.backgroundColor = state.dialogue.speakerColor;
+        this.appliedStyleTargets = nextTargets;
+    }
+    render(state) {
+        this.quickMenu.setBackDisabled(!this.vm.canRollback());
+        this.applyThemeAndStyles(state);
+        // Timed pause: auto-advance after pendingPauseMs (click still skips via handleUserAdvance)
+        if (this.pauseTimer) {
+            clearTimeout(this.pauseTimer);
+            this.pauseTimer = null;
+        }
+        if (state.pendingPauseMs != null && state.pendingPauseMs > 0 && !state.isFinished) {
+            const delay = state.pendingPauseMs;
+            this.pauseTimer = window.setTimeout(() => {
+                this.pauseTimer = null;
+                if (this.destroyed)
+                    return;
+                const cur = this.vm.getState();
+                if (cur.pendingPauseMs != null && !cur.isFinished) {
+                    this.vm.next();
                 }
-            }
-            else {
-                this.speakerTagEl.style.display = 'none';
-            }
-            this.startTypewriter(state.dialogue.text);
+            }, delay);
+        }
+        // 1. Background scene
+        this.stageLayer.updateBackground(state.visual.background, state.visual.transition);
+        // 2. Character sprites
+        this.stageLayer.updateCharacters(state.visual.characters);
+        // 3. VFX & Atmospheric Layer
+        this.stageLayer.updateVfx(state.visual.vfx);
+        // 4. Fullscreen CG Layer
+        this.stageLayer.updateCG(state.visual.activeCG);
+        // 5. Branching Choice Menu
+        this.choiceMenu.render(state.choices);
+        // 5b. CG / stage hotspots
+        this.hotspotLayer.render(state.hotspots);
+        // 6. Dialogue Box (respect `window hide` / `window show`)
+        if (state.windowVisible === false) {
+            this.dialogueBox.render(null);
         }
         else {
-            this.dialogueBoxEl.style.display = 'none';
+            this.dialogueBox.render(state.dialogue, () => {
+                if (this.isAutoMode &&
+                    !state.isFinished &&
+                    (!state.choices || state.choices.length === 0) &&
+                    (!state.hotspots || state.hotspots.length === 0) &&
+                    !state.pendingInput) {
+                    this.scheduleAutoAdvance();
+                }
+            });
         }
-        // Render choices
-        if (state.choices && state.choices.length > 0) {
-            this.choiceContainerEl.innerHTML = '';
-            this.choiceContainerEl.style.display = 'flex';
-            this.choiceContainerEl.style.pointerEvents = 'auto';
-            this.choiceContainerEl.style.opacity = '1';
-            state.choices.forEach((choice, index) => {
-                const btn = document.createElement('button');
-                btn.className = 'kawa-choice-btn kawa-choice';
-                btn.textContent = choice.text;
-                btn.addEventListener('click', (e) => {
-                    e.stopPropagation();
-                    if (this.isChoicePending)
-                        return;
-                    this.isChoicePending = true;
-                    this.choiceContainerEl.style.pointerEvents = 'none';
-                    this.choiceContainerEl.style.opacity = '0.5';
-                    this.vm.choose(index);
+        // 6b. Text input prompt (`input var "prompt"`)
+        if (state.pendingInput) {
+            if (!this.rootEl.querySelector('.kawa-input-overlay')) {
+                const prompt = state.pendingInput.prompt;
+                const current = typeof state.variables[state.pendingInput.variable] === 'string'
+                    ? String(state.variables[state.pendingInput.variable])
+                    : '';
+                showInputModal(this.rootEl, {
+                    prompt,
+                    defaultValue: current,
+                    onSubmit: (value) => this.vm.submitInput(value)
                 });
-                this.choiceContainerEl.appendChild(btn);
-            });
+            }
         }
         else {
-            this.choiceContainerEl.style.display = 'none';
+            this.rootEl.querySelector('.kawa-input-overlay')?.remove();
         }
-        // Render Ending Card if Story is Finished
+        // 7. Ending Screen if finished
         if (state.isFinished) {
-            this.choiceContainerEl.style.display = 'none';
-            const existingEnd = this.rootEl.querySelector('.kawa-ending-card');
-            if (!existingEnd) {
-                const endCard = document.createElement('div');
-                endCard.className = 'kawa-ending-card';
-                endCard.innerHTML = `
-          <div class="kawa-ending-title">🌸 The End</div>
-          <div class="kawa-ending-subtitle">Story complete! Thank you for playing.</div>
-          <div style="display:flex;gap:12px;margin-top:16px;">
-            <button class="kawa-btn kawa-btn-replay">🔄 Play Again</button>
-            <button class="kawa-btn kawa-btn-load-end">📂 Load Slot</button>
-          </div>
-        `;
-                endCard.querySelector('.kawa-btn-replay')?.addEventListener('click', () => {
-                    this.vm.jump('start');
-                });
-                endCard.querySelector('.kawa-btn-load-end')?.addEventListener('click', () => {
-                    this.showSaveLoadModal('load');
-                });
-                this.rootEl.appendChild(endCard);
-            }
+            this.renderEndingCard();
         }
         else {
-            const existingEnd = this.rootEl.querySelector('.kawa-ending-card');
-            if (existingEnd)
-                existingEnd.remove();
+            const endingEl = this.stageLayer.stageEl.querySelector('.kawa-ending-card');
+            if (endingEl)
+                endingEl.remove();
         }
     }
-    startTypewriter(text) {
-        if (this.currentTypewriterInterval) {
-            clearInterval(this.currentTypewriterInterval);
-        }
-        this.fullCurrentText = text;
-        if (this.typewriterSpeed <= 0) {
-            this.dialogueTextEl.textContent = text;
-            this.isTypewriting = false;
+    renderEndingCard() {
+        // Don't remount — recreating replayed the pop animation and looked like a jump.
+        if (this.stageLayer.stageEl.querySelector('.kawa-ending-card')) {
             return;
         }
-        this.isTypewriting = true;
-        let index = 0;
-        this.dialogueTextEl.textContent = '';
-        this.currentTypewriterInterval = window.setInterval(() => {
-            index += 1;
-            this.dialogueTextEl.textContent = this.fullCurrentText.slice(0, index);
-            if (index >= this.fullCurrentText.length) {
-                this.finishTypewriter();
-            }
-        }, this.typewriterSpeed);
-    }
-    finishTypewriter() {
-        if (this.currentTypewriterInterval) {
-            clearInterval(this.currentTypewriterInterval);
-            this.currentTypewriterInterval = null;
-        }
-        this.dialogueTextEl.textContent = this.fullCurrentText;
-        this.isTypewriting = false;
-    }
-    async showSaveLoadModal(mode) {
-        const existing = this.rootEl.querySelector('.kawa-modal-overlay');
-        if (existing)
-            existing.remove();
-        const overlay = document.createElement('div');
-        overlay.className = 'kawa-modal-overlay';
-        const card = document.createElement('div');
-        card.className = 'kawa-modal-card';
-        card.setAttribute('role', 'dialog');
-        card.setAttribute('aria-modal', 'true');
-        card.setAttribute('aria-label', mode === 'save' ? 'Save Game' : 'Load Game');
-        const header = document.createElement('div');
-        header.className = 'kawa-modal-header';
-        const title = document.createElement('div');
-        title.className = 'kawa-modal-title';
-        title.textContent = mode === 'save' ? '💾 Save Game' : '📂 Load Game';
-        const closeBtn = document.createElement('button');
-        closeBtn.className = 'kawa-btn';
-        closeBtn.textContent = '✕ Close';
-        closeBtn.setAttribute('aria-label', 'Close modal');
-        closeBtn.addEventListener('click', () => overlay.remove());
-        header.appendChild(title);
-        header.appendChild(closeBtn);
-        const body = document.createElement('div');
-        body.className = 'kawa-modal-body';
-        const grid = document.createElement('div');
-        grid.className = 'kawa-slots-grid';
-        const saveManager = this.vm.getSaveManager();
-        const slots = await saveManager.listSlots(6);
-        slots.forEach((slot, idx) => {
-            const slotNum = String(idx + 1);
-            const slotCard = document.createElement('div');
-            slotCard.className = 'kawa-slot-card';
-            const slotHeader = document.createElement('div');
-            slotHeader.className = 'kawa-slot-header';
-            const badge = document.createElement('span');
-            badge.className = 'kawa-slot-badge';
-            badge.textContent = `Slot ${slotNum}`;
-            const timeSpan = document.createElement('span');
-            timeSpan.className = 'kawa-slot-time';
-            timeSpan.textContent = slot ? new Date(slot.timestamp).toLocaleString() : 'Empty';
-            slotHeader.appendChild(badge);
-            slotHeader.appendChild(timeSpan);
-            slotCard.appendChild(slotHeader);
-            if (slot) {
-                const preview = document.createElement('div');
-                preview.className = 'kawa-slot-preview';
-                preview.textContent = slot.previewText || `Label: ${slot.snapshot.state.currentLabel}`;
-                slotCard.appendChild(preview);
-            }
-            else {
-                const emptyText = document.createElement('div');
-                emptyText.className = 'kawa-slot-empty-text';
-                emptyText.textContent = 'No save data';
-                slotCard.appendChild(emptyText);
-            }
-            const actions = document.createElement('div');
-            actions.className = 'kawa-slot-actions';
-            if (mode === 'save') {
-                const saveActionBtn = document.createElement('button');
-                saveActionBtn.className = 'kawa-slot-btn kawa-slot-btn-save';
-                saveActionBtn.textContent = 'Save Here';
-                saveActionBtn.setAttribute('aria-label', `Save to slot ${slotNum}`);
-                saveActionBtn.addEventListener('click', async () => {
-                    await this.vm.save(slotNum);
-                    overlay.remove();
-                    this.showSaveLoadModal('save');
-                });
-                actions.appendChild(saveActionBtn);
-            }
-            else {
-                if (slot) {
-                    const loadActionBtn = document.createElement('button');
-                    loadActionBtn.className = 'kawa-slot-btn kawa-slot-btn-load';
-                    loadActionBtn.textContent = 'Load';
-                    loadActionBtn.setAttribute('aria-label', `Load slot ${slotNum}`);
-                    loadActionBtn.addEventListener('click', async () => {
-                        const ok = await this.vm.load(slotNum);
-                        if (ok)
-                            overlay.remove();
-                    });
-                    actions.appendChild(loadActionBtn);
-                }
-            }
-            if (slot) {
-                const delBtn = document.createElement('button');
-                delBtn.className = 'kawa-slot-btn kawa-slot-btn-del';
-                delBtn.textContent = '🗑';
-                delBtn.title = 'Delete Save';
-                delBtn.setAttribute('aria-label', `Delete slot ${slotNum}`);
-                delBtn.addEventListener('click', async () => {
-                    await saveManager.deleteSlot(slotNum);
-                    overlay.remove();
-                    this.showSaveLoadModal(mode);
-                });
-                actions.appendChild(delBtn);
-            }
-            slotCard.appendChild(actions);
-            grid.appendChild(slotCard);
+        const endingCard = document.createElement('div');
+        endingCard.className = 'kawa-ending-card';
+        endingCard.setAttribute('role', 'alert');
+        endingCard.setAttribute('aria-label', 'Story Finished');
+        endingCard.innerHTML = `
+      <div class="kawa-ending-title">The End</div>
+      <div class="kawa-ending-subtitle">Thank you for playing!</div>
+    `;
+        const restartBtn = document.createElement('button');
+        restartBtn.type = 'button';
+        restartBtn.className = 'kawa-choice-btn kawa-ending-btn';
+        restartBtn.style.marginTop = '16px';
+        restartBtn.innerHTML = `${SVG_ICONS.replay} Play Again`;
+        restartBtn.addEventListener('click', (e) => {
+            e.preventDefault();
+            e.stopPropagation();
+            endingCard.remove();
+            this.startNewGame();
+        });
+        const menuBtn = document.createElement('button');
+        menuBtn.type = 'button';
+        menuBtn.className = 'kawa-choice-btn kawa-ending-btn';
+        menuBtn.style.marginTop = '10px';
+        menuBtn.innerHTML = `${SVG_ICONS.home} Main Menu`;
+        menuBtn.addEventListener('click', (e) => {
+            e.preventDefault();
+            e.stopPropagation();
+            endingCard.remove();
+            this.showMainMenu();
         });
-        body.appendChild(grid);
-        card.appendChild(header);
-        card.appendChild(body);
-        overlay.appendChild(card);
-        this.rootEl.appendChild(overlay);
+        endingCard.appendChild(restartBtn);
+        endingCard.appendChild(menuBtn);
+        this.stageLayer.stageEl.appendChild(endingCard);
     }
-    showHistoryModal() {
-        const existing = this.rootEl.querySelector('.kawa-modal-overlay');
-        if (existing)
-            existing.remove();
-        const overlay = document.createElement('div');
-        overlay.className = 'kawa-modal-overlay';
-        const card = document.createElement('div');
-        card.className = 'kawa-modal-card';
-        card.setAttribute('role', 'dialog');
-        card.setAttribute('aria-modal', 'true');
-        card.setAttribute('aria-label', 'Dialogue History');
-        const header = document.createElement('div');
-        header.className = 'kawa-modal-header';
-        const title = document.createElement('div');
-        title.className = 'kawa-modal-title';
-        title.textContent = '📜 Dialogue History';
-        const closeBtn = document.createElement('button');
-        closeBtn.className = 'kawa-btn';
-        closeBtn.textContent = '✕ Close';
-        closeBtn.setAttribute('aria-label', 'Close history modal');
-        closeBtn.addEventListener('click', () => overlay.remove());
-        header.appendChild(title);
-        header.appendChild(closeBtn);
-        const body = document.createElement('div');
-        body.className = 'kawa-modal-body';
-        const entries = this.vm.getHistoryManager().getEntries();
-        if (entries.length === 0) {
-            const emptyMsg = document.createElement('div');
-            emptyMsg.textContent = 'No dialogue history yet.';
-            emptyMsg.style.opacity = '0.6';
-            body.appendChild(emptyMsg);
-        }
-        else {
-            for (const entry of entries) {
-                const item = document.createElement('div');
-                item.className = 'kawa-history-item';
-                if (entry.speakerDisplayName) {
-                    const spk = document.createElement('div');
-                    spk.className = 'kawa-history-speaker';
-                    spk.textContent = entry.speakerDisplayName;
-                    item.appendChild(spk);
-                }
-                const txt = document.createElement('div');
-                txt.textContent = entry.text;
-                item.appendChild(txt);
-                body.appendChild(item);
+    saveSettings() {
+        if (typeof localStorage !== 'undefined') {
+            try {
+                localStorage.setItem('kawaijs_settings', JSON.stringify({
+                    typewriterSpeed: this.typewriterSpeed,
+                    autoDelayMs: this.autoDelayMs,
+                    musicVolume: this.musicVolume,
+                    soundVolume: this.soundVolume
+                }));
             }
+            catch { }
         }
-        card.appendChild(header);
-        card.appendChild(body);
-        overlay.appendChild(card);
-        this.rootEl.appendChild(overlay);
     }
 }
 //# sourceMappingURL=renderer.js.map