@reftrixmcp/mcp-server 0.1.7

package/dist/services/motion/js-animation-detector.js

@@ -0,0 +1,911 @@
+"use strict";
+// SPDX-FileCopyrightText: 2026 TKMD and Reftrix Contributors
+// SPDX-License-Identifier: AGPL-3.0-only
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JSAnimationDetectorService = exports.BASE_CONFIDENCE_SCORES = void 0;
+exports.calculateConfidence = calculateConfidence;
+exports.createJSAnimationDetector = createJSAnimationDetector;
+const logger_1 = require("../../utils/logger");
+/**
+ * ソースごとの基本信頼度
+ */
+exports.BASE_CONFIDENCE_SCORES = {
+    cdp: 0.95,
+    web_animations_api: 0.9,
+    library_signature: 0.75,
+    raf_monitoring: 0.7,
+    intersection_observer: 0.65,
+};
+// =====================================================
+// デフォルトオプション
+// =====================================================
+const DEFAULT_OPTIONS = {
+    enableCDP: true,
+    enableWebAnimations: true,
+    enableLibraryDetection: true,
+    waitTime: 1000,
+};
+// =====================================================
+// 信頼度計算ヘルパー関数 (v0.1.0)
+// =====================================================
+/**
+ * 複数ソースからの信頼度をマージ
+ * 複数ソースで検出された場合、信頼度は上昇する（逓減効果あり）
+ *
+ * @param sources - 検出に使用したソースの配列
+ * @returns マージされた信頼度スコア (0-1)
+ */
+function mergeConfidenceScores(sources) {
+    if (sources.length === 0)
+        return 0;
+    const firstSource = sources[0];
+    if (sources.length === 1 && firstSource !== undefined) {
+        return exports.BASE_CONFIDENCE_SCORES[firstSource];
+    }
+    // 最高スコアを基準に、追加ソースごとにボーナス
+    const sortedScores = sources.map((s) => exports.BASE_CONFIDENCE_SCORES[s]).sort((a, b) => b - a);
+    const firstScore = sortedScores[0];
+    if (firstScore === undefined)
+        return 0;
+    let score = firstScore;
+    // 追加ソースごとに信頼度を増加（逓減効果）
+    for (let i = 1; i < sortedScores.length; i++) {
+        const currentScore = sortedScores[i];
+        if (currentScore !== undefined) {
+            const bonus = (1 - score) * currentScore * 0.5;
+            score += bonus;
+        }
+    }
+    return Math.min(score, 1.0);
+}
+/**
+ * 信頼度情報を生成
+ *
+ * @param sources - 検出に使用したソースの配列
+ * @param additionalRationale - 追加の根拠説明
+ * @returns 信頼度情報オブジェクト
+ */
+function calculateConfidence(sources, additionalRationale = []) {
+    const sourceScores = {
+        cdp: 0,
+        web_animations_api: 0,
+        library_signature: 0,
+        raf_monitoring: 0,
+        intersection_observer: 0,
+    };
+    sources.forEach((s) => {
+        sourceScores[s] = exports.BASE_CONFIDENCE_SCORES[s];
+    });
+    const rationale = [];
+    if (sources.includes("cdp")) {
+        rationale.push("CDP Animation domain detection (high confidence)");
+    }
+    if (sources.includes("web_animations_api")) {
+        rationale.push("Web Animations API detection");
+    }
+    if (sources.includes("library_signature")) {
+        rationale.push("Animation library signature detected");
+    }
+    if (sources.includes("raf_monitoring")) {
+        rationale.push("requestAnimationFrame callback detected");
+    }
+    if (sources.includes("intersection_observer")) {
+        rationale.push("IntersectionObserver triggered animation");
+    }
+    rationale.push(...additionalRationale);
+    return {
+        score: mergeConfidenceScores(sources),
+        sources,
+        sourceScores,
+        rationale,
+    };
+}
+// =====================================================
+// JSAnimationDetectorService クラス
+// =====================================================
+/**
+ * JavaScript駆動アニメーションの包括的検出サービス
+ *
+ * CDP + Web Animations API + ライブラリシグネチャ検出を組み合わせて
+ * Webページ上のJavaScriptアニメーションを検出します。
+ */
+class JSAnimationDetectorService {
+    cdpSession = null;
+    cdpAnimations = new Map();
+    isListening = false;
+    /**
+     * CDPセッションを初期化してAnimationドメインを有効化
+     */
+    async initializeCDP(page) {
+        if (this.cdpSession) {
+            return this.cdpSession;
+        }
+        try {
+            const client = await page.context().newCDPSession(page);
+            // Animation ドメインを有効化
+            await client.send("Animation.enable");
+            this.cdpSession = client;
+            if ((0, logger_1.isDevelopment)()) {
+                logger_1.logger.debug("[JSAnimationDetector] CDP session initialized");
+            }
+            return client;
+        }
+        catch (error) {
+            if ((0, logger_1.isDevelopment)()) {
+                logger_1.logger.error("[JSAnimationDetector] CDP initialization failed", { error });
+            }
+            throw new Error(`CDP initialization failed: ${error instanceof Error ? error.message : "Unknown error"}`);
+        }
+    }
+    /**
+     * CDPイベントリスナーを設定
+     */
+    setupCDPListeners(client) {
+        if (this.isListening) {
+            return;
+        }
+        // Animation.animationCreated イベント
+        client.on("Animation.animationCreated", (event) => {
+            if ((0, logger_1.isDevelopment)()) {
+                logger_1.logger.debug("[JSAnimationDetector] Animation created", { id: event.id });
+            }
+        });
+        // Animation.animationStarted イベント（タイミング情報含む）
+        client.on("Animation.animationStarted", (event) => {
+            const anim = event.animation;
+            // 信頼度情報を生成（CDP検出は高信頼度）
+            const confidenceRationale = [
+                `Animation type: ${anim.type}`,
+                `Duration: ${anim.source?.duration ?? 0}ms`,
+            ];
+            if (anim.source?.keyframesRule?.keyframes) {
+                confidenceRationale.push(`Keyframes detected: ${anim.source.keyframesRule.keyframes.length}`);
+            }
+            const cdpAnimation = {
+                id: anim.id,
+                name: anim.name || `animation-${anim.id}`,
+                pausedState: anim.pausedState,
+                playState: anim.playState,
+                playbackRate: anim.playbackRate,
+                startTime: anim.startTime,
+                currentTime: anim.currentTime,
+                type: this.mapAnimationType(anim.type),
+                source: {
+                    duration: anim.source?.duration ?? 0,
+                    delay: anim.source?.delay ?? 0,
+                    iterations: anim.source?.iterations ?? 1,
+                    direction: anim.source?.direction ?? "normal",
+                    easing: anim.source?.easing ?? "linear",
+                    ...(anim.source?.keyframesRule !== undefined
+                        ? { keyframesRule: anim.source.keyframesRule }
+                        : {}),
+                },
+                confidence: calculateConfidence(["cdp"], confidenceRationale),
+            };
+            this.cdpAnimations.set(anim.id, cdpAnimation);
+            if ((0, logger_1.isDevelopment)()) {
+                logger_1.logger.debug("[JSAnimationDetector] Animation started", {
+                    id: anim.id,
+                    name: anim.name,
+                    type: cdpAnimation.type,
+                    duration: cdpAnimation.source.duration,
+                });
+            }
+        });
+        // Animation.animationCanceled イベント
+        client.on("Animation.animationCanceled", (event) => {
+            this.cdpAnimations.delete(event.id);
+            if ((0, logger_1.isDevelopment)()) {
+                logger_1.logger.debug("[JSAnimationDetector] Animation canceled", { id: event.id });
+            }
+        });
+        this.isListening = true;
+    }
+    /**
+     * CDPのアニメーションタイプをマッピング
+     */
+    mapAnimationType(type) {
+        switch (type) {
+            case "CSSAnimation":
+                return "CSSAnimation";
+            case "CSSTransition":
+                return "CSSTransition";
+            default:
+                return "WebAnimation";
+        }
+    }
+    /**
+     * CDP経由でアニメーションを検出
+     */
+    async detectCDPAnimations(page, waitTime) {
+        try {
+            const client = await this.initializeCDP(page);
+            this.setupCDPListeners(client);
+            // アニメーションが開始されるのを待つ
+            await page.waitForTimeout(waitTime);
+            // 現在のアニメーション状態を取得
+            const animations = Array.from(this.cdpAnimations.values());
+            if ((0, logger_1.isDevelopment)()) {
+                logger_1.logger.debug("[JSAnimationDetector] CDP animations detected", {
+                    count: animations.length,
+                });
+            }
+            return animations;
+        }
+        catch (error) {
+            if ((0, logger_1.isDevelopment)()) {
+                logger_1.logger.error("[JSAnimationDetector] CDP detection failed", { error });
+            }
+            return [];
+        }
+    }
+    /**
+     * Web Animations API でアニメーションを検出
+     */
+    async detectWebAnimations(page) {
+        try {
+            const animations = await page.evaluate(() => {
+                const results = [];
+                const allAnimations = document.getAnimations();
+                let counter = 0;
+                for (const anim of allAnimations) {
+                    counter++;
+                    // ターゲット要素のセレクタを取得
+                    let targetSelector = "unknown";
+                    const effect = anim.effect;
+                    if (effect?.target instanceof Element) {
+                        const target = effect.target;
+                        if (target.id) {
+                            targetSelector = `#${target.id}`;
+                        }
+                        else if (target.className && typeof target.className === "string") {
+                            targetSelector = `.${target.className.split(" ").filter(Boolean).join(".")}`;
+                        }
+                        else {
+                            targetSelector = target.tagName.toLowerCase();
+                        }
+                    }
+                    // タイミング情報を取得
+                    const timing = effect?.getComputedTiming() ?? {};
+                    // キーフレームを取得
+                    let keyframes = [];
+                    if (effect instanceof KeyframeEffect) {
+                        try {
+                            keyframes = effect.getKeyframes().map((kf) => ({
+                                offset: kf.offset,
+                                easing: kf.easing,
+                                composite: kf.composite,
+                                ...Object.fromEntries(Object.entries(kf).filter(([key]) => !["offset", "easing", "composite", "computedOffset"].includes(key))),
+                            }));
+                        }
+                        catch {
+                            // キーフレーム取得失敗は無視
+                        }
+                    }
+                    results.push({
+                        id: anim.id || `web-anim-${counter}`,
+                        playState: anim.playState,
+                        target: targetSelector,
+                        timing: {
+                            duration: typeof timing.duration === "number" ? timing.duration : 0,
+                            delay: typeof timing.delay === "number" ? timing.delay : 0,
+                            iterations: timing.iterations === Infinity
+                                ? -1
+                                : typeof timing.iterations === "number"
+                                    ? timing.iterations
+                                    : 1,
+                            direction: timing.direction ?? "normal",
+                            easing: timing.easing ?? "linear",
+                            fill: timing.fill ?? "none",
+                        },
+                        keyframes,
+                    });
+                }
+                return results;
+            });
+            if ((0, logger_1.isDevelopment)()) {
+                logger_1.logger.debug("[JSAnimationDetector] Web Animations detected", {
+                    count: animations.length,
+                });
+            }
+            // 信頼度情報を追加（Web Animations APIは高信頼度）
+            const animationsWithConfidence = animations.map((anim) => {
+                const confidenceRationale = [
+                    `Target: ${anim.target}`,
+                    `Duration: ${anim.timing.duration}ms`,
+                    `Play state: ${anim.playState}`,
+                ];
+                if (anim.keyframes.length > 0) {
+                    confidenceRationale.push(`Keyframes: ${anim.keyframes.length}`);
+                }
+                return {
+                    ...anim,
+                    confidence: calculateConfidence(["web_animations_api"], confidenceRationale),
+                };
+            });
+            return animationsWithConfidence;
+        }
+        catch (error) {
+            if ((0, logger_1.isDevelopment)()) {
+                logger_1.logger.error("[JSAnimationDetector] Web Animations detection failed", { error });
+            }
+            return [];
+        }
+    }
+    /**
+     * Three.jsシーン詳細情報を取得
+     *
+     * WebGLコンテキストとThree.jsオブジェクトから詳細情報を抽出します。
+     * セキュリティ上、JavaScriptコードの実行が必要なため、Playwright page.evaluate() を使用します。
+     *
+     * @param page - Playwrightページオブジェクト
+     * @returns Three.js詳細情報（検出できない場合はnull）
+     */
+    async detectThreeJSDetails(page) {
+        const startTime = Date.now();
+        try {
+            const result = await page.evaluate(() => {
+                // windowの型拡張（Three.js関連）
+                const win = window;
+                // Three.jsが存在しない場合はnull
+                if (typeof win.THREE === "undefined") {
+                    return null;
+                }
+                // 結果オブジェクトを初期化
+                // Note: exactOptionalPropertyTypes対応のため、undefinedを避けて初期化
+                const threeVersion = win.THREE.REVISION;
+                const details = {
+                    scenes: [],
+                    cameras: [],
+                    renderer: {},
+                    performance: {},
+                    textures: [],
+                };
+                // versionがundefinedでない場合のみ設定
+                if (threeVersion !== undefined) {
+                    details.version = threeVersion;
+                }
+                // WebGLコンテキストからレンダラー情報を取得
+                const canvases = document.querySelectorAll("canvas");
+                let webglContextCount = 0;
+                canvases.forEach((canvas, index) => {
+                    try {
+                        const gl = canvas.getContext("webgl") ||
+                            canvas.getContext("webgl2");
+                        if (!gl)
+                            return;
+                        webglContextCount++;
+                        // WebGLコンテキスト属性からレンダラー情報を推定
+                        const attrs = gl.getContextAttributes();
+                        if (attrs && index === 0) {
+                            // 最初のcanvasの設定をレンダラー情報として採用
+                            details.renderer = {
+                                antialias: attrs.antialias ?? false,
+                                // preserveDrawingBuffer, premultipliedAlphaなども取得可能だが省略
+                            };
+                        }
+                        // シーン情報（簡易版: canvas要素ベース）
+                        details.scenes.push({
+                            id: `scene-${index}`,
+                            objects: [],
+                        });
+                        // WebGL拡張情報からパフォーマンス統計を取得試行
+                        // 注: renderer.infoへの直接アクセスは不可のため、推定値のみ
+                        try {
+                            // WEBGL_debug_renderer_infoは一部ブラウザで取得可能
+                            // ただしプライバシー保護のため詳細は取得しない
+                            const debugExt = gl.getExtension("WEBGL_debug_renderer_info");
+                            if (debugExt) {
+                                // デバッグ情報が取得可能な場合のみフラグを設定
+                                // 実際のGPU情報はプライバシー上の理由で省略
+                            }
+                        }
+                        catch {
+                            // 拡張取得失敗は無視
+                        }
+                    }
+                    catch {
+                        // コンテキスト取得失敗は無視
+                    }
+                });
+                // __THREE_DEVTOOLS__から追加情報を取得（開発ツール拡張使用時）
+                if (win.__THREE_DEVTOOLS__) {
+                    try {
+                        const devtools = win.__THREE_DEVTOOLS__;
+                        // シーン情報を更新
+                        if (Array.isArray(devtools.scenes)) {
+                            details.scenes = devtools.scenes.map((scene, index) => {
+                                const sceneObj = scene;
+                                const sceneId = sceneObj.uuid || `scene-${index}`;
+                                let background;
+                                let fog;
+                                // 背景色を取得
+                                if (sceneObj.background) {
+                                    const bg = sceneObj.background;
+                                    if (typeof bg.getHexString === "function") {
+                                        background = `#${bg.getHexString()}`;
+                                    }
+                                }
+                                // フォグ情報を取得
+                                if (sceneObj.fog) {
+                                    const fogObj = sceneObj.fog;
+                                    const fogColor = fogObj.color;
+                                    // exactOptionalPropertyTypes対応: undefinedを直接代入しない
+                                    const fogData = {
+                                        type: fogObj.isFogExp2 ? "FogExp2" : "Fog",
+                                        color: fogColor && typeof fogColor.getHexString === "function"
+                                            ? `#${fogColor.getHexString()}`
+                                            : "#000000",
+                                    };
+                                    // 数値プロパティは存在する場合のみ設定
+                                    if (typeof fogObj.density === "number") {
+                                        fogData.density = fogObj.density;
+                                    }
+                                    if (typeof fogObj.near === "number") {
+                                        fogData.near = fogObj.near;
+                                    }
+                                    if (typeof fogObj.far === "number") {
+                                        fogData.far = fogObj.far;
+                                    }
+                                    fog = fogData;
+                                }
+                                // 子オブジェクトを取得（最大20個に制限）
+                                const objects = [];
+                                if (Array.isArray(sceneObj.children)) {
+                                    const children = sceneObj.children.slice(0, 20);
+                                    for (const child of children) {
+                                        const objType = child.type || "Object3D";
+                                        const obj = { type: objType };
+                                        // ジオメトリ情報
+                                        if (child.geometry) {
+                                            const geo = child.geometry;
+                                            obj.geometry = geo.type || "BufferGeometry";
+                                        }
+                                        // マテリアル情報
+                                        if (child.material) {
+                                            const mat = child.material;
+                                            obj.material = mat.type || "Material";
+                                        }
+                                        // 位置情報
+                                        if (child.position) {
+                                            const pos = child.position;
+                                            if (typeof pos.x === "number" &&
+                                                typeof pos.y === "number" &&
+                                                typeof pos.z === "number") {
+                                                obj.position = [pos.x, pos.y, pos.z];
+                                            }
+                                        }
+                                        // 回転情報
+                                        if (child.rotation) {
+                                            const rot = child.rotation;
+                                            if (typeof rot.x === "number" &&
+                                                typeof rot.y === "number" &&
+                                                typeof rot.z === "number") {
+                                                obj.rotation = [rot.x, rot.y, rot.z];
+                                            }
+                                        }
+                                        // スケール情報
+                                        if (child.scale) {
+                                            const scl = child.scale;
+                                            if (typeof scl.x === "number" &&
+                                                typeof scl.y === "number" &&
+                                                typeof scl.z === "number") {
+                                                obj.scale = [scl.x, scl.y, scl.z];
+                                            }
+                                        }
+                                        // ライト固有情報
+                                        if (objType.includes("Light")) {
+                                            if (child.color) {
+                                                const col = child.color;
+                                                if (typeof col.getHexString === "function") {
+                                                    obj.color = `#${col.getHexString()}`;
+                                                }
+                                            }
+                                            if (typeof child.intensity === "number") {
+                                                obj.intensity = child.intensity;
+                                            }
+                                        }
+                                        objects.push(obj);
+                                    }
+                                }
+                                // exactOptionalPropertyTypes対応: undefinedを直接代入しない
+                                const sceneData = {
+                                    id: sceneId,
+                                    objects,
+                                };
+                                if (background !== undefined) {
+                                    sceneData.background = background;
+                                }
+                                if (fog !== undefined) {
+                                    sceneData.fog = fog;
+                                }
+                                return sceneData;
+                            });
+                        }
+                        // レンダラー情報を更新
+                        if (Array.isArray(devtools.renderers) && devtools.renderers.length > 0) {
+                            const renderer = devtools.renderers[0];
+                            // シャドウマップ
+                            if (renderer.shadowMap) {
+                                const sm = renderer.shadowMap;
+                                details.renderer.shadowMap = sm.enabled === true;
+                            }
+                            // トーンマッピング
+                            if (typeof renderer.toneMapping === "number") {
+                                // Three.js ToneMappingを文字列にマッピング
+                                const toneMappingMap = {
+                                    0: "NoToneMapping",
+                                    1: "LinearToneMapping",
+                                    2: "ReinhardToneMapping",
+                                    3: "CineonToneMapping",
+                                    4: "ACESFilmicToneMapping",
+                                };
+                                details.renderer.toneMapping = toneMappingMap[renderer.toneMapping] || "Unknown";
+                            }
+                            // 出力カラースペース
+                            if (typeof renderer.outputColorSpace === "string") {
+                                details.renderer.outputColorSpace = renderer.outputColorSpace;
+                            }
+                            // ピクセル比
+                            if (typeof renderer.getPixelRatio === "function") {
+                                try {
+                                    details.renderer.pixelRatio = renderer.getPixelRatio();
+                                }
+                                catch {
+                                    // 取得失敗は無視
+                                }
+                            }
+                            // パフォーマンス統計
+                            if (renderer.info) {
+                                const info = renderer.info;
+                                const render = info.render;
+                                if (render) {
+                                    if (typeof render.calls === "number") {
+                                        details.performance.drawCalls = render.calls;
+                                    }
+                                    if (typeof render.triangles === "number") {
+                                        details.performance.triangles = render.triangles;
+                                    }
+                                    if (typeof render.points === "number") {
+                                        details.performance.points = render.points;
+                                    }
+                                    if (typeof render.lines === "number") {
+                                        details.performance.lines = render.lines;
+                                    }
+                                }
+                            }
+                        }
+                    }
+                    catch {
+                        // DevTools情報取得失敗は無視
+                    }
+                }
+                // シーン数が0の場合、WebGLコンテキスト数に基づいて生成
+                if (details.scenes.length === 0 && webglContextCount > 0) {
+                    for (let i = 0; i < webglContextCount; i++) {
+                        details.scenes.push({
+                            id: `scene-${i}`,
+                            objects: [],
+                        });
+                    }
+                }
+                return details;
+            });
+            // 処理時間を計測
+            const processingTimeMs = Date.now() - startTime;
+            if ((0, logger_1.isDevelopment)()) {
+                logger_1.logger.debug("[JSAnimationDetector] Three.js details detected", {
+                    hasDetails: result !== null,
+                    version: result?.version,
+                    scenesCount: result?.scenes.length ?? 0,
+                    camerasCount: result?.cameras.length ?? 0,
+                    processingTimeMs,
+                });
+            }
+            return result;
+        }
+        catch (error) {
+            if ((0, logger_1.isDevelopment)()) {
+                logger_1.logger.error("[JSAnimationDetector] Three.js details detection failed", { error });
+            }
+            return null;
+        }
+    }
+    /**
+     * アニメーションライブラリを検出
+     */
+    async detectLibraries(page) {
+        try {
+            const result = await page.evaluate(() => {
+                // windowの型拡張
+                const win = window;
+                // GSAP 検出
+                const gsapDetected = typeof win.gsap !== "undefined";
+                let gsapVersion;
+                let gsapTweens = 0;
+                if (gsapDetected && win.gsap) {
+                    gsapVersion = win.gsap.version;
+                    // GSAPのアクティブなアニメーション数を取得
+                    try {
+                        const timeline = win.gsap.globalTimeline;
+                        if (timeline?.getChildren) {
+                            gsapTweens = timeline.getChildren().length;
+                        }
+                    }
+                    catch {
+                        // 取得失敗は無視
+                    }
+                }
+                // Framer Motion 検出（data-framer-* 属性で判定）
+                const framerMotionElements = document.querySelectorAll("[data-framer-appear-id], [data-framer-name], [data-framer-component-type]");
+                const framerMotionDetected = framerMotionElements.length > 0;
+                // Anime.js 検出
+                const animeDetected = typeof win.anime !== "undefined";
+                let animeInstances = 0;
+                if (animeDetected && win.anime?.running) {
+                    animeInstances = win.anime.running.length;
+                }
+                // Three.js 検出
+                const threeDetected = typeof win.THREE !== "undefined";
+                let threeScenes = 0;
+                if (threeDetected) {
+                    // canvas要素でWebGLコンテキストを使用しているものをカウント
+                    const canvases = document.querySelectorAll("canvas");
+                    canvases.forEach((canvas) => {
+                        try {
+                            const gl = canvas.getContext("webgl") || canvas.getContext("webgl2");
+                            if (gl) {
+                                threeScenes++;
+                            }
+                        }
+                        catch {
+                            // コンテキスト取得失敗は無視
+                        }
+                    });
+                }
+                // Lottie 検出
+                const lottieDetected = typeof win.lottie !== "undefined";
+                let lottieAnimations = 0;
+                if (lottieDetected && win.lottie?.getRegisteredAnimations) {
+                    try {
+                        lottieAnimations = win.lottie.getRegisteredAnimations().length;
+                    }
+                    catch {
+                        // 取得失敗は無視
+                    }
+                }
+                // Lottie要素も検出（lottie-player, dotlottie-player）
+                const lottieElements = document.querySelectorAll("lottie-player, dotlottie-player, [data-lottie]");
+                if (lottieElements.length > 0) {
+                    lottieAnimations = Math.max(lottieAnimations, lottieElements.length);
+                }
+                return {
+                    gsap: {
+                        detected: gsapDetected,
+                        version: gsapVersion,
+                        tweens: gsapTweens,
+                    },
+                    framerMotion: {
+                        detected: framerMotionDetected,
+                        elements: framerMotionElements.length,
+                    },
+                    anime: {
+                        detected: animeDetected,
+                        instances: animeInstances,
+                    },
+                    three: {
+                        detected: threeDetected,
+                        scenes: threeScenes,
+                    },
+                    lottie: {
+                        detected: lottieDetected || lottieElements.length > 0,
+                        animations: lottieAnimations,
+                    },
+                };
+            });
+            // Three.js詳細情報を取得（Three.jsが検出された場合のみ）
+            let threeDetails;
+            if (result.three.detected) {
+                const details = await this.detectThreeJSDetails(page);
+                if (details) {
+                    threeDetails = details;
+                }
+            }
+            // 信頼度情報を追加（各ライブラリごとに）
+            const finalResult = {
+                gsap: {
+                    ...result.gsap,
+                    confidence: result.gsap.detected
+                        ? calculateConfidence(["library_signature"], [
+                            `Library: GSAP`,
+                            ...(result.gsap.version ? [`Version: ${result.gsap.version}`] : []),
+                            ...(result.gsap.tweens ? [`Active tweens: ${result.gsap.tweens}`] : []),
+                        ])
+                        : undefined,
+                },
+                framerMotion: {
+                    ...result.framerMotion,
+                    confidence: result.framerMotion.detected
+                        ? calculateConfidence(["library_signature"], [
+                            `Library: Framer Motion`,
+                            `Elements with data-framer-*: ${result.framerMotion.elements}`,
+                        ])
+                        : undefined,
+                },
+                anime: {
+                    ...result.anime,
+                    confidence: result.anime.detected
+                        ? calculateConfidence(["library_signature"], [
+                            `Library: anime.js`,
+                            ...(result.anime.instances
+                                ? [`Running instances: ${result.anime.instances}`]
+                                : []),
+                        ])
+                        : undefined,
+                },
+                three: {
+                    ...result.three,
+                    details: threeDetails,
+                    confidence: result.three.detected
+                        ? calculateConfidence(["library_signature"], [
+                            `Library: Three.js`,
+                            ...(threeDetails?.version ? [`Version: ${threeDetails.version}`] : []),
+                            `WebGL scenes: ${result.three.scenes}`,
+                        ])
+                        : undefined,
+                },
+                lottie: {
+                    ...result.lottie,
+                    confidence: result.lottie.detected
+                        ? calculateConfidence(["library_signature"], [`Library: Lottie`, `Animations: ${result.lottie.animations}`])
+                        : undefined,
+                },
+            };
+            if ((0, logger_1.isDevelopment)()) {
+                logger_1.logger.debug("[JSAnimationDetector] Libraries detected", {
+                    gsap: finalResult.gsap.detected,
+                    framerMotion: finalResult.framerMotion.detected,
+                    anime: finalResult.anime.detected,
+                    three: finalResult.three.detected,
+                    threeDetails: finalResult.three.details !== undefined,
+                    lottie: finalResult.lottie.detected,
+                });
+            }
+            return finalResult;
+        }
+        catch (error) {
+            if ((0, logger_1.isDevelopment)()) {
+                logger_1.logger.error("[JSAnimationDetector] Library detection failed", { error });
+            }
+            return {
+                gsap: { detected: false, version: undefined, tweens: undefined },
+                framerMotion: { detected: false, elements: undefined },
+                anime: { detected: false, instances: undefined },
+                three: { detected: false, scenes: undefined, details: undefined },
+                lottie: { detected: false, animations: undefined },
+            };
+        }
+    }
+    /**
+     * JSアニメーションを検出
+     *
+     * @param page - Playwrightページオブジェクト
+     * @param options - 検出オプション
+     * @returns 検出結果
+     */
+    async detect(page, options) {
+        const startTime = Date.now();
+        const opts = { ...DEFAULT_OPTIONS, ...options };
+        if ((0, logger_1.isDevelopment)()) {
+            logger_1.logger.debug("[JSAnimationDetector] detect called", {
+                enableCDP: opts.enableCDP,
+                enableWebAnimations: opts.enableWebAnimations,
+                enableLibraryDetection: opts.enableLibraryDetection,
+                waitTime: opts.waitTime,
+            });
+        }
+        // 並列で検出を実行
+        const [cdpAnimations, webAnimations, libraries] = await Promise.all([
+            opts.enableCDP ? this.detectCDPAnimations(page, opts.waitTime) : Promise.resolve([]),
+            opts.enableWebAnimations ? this.detectWebAnimations(page) : Promise.resolve([]),
+            opts.enableLibraryDetection
+                ? this.detectLibraries(page)
+                : Promise.resolve({
+                    gsap: { detected: false, version: undefined, tweens: undefined },
+                    framerMotion: { detected: false, elements: undefined },
+                    anime: { detected: false, instances: undefined },
+                    three: { detected: false, scenes: undefined },
+                    lottie: { detected: false, animations: undefined },
+                }),
+        ]);
+        const detectionTimeMs = Date.now() - startTime;
+        // 総検出数を計算
+        const totalDetected = cdpAnimations.length +
+            webAnimations.length +
+            (libraries.gsap.tweens ?? 0) +
+            (libraries.framerMotion.elements ?? 0) +
+            (libraries.anime.instances ?? 0) +
+            (libraries.lottie.animations ?? 0);
+        // 総合信頼度スコアを計算（使用されたソースを集約）
+        const usedSources = [];
+        const overallRationale = [];
+        if (opts.enableCDP && cdpAnimations.length > 0) {
+            usedSources.push("cdp");
+            overallRationale.push(`CDP animations detected: ${cdpAnimations.length}`);
+        }
+        if (opts.enableWebAnimations && webAnimations.length > 0) {
+            usedSources.push("web_animations_api");
+            overallRationale.push(`Web Animations detected: ${webAnimations.length}`);
+        }
+        if (opts.enableLibraryDetection) {
+            const detectedLibraries = [];
+            if (libraries.gsap.detected)
+                detectedLibraries.push("GSAP");
+            if (libraries.framerMotion.detected)
+                detectedLibraries.push("Framer Motion");
+            if (libraries.anime.detected)
+                detectedLibraries.push("anime.js");
+            if (libraries.three.detected)
+                detectedLibraries.push("Three.js");
+            if (libraries.lottie.detected)
+                detectedLibraries.push("Lottie");
+            if (detectedLibraries.length > 0) {
+                usedSources.push("library_signature");
+                overallRationale.push(`Libraries detected: ${detectedLibraries.join(", ")}`);
+            }
+        }
+        overallRationale.push(`Detection time: ${detectionTimeMs}ms`);
+        const overallConfidence = usedSources.length > 0
+            ? calculateConfidence(usedSources, overallRationale)
+            : calculateConfidence([], ["No animations detected"]);
+        const result = {
+            cdpAnimations,
+            webAnimations,
+            libraries,
+            detectionTimeMs,
+            totalDetected,
+            overallConfidence,
+        };
+        if ((0, logger_1.isDevelopment)()) {
+            logger_1.logger.info("[JSAnimationDetector] Detection completed", {
+                cdpAnimations: cdpAnimations.length,
+                webAnimations: webAnimations.length,
+                totalDetected,
+                detectionTimeMs,
+                overallConfidenceScore: overallConfidence.score,
+            });
+        }
+        return result;
+    }
+    /**
+     * CDPセッションをクリーンアップ
+     */
+    async cleanup() {
+        if (this.cdpSession) {
+            try {
+                await this.cdpSession.send("Animation.disable");
+                await this.cdpSession.detach();
+            }
+            catch {
+                // クリーンアップエラーは無視
+            }
+            this.cdpSession = null;
+        }
+        this.cdpAnimations.clear();
+        this.isListening = false;
+        if ((0, logger_1.isDevelopment)()) {
+            logger_1.logger.debug("[JSAnimationDetector] Cleanup completed");
+        }
+    }
+}
+exports.JSAnimationDetectorService = JSAnimationDetectorService;
+// =====================================================
+// ファクトリ関数
+// =====================================================
+/**
+ * JSAnimationDetectorService インスタンスを作成
+ */
+function createJSAnimationDetector() {
+    return new JSAnimationDetectorService();
+}
+//# sourceMappingURL=js-animation-detector.js.map