@luna-editor/engine 0.2.0 → 0.3.1

package/dist/plugin/PluginManager.js

@@ -7,54 +7,174 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-/* eslint-disable @typescript-eslint/no-explicit-any */
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
 import React from "react";
 import { useScreenSizeAtom } from "../atoms/screen-size";
 import { useDataAPI } from "../contexts/DataContext";
+import { getFontFamilyStyle, getUIFontFamilyStyle, } from "../hooks/useFontLoader";
 import { usePluginAPI, useUIVisibility } from "../hooks/usePluginAPI";
 import { useScreenScale, useScreenSize, useToPixel, } from "../hooks/useScreenSize";
-import { ComponentType, } from "../sdk";
+import { ComponentType, definePlugin, } from "../sdk";
+// グローバルなロード状態管理（複数のPluginManagerインスタンス間で共有）
+const globalLoadingPlugins = new Map();
+const globalLoadedPlugins = new Map();
 export class PluginManager {
     constructor() {
         this.plugins = new Map();
         this.styleElements = new Map();
+        this.originalClassNames = new Map(); // 元のクラス名を保持
         this.injectedStyles = new Set();
         this.storage = new Map();
         this.componentRegistry = new Map();
         this.uiVisibilityState = new Map();
         this.uiVisibilityListeners = new Map();
+        this.selectChoiceCallback = null;
+        this.getBranchStateCallback = null;
+        this.emotionEffectUpdaterCallback = null;
+        this.dataContextGetter = null;
+        this.preloadPromises = [];
+        this.muteAudio = false;
+        // 作品のサウンドデータ（ID → URL）
+        this.workSounds = new Map();
+        // ビルトインのクリック音設定
+        this.clickSoundUrl = null;
+        this.clickSoundVolume = 0.5;
+        // プラグインによるクリック音の上書きフラグ
+        this.clickSoundOverridden = false;
         this.initializeReactRuntime();
     }
+    /**
+     * 開発環境かどうかを判定
+     * localhost、127.0.0.1、またはポート3000で実行されている場合に true を返す
+     */
+    isDevelopment() {
+        if (typeof window === "undefined") {
+            return false;
+        }
+        return (window.location.hostname === "localhost" ||
+            window.location.hostname === "127.0.0.1" ||
+            window.location.port === "3000");
+    }
     /**
      * グローバルReactランタイムを初期化（クライアントサイドのみ）
+     * 既に初期化済みの場合はスキップ
      */
     initializeReactRuntime() {
         // サーバーサイドではスキップ
         if (typeof window === "undefined") {
             return;
         }
+        const globalWindow = window;
+        // 既に初期化済みの場合はスキップ
+        if (globalWindow.__LUNA_REACT_RUNTIME_INITIALIZED__) {
+            return;
+        }
+        globalWindow.__LUNA_REACT_RUNTIME_INITIALIZED__ = true;
         // JSXランタイム
-        window.__LUNA_JSX_RUNTIME__ = {
+        globalWindow.__LUNA_JSX_RUNTIME__ = {
             jsx: (type, props, key) => {
-                return React.createElement(type, key ? Object.assign(Object.assign({}, props), { key }) : props);
+                const { children } = props, restProps = __rest(props, ["children"]);
+                const propsWithKey = key ? Object.assign(Object.assign({}, restProps), { key }) : restProps;
+                return children !== undefined
+                    ? React.createElement(type, propsWithKey, children)
+                    : React.createElement(type, propsWithKey);
             },
             jsxs: (type, props, key) => {
-                return React.createElement(type, key ? Object.assign(Object.assign({}, props), { key }) : props);
+                const { children } = props, restProps = __rest(props, ["children"]);
+                const propsWithKey = key ? Object.assign(Object.assign({}, restProps), { key }) : restProps;
+                // jsxsはchildren配列をスプレッドして渡す
+                return Array.isArray(children)
+                    ? React.createElement(type, propsWithKey, ...children)
+                    : React.createElement(type, propsWithKey, children);
             },
             Fragment: React.Fragment,
         };
         // Reactランタイム (useDataAPIフックと画面サイズフックを含む)
-        window.__LUNA_REACT_RUNTIME__ = Object.assign(Object.assign({}, React), { default: React, useDataAPI,
+        globalWindow.__LUNA_REACT_RUNTIME__ = Object.assign(Object.assign({}, React), { default: React, useDataAPI,
             usePluginAPI,
             useUIVisibility,
             useToPixel,
             useScreenSize,
             useScreenScale,
             useScreenSizeAtom,
-            ComponentType });
-        console.log("🔧 Luna React Runtime initialized for JSX support with hooks and screen size system");
+            ComponentType,
+            definePlugin,
+            getFontFamilyStyle,
+            getUIFontFamilyStyle });
     }
-    loadPlugin(packageName, bundleUrl, config) {
+    loadPlugin(packageName, bundleUrl, config, assets) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // 開発環境ではキャッシュをバイパスして常に最新コードをロード
+            const isDevelopment = this.isDevelopment();
+            if (isDevelopment) {
+                // 開発環境では強制リロード（キャッシュをクリア）
+                globalLoadedPlugins.delete(packageName);
+                this.plugins.delete(packageName);
+                // ロード中のPromiseもクリア（再ロードを確実にするため）
+                globalLoadingPlugins.delete(packageName);
+            }
+            else {
+                // 本番環境のみキャッシュを使用
+                // グローバルに既にロード済みの場合はローカルにコピーしてスキップ
+                const globalLoaded = globalLoadedPlugins.get(packageName);
+                if (globalLoaded) {
+                    // 新しいconfigで更新したコピーを作成
+                    const updatedPlugin = Object.assign(Object.assign({}, globalLoaded), { config: config !== null && config !== void 0 ? config : globalLoaded.config });
+                    this.plugins.set(packageName, updatedPlugin);
+                    // コンポーネントレジストリにも登録
+                    for (const [type, component] of globalLoaded.instance.components) {
+                        this.componentRegistry.set(type, component);
+                    }
+                    return;
+                }
+            }
+            if (!isDevelopment) {
+                // 本番環境のみ：ローカルに既にロード済みの場合はconfigだけ更新してスキップ
+                const localLoaded = this.plugins.get(packageName);
+                if (localLoaded) {
+                    // configを更新
+                    localLoaded.config = config !== null && config !== void 0 ? config : localLoaded.config;
+                    return;
+                }
+                // 本番環境のみ：グローバルでロード中の場合はそのPromiseを待つ
+                const existingLoadPromise = globalLoadingPlugins.get(packageName);
+                if (existingLoadPromise) {
+                    yield existingLoadPromise;
+                    // ロード完了後にグローバルからコピー（新しいconfigで更新）
+                    const loaded = globalLoadedPlugins.get(packageName);
+                    if (loaded) {
+                        const updatedPlugin = Object.assign(Object.assign({}, loaded), { config: config !== null && config !== void 0 ? config : loaded.config });
+                        this.plugins.set(packageName, updatedPlugin);
+                        for (const [type, component] of loaded.instance.components) {
+                            this.componentRegistry.set(type, component);
+                        }
+                    }
+                    return;
+                }
+            }
+            // ロード処理をPromiseとして保存
+            const loadPromise = this.doLoadPlugin(packageName, bundleUrl, config, assets);
+            globalLoadingPlugins.set(packageName, loadPromise);
+            try {
+                yield loadPromise;
+            }
+            finally {
+                // ロード完了後にマップから削除
+                globalLoadingPlugins.delete(packageName);
+            }
+        });
+    }
+    doLoadPlugin(packageName, bundleUrl, config, assets) {
         return __awaiter(this, void 0, void 0, function* () {
             try {
                 // スクリプトタグで動的にプラグインを読み込む
@@ -68,17 +188,25 @@ export class PluginManager {
                     components: new Map(),
                     assetUrls: new Map(),
                 };
+                // 外部アプリから渡されたアセットURLを事前にキャッシュ
+                if (assets) {
+                    for (const asset of assets) {
+                        instance.assetUrls.set(asset.filename, asset.url);
+                    }
+                }
                 // プラグインAPIを作成
                 const api = this.createPluginAPI(packageName, instance);
                 // プラグインをセットアップ
                 plugin.setup(api);
-                console.log(`Plugin ${packageName} setup completed. Hooks:`, Object.keys(instance.hooks));
-                this.plugins.set(packageName, {
+                const loadedPlugin = {
                     plugin,
                     instance,
                     enabled: true,
                     config: config || {},
-                });
+                };
+                // ローカルとグローバル両方に保存
+                this.plugins.set(packageName, loadedPlugin);
+                globalLoadedPlugins.set(packageName, loadedPlugin);
             }
             catch (error) {
                 console.error(`Failed to load plugin ${packageName}:`, error);
@@ -108,9 +236,7 @@ export class PluginManager {
             };
             // プラグインバンドルをfetchで取得して実行
             // 開発環境ではキャッシュを無効化してホットリロードを確実に動作させる
-            const isDevelopment = window.location.hostname === "localhost" ||
-                window.location.hostname === "127.0.0.1" ||
-                window.location.port === "3000";
+            const isDevelopment = this.isDevelopment();
             const fetchOptions = isDevelopment
                 ? {
                     cache: "no-cache",
@@ -120,7 +246,6 @@ export class PluginManager {
                     },
                 }
                 : {};
-            console.log(`🔄 Loading plugin ${packageName} (dev: ${isDevelopment}, cache: ${isDevelopment ? "disabled" : "enabled"})`);
             fetch(url, fetchOptions)
                 .then((response) => {
                 if (!response.ok) {
@@ -133,12 +258,7 @@ export class PluginManager {
                     // import文を削除
                     .replace(/^import\s+.*?from\s+['"].*?['"];?\s*$/gm, "")
                     .replace(/export\s*{[^}]*}\s*;?\s*$/g, "")
-                    .replace(/export\s+default\s+/g, "")
-                    // luna-react/jsxランタイムへの参照を置換
-                    .replace(/from\s+['"]luna-react\/jsx-runtime['"]/, 'from "__LUNA_JSX_RUNTIME__"')
-                    .replace(/from\s+['"]luna-react['"]/, 'from "__LUNA_REACT__"')
-                    .replace(/require\(['"]luna-react\/jsx-runtime['"]\)/, 'require("__LUNA_JSX_RUNTIME__")')
-                    .replace(/require\(['"]luna-react['"]\)/, 'require("__LUNA_REACT__")');
+                    .replace(/export\s+default\s+/g, "");
                 // ES modules形式のプラグインコードを処理
                 const wrappedCode = `
 						(function() {
@@ -156,10 +276,10 @@ export class PluginManager {
 
 							// Luna React Runtime を提供
 							const require = function(moduleName) {
-								if (moduleName === "__LUNA_REACT__" || moduleName === "luna-react" || moduleName === "react" || moduleName === "@luna-editor/engine") {
+								if (moduleName === "react" || moduleName === "luna-react" || moduleName === "@luna-editor/engine" || moduleName === "@luna-editor/engine/sdk" || moduleName === "@luna-editor/plugin-sdk") {
 									return window.__LUNA_REACT_RUNTIME__;
 								}
-								if (moduleName === "__LUNA_JSX_RUNTIME__" || moduleName === "luna-react/jsx-runtime" || moduleName === "react/jsx-runtime" || moduleName === "react/jsx-dev-runtime") {
+								if (moduleName === "react/jsx-runtime" || moduleName === "react/jsx-dev-runtime" || moduleName === "luna-react/jsx-runtime" || moduleName === "luna-react/jsx-dev-runtime") {
 									return window.__LUNA_JSX_RUNTIME__;
 								}
 								throw new Error('Module not found: ' + moduleName);
@@ -190,19 +310,6 @@ export class PluginManager {
                 scriptElement.type = "text/javascript";
                 scriptElement.dataset.plugin = packageName;
                 scriptElement.textContent = wrappedCode;
-                // タイムアウトを設定（グローバルコールバックが5秒以内に呼ばれない場合はエラー）
-                const timeoutId = setTimeout(() => {
-                    if (window[globalName]) {
-                        delete window[globalName];
-                        reject(new Error(`Plugin ${packageName} did not initialize within timeout`));
-                    }
-                }, 5000);
-                // グローバルコールバック関数にタイムアウトクリアを追加
-                const originalCallback = window[globalName];
-                window[globalName] = (plugin) => {
-                    clearTimeout(timeoutId);
-                    originalCallback(plugin);
-                };
                 // DOMに追加（この時点で同期的に実行される）
                 document.head.appendChild(scriptElement);
             })
@@ -220,17 +327,23 @@ export class PluginManager {
             return {
                 setClassName: (className) => {
                     classNames.clear();
-                    className.split(" ").forEach((cn) => classNames.add(cn));
+                    for (const cn of className.split(" ")) {
+                        classNames.add(cn);
+                    }
                     instance.styles.set(elementName, Array.from(classNames));
                     this.applyStyles(elementName, Array.from(classNames));
                 },
                 addClassName: (className) => {
-                    className.split(" ").forEach((cn) => classNames.add(cn));
+                    for (const cn of className.split(" ")) {
+                        classNames.add(cn);
+                    }
                     instance.styles.set(elementName, Array.from(classNames));
                     this.applyStyles(elementName, Array.from(classNames));
                 },
                 removeClassName: (className) => {
-                    className.split(" ").forEach((cn) => classNames.delete(cn));
+                    for (const cn of className.split(" ")) {
+                        classNames.delete(cn);
+                    }
                     instance.styles.set(elementName, Array.from(classNames));
                     this.applyStyles(elementName, Array.from(classNames));
                 },
@@ -281,7 +394,7 @@ export class PluginManager {
                     // ターゲット要素内の画像を探してマスクを適用
                     const targetImage = targetElement.querySelector("img");
                     let maskStyles = {};
-                    if (targetImage && targetImage.src) {
+                    if (targetImage === null || targetImage === void 0 ? void 0 : targetImage.src) {
                         // 画像のスタイルプロパティを取得
                         const computedImageStyle = getComputedStyle(targetImage);
                         const objectFit = computedImageStyle.objectFit;
@@ -312,7 +425,7 @@ export class PluginManager {
                     // スタイルを個別に適用
                     Object.entries(overlayStyles).forEach(([key, value]) => {
                         if (typeof value === "string") {
-                            overlay.style[key] = value;
+                            overlay.style.setProperty(key.replace(/([A-Z])/g, "-$1").toLowerCase(), value);
                         }
                     });
                     overlay.dataset.plugin = packageName;
@@ -332,7 +445,9 @@ export class PluginManager {
                 },
                 clearOverlays: () => {
                     const overlaysToRemove = Array.from(instance.overlays.keys()).filter((id) => id.includes(`-overlay-${elementName}-`));
-                    overlaysToRemove.forEach((id) => this.removeOverlay(id, instance));
+                    for (const id of overlaysToRemove) {
+                        this.removeOverlay(id, instance);
+                    }
                 },
             };
         };
@@ -344,6 +459,8 @@ export class PluginManager {
                 gameScreen: createStyleElement("gameScreen"),
                 characterSprite: createStyleElement("characterSprite"),
                 background: createStyleElement("background"),
+                fullscreenTextOverlay: createStyleElement("fullscreenTextOverlay"),
+                fullscreenTextContainer: createStyleElement("fullscreenTextContainer"),
             },
             injectCSS: (css) => {
                 if (this.injectedStyles.has(css))
@@ -481,45 +598,80 @@ export class PluginManager {
                         keysToDelete.push(key);
                     }
                 }
-                keysToDelete.forEach((key) => this.storage.delete(key));
+                for (const key of keysToDelete) {
+                    this.storage.delete(key);
+                }
             },
         };
         const assetAPI = {
             getUrl: (filename) => {
-                // プラグインアセットのAPIエンドポイントを返す（URLエンコーディング対応）
+                // キャッシュに最終URL（リダイレクト後）があればそれを返す
+                const cachedUrl = instance.assetUrls.get(filename);
+                if (cachedUrl) {
+                    return cachedUrl;
+                }
+                // なければAPIエンドポイントを返す（URLエンコーディング対応）
                 const encodedPackageName = encodeURIComponent(packageName);
                 const encodedFilename = encodeURIComponent(filename);
                 const url = `/api/plugin/${encodedPackageName}/assets/${encodedFilename}`;
-                // instance内にURLを保存（Context API経由でアクセス可能にするため）
-                instance.assetUrls.set(filename, url);
                 return url;
             },
-            preload: (filenames) => __awaiter(this, void 0, void 0, function* () {
-                const promises = filenames.map((filename) => {
-                    const url = assetAPI.getUrl(filename);
-                    if (filename.match(/\.(png|jpg|jpeg|gif|webp)$/i)) {
-                        return new Promise((resolve, reject) => {
-                            const img = new Image();
-                            img.onload = () => resolve();
-                            img.onerror = () => reject(new Error(`Failed to load image: ${url}`));
-                            img.src = url;
-                        });
-                    }
-                    if (filename.match(/\.(mp3|wav|ogg)$/i)) {
-                        return new Promise((resolve, reject) => {
-                            const audio = new Audio();
-                            audio.oncanplaythrough = () => resolve();
-                            audio.onerror = () => reject(new Error(`Failed to load audio: ${url}`));
-                            audio.src = url;
-                        });
-                    }
-                    return Promise.resolve();
-                });
-                yield Promise.all(promises);
-            }),
+            preload: (filenames) => {
+                const preloadPromise = (() => __awaiter(this, void 0, void 0, function* () {
+                    const promises = filenames.map((filename) => __awaiter(this, void 0, void 0, function* () {
+                        // 既にキャッシュされたURLがあればAPIフェッチをスキップ
+                        let finalUrl = instance.assetUrls.get(filename);
+                        if (!finalUrl) {
+                            // APIエンドポイントURL
+                            const encodedPackageName = encodeURIComponent(packageName);
+                            const encodedFilename = encodeURIComponent(filename);
+                            const apiUrl = `/api/plugin/${encodedPackageName}/assets/${encodedFilename}`;
+                            // fetchでリダイレクト後の最終URLを取得
+                            try {
+                                const response = yield fetch(apiUrl, { method: "HEAD" });
+                                finalUrl = response.url; // リダイレクト後の最終URL
+                                // 最終URLをキャッシュに保存
+                                instance.assetUrls.set(filename, finalUrl);
+                            }
+                            catch (error) {
+                                console.error(`Failed to preload asset: ${filename}`, error);
+                                return Promise.resolve();
+                            }
+                        }
+                        try {
+                            // 画像をプリロード
+                            if (filename.match(/\.(png|jpg|jpeg|gif|webp)$/i)) {
+                                return new Promise((resolve, reject) => {
+                                    const img = new Image();
+                                    img.onload = () => resolve();
+                                    img.onerror = () => reject(new Error(`Failed to load image: ${finalUrl}`));
+                                    img.src = finalUrl;
+                                });
+                            }
+                            // 音声をプリロード
+                            if (filename.match(/\.(mp3|wav|ogg)$/i)) {
+                                return new Promise((resolve, reject) => {
+                                    const audio = new Audio();
+                                    audio.oncanplaythrough = () => resolve();
+                                    audio.onerror = () => reject(new Error(`Failed to load audio: ${finalUrl}`));
+                                    audio.src = finalUrl;
+                                });
+                            }
+                        }
+                        catch (error) {
+                            console.error(`Failed to preload asset: ${filename}`, error);
+                        }
+                    }));
+                    yield Promise.all(promises);
+                }))();
+                // プリロードPromiseを追跡
+                this.preloadPromises.push(preloadPromise);
+                return preloadPromise;
+            },
             playSound: (filename, options) => {
-                console.log("playing sound", filename);
-                console.log("url:", assetAPI.getUrl(filename));
+                // ミュート中は再生しない
+                if (this.muteAudio)
+                    return;
                 const audio = new Audio(assetAPI.getUrl(filename));
                 if ((options === null || options === void 0 ? void 0 : options.volume) !== undefined) {
                     audio.volume = options.volume;
@@ -531,10 +683,30 @@ export class PluginManager {
                     console.error("Failed to play sound:", error);
                 });
             },
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
             stopSound: (_filename) => {
-                // eslint-disable-line @typescript-eslint/no-unused-vars
                 // TODO: 音声停止の実装
             },
+            playWorkSound: (soundId, options) => {
+                // ミュート中は再生しない
+                if (this.muteAudio)
+                    return;
+                const soundUrl = this.getWorkSoundUrl(soundId);
+                if (!soundUrl) {
+                    console.warn(`Work sound not found: ${soundId}`);
+                    return;
+                }
+                const audio = new Audio(soundUrl);
+                if ((options === null || options === void 0 ? void 0 : options.volume) !== undefined) {
+                    audio.volume = options.volume;
+                }
+                if (options === null || options === void 0 ? void 0 : options.loop) {
+                    audio.loop = true;
+                }
+                audio.play().catch((error) => {
+                    console.error("Failed to play work sound:", error);
+                });
+            },
         };
         const componentAPI = {
             registerComponent: (type, component) => {
@@ -546,7 +718,6 @@ export class PluginManager {
                 }
                 instance.components.set(type, component);
                 this.componentRegistry.set(type, component);
-                console.log(`Plugin ${packageName} registered component: ${type}`);
             },
         };
         const uiAPI = {
@@ -579,6 +750,23 @@ export class PluginManager {
                 const pluginEntry = this.plugins.get(packageName);
                 return (pluginEntry === null || pluginEntry === void 0 ? void 0 : pluginEntry.config) || {};
             },
+            selectChoice: (choiceId) => {
+                if (this.selectChoiceCallback) {
+                    this.selectChoiceCallback(choiceId);
+                }
+                else {
+                    console.warn("selectChoice callback is not registered. Make sure to call setSelectChoiceCallback.");
+                }
+            },
+            getBranchState: () => {
+                if (this.getBranchStateCallback) {
+                    return this.getBranchStateCallback();
+                }
+                return null;
+            },
+            overrideClickSound: () => {
+                this.overrideClickSound();
+            },
             hooks: {
                 onInit: (callback) => {
                     instance.hooks.onInit = callback;
@@ -592,9 +780,6 @@ export class PluginManager {
                 onCharacterEnter: (callback) => {
                     instance.hooks.onCharacterEnter = callback;
                 },
-                onCharacterExit: (callback) => {
-                    instance.hooks.onCharacterExit = callback;
-                },
                 onDialogueShow: (callback) => {
                     instance.hooks.onDialogueShow = callback;
                 },
@@ -607,13 +792,37 @@ export class PluginManager {
                 onScenarioEnd: (callback) => {
                     instance.hooks.onScenarioEnd = callback;
                 },
+                onBranchStart: (callback) => {
+                    instance.hooks.onBranchStart = callback;
+                },
+                onChoiceSelected: (callback) => {
+                    instance.hooks.onChoiceSelected = callback;
+                },
+                onBranchEnd: (callback) => {
+                    instance.hooks.onBranchEnd = callback;
+                },
+                onBranchBlockChange: (callback) => {
+                    instance.hooks.onBranchBlockChange = callback;
+                },
             },
             effects: effectAPI,
             storage: storageAPI,
             assets: assetAPI,
+            blockOptions: {
+                register: () => {
+                    // ランタイムでは何もしない（サーバー側での抽出時のみ使用）
+                    // プラグインのsetup()が呼ばれた時点でBlockOptionsはすでにDBに保存済み
+                },
+            },
             data: {
-                get: () => {
-                    throw new Error("DataAPI.get() can only be called from within DataProvider context");
+                get: (key) => {
+                    if (this.dataContextGetter) {
+                        const context = this.dataContextGetter();
+                        const value = context === null || context === void 0 ? void 0 : context[key];
+                        return value;
+                    }
+                    console.warn("DataContext getter is not registered. Make sure to call setDataContextGetter.");
+                    return undefined;
                 },
                 subscribe: () => {
                     throw new Error("DataAPI.subscribe() can only be called from within DataProvider context");
@@ -624,13 +833,41 @@ export class PluginManager {
                 updateSettings: () => {
                     throw new Error("DataAPI.updateSettings() can only be called from within DataProvider context");
                 },
+                getBlockOption: () => {
+                    throw new Error("DataAPI.getBlockOption() can only be called from within DataProvider context");
+                },
+                setBgmVolume: () => {
+                    throw new Error("DataAPI.setBgmVolume() can only be called from within DataProvider context");
+                },
+                setSeVolume: () => {
+                    throw new Error("DataAPI.setSeVolume() can only be called from within DataProvider context");
+                },
+                setVoiceVolume: () => {
+                    throw new Error("DataAPI.setVoiceVolume() can only be called from within DataProvider context");
+                },
+                setVolumes: () => {
+                    throw new Error("DataAPI.setVolumes() can only be called from within DataProvider context");
+                },
+                updateEmotionEffect: (state) => {
+                    if (this.emotionEffectUpdaterCallback) {
+                        this.emotionEffectUpdaterCallback(state);
+                    }
+                    else {
+                        console.warn("updateEmotionEffect callback is not registered. Make sure to call setEmotionEffectUpdaterCallback.");
+                    }
+                },
             },
         };
     }
     applyStyles(elementName, classNames) {
         const element = this.styleElements.get(elementName);
         if (element) {
-            element.className = classNames.join(" ");
+            // 元のクラス名を取得し、プラグインから追加されたクラスと結合
+            const originalClassName = this.originalClassNames.get(elementName) || "";
+            const pluginClassNames = classNames.join(" ");
+            element.className = originalClassName
+                ? `${originalClassName} ${pluginClassNames}`
+                : pluginClassNames;
         }
     }
     hideEffect(effectId, instance) {
@@ -651,17 +888,17 @@ export class PluginManager {
         // DOM要素にdata-style-element-name属性を追加
         element.setAttribute("data-style-element-name", name);
         this.styleElements.set(name, element);
+        // 元のクラス名を保存（初回登録時のみ）
+        if (!this.originalClassNames.has(name)) {
+            this.originalClassNames.set(name, element.className);
+        }
     }
     // フック呼び出しメソッド
     callHook(hookName, ...args) {
-        console.log(`Calling hook: ${hookName}`, args);
-        console.log(`Number of plugins: ${this.plugins.size}`);
         this.plugins.forEach((loadedPlugin, packageName) => {
             const { instance, enabled } = loadedPlugin;
-            console.log(`Plugin ${packageName}: enabled=${enabled}, has hook=${!!instance.hooks[hookName]}`);
             if (enabled && instance.hooks[hookName]) {
                 try {
-                    console.log(`Executing hook ${hookName} for plugin ${packageName}`);
                     const hook = instance.hooks[hookName];
                     if (hook) {
                         hook(...args);
@@ -703,16 +940,18 @@ export class PluginManager {
     // クリーンアップ
     cleanup() {
         // 注入されたスタイルを削除
-        document
-            .querySelectorAll("style[data-plugin]")
-            .forEach((el) => el.remove());
-        document
-            .querySelectorAll("script[data-plugin]")
-            .forEach((el) => el.remove());
+        for (const el of document.querySelectorAll("style[data-plugin]")) {
+            el.remove();
+        }
+        for (const el of document.querySelectorAll("script[data-plugin]")) {
+            el.remove();
+        }
         // エフェクトを削除
-        this.plugins.forEach(({ instance }) => {
-            instance.effects.forEach((effect) => effect.remove());
-        });
+        for (const { instance } of this.plugins.values()) {
+            for (const effect of instance.effects.values()) {
+                effect.remove();
+            }
+        }
         this.plugins.clear();
         this.styleElements.clear();
         this.injectedStyles.clear();
@@ -779,7 +1018,9 @@ export class PluginManager {
         // リスナーに通知
         const listeners = this.uiVisibilityListeners.get(type);
         if (listeners) {
-            listeners.forEach((listener) => listener(visible));
+            for (const listener of listeners) {
+                listener(visible);
+            }
         }
     }
     /**
@@ -801,6 +1042,8 @@ export class PluginManager {
             this.uiVisibilityListeners.set(type, new Set());
         }
         const listeners = this.uiVisibilityListeners.get(type);
+        if (!listeners)
+            return () => { };
         listeners.add(listener);
         // 現在の状態を即座に通知
         listener(this.uiVisibilityState.get(type) || false);
@@ -851,4 +1094,94 @@ export class PluginManager {
     hideUI(type) {
         this.setUIVisibility(type, false);
     }
+    setSelectChoiceCallback(callback) {
+        this.selectChoiceCallback = callback;
+    }
+    setGetBranchStateCallback(callback) {
+        this.getBranchStateCallback = callback;
+    }
+    setEmotionEffectUpdaterCallback(callback) {
+        this.emotionEffectUpdaterCallback = callback;
+    }
+    setDataContextGetter(callback) {
+        this.dataContextGetter = callback;
+    }
+    /**
+     * 全てのアセットプリロードが完了するまで待機
+     * @returns プリロード完了時にresolveするPromise
+     */
+    waitForPreloads() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield Promise.all(this.preloadPromises);
+            this.preloadPromises = [];
+        });
+    }
+    /**
+     * 音声のミュート状態を設定
+     * @param mute - ミュートするかどうか
+     */
+    setMuteAudio(mute) {
+        this.muteAudio = mute;
+    }
+    /**
+     * 作品のサウンドデータを設定
+     * @param sounds - サウンドIDをキーとしたURL/名前のマップ
+     */
+    setWorkSounds(sounds) {
+        this.workSounds.clear();
+        for (const sound of sounds) {
+            this.workSounds.set(sound.id, { url: sound.url, name: sound.name });
+        }
+    }
+    /**
+     * 作品のサウンドURLを取得
+     * @param soundId - サウンドID
+     */
+    getWorkSoundUrl(soundId) {
+        var _a, _b;
+        return (_b = (_a = this.workSounds.get(soundId)) === null || _a === void 0 ? void 0 : _a.url) !== null && _b !== void 0 ? _b : null;
+    }
+    /**
+     * ビルトインのクリック音を設定
+     * @param url - サウンドファイルのURL（nullで無効化）
+     * @param volume - 音量（0.0 - 1.0）
+     */
+    setClickSound(url, volume = 0.5) {
+        this.clickSoundUrl = url;
+        this.clickSoundVolume = volume;
+    }
+    /**
+     * プラグインがクリック音を上書きする
+     * これを呼び出すと、ビルトインのクリック音は再生されなくなる
+     */
+    overrideClickSound() {
+        this.clickSoundOverridden = true;
+    }
+    /**
+     * プラグインのクリック音上書きをリセット
+     * 各ブロック遷移の前に呼び出す
+     */
+    resetClickSoundOverride() {
+        this.clickSoundOverridden = false;
+    }
+    /**
+     * クリック音が上書きされているかを取得
+     */
+    isClickSoundOverridden() {
+        return this.clickSoundOverridden;
+    }
+    /**
+     * ビルトインのクリック音を再生
+     * プラグインで上書きされている場合やミュート中は再生しない
+     */
+    playClickSound() {
+        if (this.muteAudio || this.clickSoundOverridden || !this.clickSoundUrl) {
+            return;
+        }
+        const audio = new Audio(this.clickSoundUrl);
+        audio.volume = this.clickSoundVolume;
+        audio.play().catch((error) => {
+            console.error("Failed to play click sound:", error);
+        });
+    }
 }