@reftrixmcp/mcp-server 0.1.7 → 0.2.0

package/dist/services/motion/three-js-scene-extractor.js

@@ -1,1126 +0,0 @@
-"use strict";
-// SPDX-FileCopyrightText: 2026 TKMD and Reftrix Contributors
-// SPDX-License-Identifier: AGPL-3.0-only
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ThreeJSSceneExtractor = void 0;
-exports.createThreeJSSceneExtractor = createThreeJSSceneExtractor;
-const logger_1 = require("../../utils/logger");
-// =====================================================
-// ThreeJSSceneExtractor クラス
-// =====================================================
-/**
- * Three.jsシーングラフ抽出サービス
- *
- * Playwrightページからシーングラフ情報を安全に抽出します。
- * セキュリティ上の制限（深度、オブジェクト数、JSONサイズ）を厳守します。
- */
-class ThreeJSSceneExtractor {
-    // =====================================================
-    // 定数
-    // =====================================================
-    /** シーン数の最大値（デフォルト） */
-    static MAX_SCENES_DEFAULT = 10;
-    /** 子オブジェクト数の最大値（デフォルト） */
-    static MAX_CHILDREN_DEFAULT = 20;
-    /** ネスト深度の最大値（デフォルト） */
-    static MAX_DEPTH_DEFAULT = 3;
-    /** JSONBサイズの最大値（デフォルト: 256KB） */
-    static MAX_JSON_SIZE_DEFAULT = 256 * 1024;
-    /** テクスチャURLの最大数 */
-    static MAX_TEXTURES_DEFAULT = 50;
-    // =====================================================
-    // 数値検証ユーティリティ
-    // =====================================================
-    /**
-     * 数値を検証し、範囲内に収める
-     *
-     * @param val - 検証する値
-     * @param min - 最小値
-     * @param max - 最大値
-     * @returns 検証結果
-     */
-    static validateNumber(val, min, max) {
-        // null/undefined チェック
-        if (val === null || val === undefined) {
-            return { valid: false, reason: "null or undefined" };
-        }
-        // 型チェック
-        if (typeof val !== "number") {
-            return { valid: false, reason: "not a number" };
-        }
-        // NaN チェック
-        if (Number.isNaN(val)) {
-            return { valid: false, reason: "NaN" };
-        }
-        // Infinity チェック
-        if (!Number.isFinite(val)) {
-            return { valid: false, reason: "Infinity" };
-        }
-        // 範囲チェック（クランプ）
-        const clamped = Math.min(Math.max(val, min), max);
-        return {
-            valid: true,
-            sanitizedValue: clamped,
-        };
-    }
-    /**
-     * Vector3を安全に抽出
-     *
-     * @param vec - 検証するベクトル
-     * @returns 安全なベクトル配列またはundefined
-     */
-    static sanitizeVector3(vec) {
-        if (!vec || typeof vec !== "object") {
-            return undefined;
-        }
-        const obj = vec;
-        // x, y, z が存在するか確認
-        if (!("x" in obj) || !("y" in obj) || !("z" in obj)) {
-            return undefined;
-        }
-        const xResult = ThreeJSSceneExtractor.validateNumber(obj.x, -1e10, 1e10);
-        const yResult = ThreeJSSceneExtractor.validateNumber(obj.y, -1e10, 1e10);
-        const zResult = ThreeJSSceneExtractor.validateNumber(obj.z, -1e10, 1e10);
-        if (!xResult.valid || !yResult.valid || !zResult.valid) {
-            return undefined;
-        }
-        return [xResult.sanitizedValue, yResult.sanitizedValue, zResult.sanitizedValue];
-    }
-    // =====================================================
-    // シーングラフ抽出
-    // =====================================================
-    /**
-     * 再帰的にシーングラフを抽出
-     *
-     * @param obj - Three.jsオブジェクト
-     * @param options - 抽出オプション
-     * @param currentDepth - 現在の深度
-     * @param visitedSet - 循環参照検出用のUUIDセット
-     * @returns 抽出結果
-     */
-    static extractSceneGraphNode(obj, options, currentDepth, visitedSet) {
-        // 深度制限チェック
-        if (currentDepth > options.maxDepth) {
-            return {
-                node: { type: "Group", truncated: true, depth: currentDepth },
-                objectCount: 0,
-                truncated: true,
-            };
-        }
-        if (!obj || typeof obj !== "object") {
-            return { node: null, objectCount: 0, truncated: false };
-        }
-        const threeObj = obj;
-        // UUIDベースの循環参照検出
-        const uuid = typeof threeObj.uuid === "string" ? threeObj.uuid : undefined;
-        if (uuid) {
-            if (visitedSet.has(uuid)) {
-                // 循環参照検出
-                return {
-                    node: { type: "CircularReference", truncated: true },
-                    objectCount: 0,
-                    truncated: true,
-                };
-            }
-            visitedSet.add(uuid);
-        }
-        // オブジェクトタイプを取得
-        const type = typeof threeObj.type === "string" ? threeObj.type : "Object3D";
-        // 基本ノード構築
-        const node = {
-            type,
-            depth: currentDepth,
-        };
-        // 名前
-        if (typeof threeObj.name === "string" && threeObj.name !== "") {
-            node.name = threeObj.name;
-        }
-        // UUID
-        if (uuid) {
-            node.uuid = uuid;
-        }
-        // 位置
-        const position = ThreeJSSceneExtractor.sanitizeVector3(threeObj.position);
-        if (position) {
-            node.position = position;
-        }
-        // 回転
-        const rotation = ThreeJSSceneExtractor.sanitizeVector3(threeObj.rotation);
-        if (rotation) {
-            node.rotation = rotation;
-        }
-        // スケール
-        const scale = ThreeJSSceneExtractor.sanitizeVector3(threeObj.scale);
-        if (scale) {
-            node.scale = scale;
-        }
-        // ジオメトリ情報
-        if (threeObj.geometry && typeof threeObj.geometry === "object") {
-            const geo = threeObj.geometry;
-            node.geometry = typeof geo.type === "string" ? geo.type : "BufferGeometry";
-        }
-        // マテリアル情報
-        if (threeObj.material && options.extractMaterialDetails) {
-            const mat = ThreeJSSceneExtractor.extractMaterialInfo(threeObj.material);
-            if (mat) {
-                node.material = mat;
-            }
-        }
-        // ライト固有情報
-        if (type.includes("Light")) {
-            if (threeObj.color && typeof threeObj.color === "object") {
-                const color = threeObj.color;
-                if (typeof color.getHexString === "function") {
-                    try {
-                        node.color = `#${color.getHexString()}`;
-                    }
-                    catch {
-                        // getHexString失敗は無視
-                    }
-                }
-            }
-            const intensityResult = ThreeJSSceneExtractor.validateNumber(threeObj.intensity, 0, 1000);
-            if (intensityResult.valid && intensityResult.sanitizedValue !== undefined) {
-                node.intensity = intensityResult.sanitizedValue;
-            }
-        }
-        // InstancedMesh固有
-        if (type === "InstancedMesh" || threeObj.isInstancedMesh === true) {
-            const countResult = ThreeJSSceneExtractor.validateNumber(threeObj.count, 0, 1e6);
-            if (countResult.valid && countResult.sanitizedValue !== undefined) {
-                node.instanceCount = countResult.sanitizedValue;
-            }
-        }
-        // SkinnedMesh固有
-        if (type === "SkinnedMesh" || threeObj.isSkinnedMesh === true) {
-            if (threeObj.skeleton && typeof threeObj.skeleton === "object") {
-                const skeleton = threeObj.skeleton;
-                if (Array.isArray(skeleton.bones)) {
-                    node.boneCount = skeleton.bones.length;
-                }
-            }
-        }
-        let totalObjectCount = 1;
-        let wasTruncated = false;
-        // 子オブジェクト処理
-        if (Array.isArray(threeObj.children) && threeObj.children.length > 0) {
-            const children = threeObj.children.slice(0, options.maxChildrenPerScene);
-            wasTruncated = threeObj.children.length > options.maxChildrenPerScene;
-            node.children = [];
-            for (const child of children) {
-                const childResult = ThreeJSSceneExtractor.extractSceneGraphNode(child, options, currentDepth + 1, visitedSet);
-                if (childResult.node) {
-                    node.children.push(childResult.node);
-                    totalObjectCount += childResult.objectCount;
-                    wasTruncated = wasTruncated || childResult.truncated;
-                }
-            }
-        }
-        else if (threeObj.children !== undefined && !Array.isArray(threeObj.children)) {
-            // childrenが配列でない場合は空配列として扱う
-            node.children = [];
-        }
-        if (wasTruncated) {
-            node.truncated = true;
-        }
-        return { node, objectCount: totalObjectCount, truncated: wasTruncated };
-    }
-    /**
-     * シーングラフ抽出（単一シーン）
-     */
-    static extractSceneGraph(scene, options) {
-        const startTime = Date.now();
-        const opts = {
-            maxScenes: options?.maxScenes ?? ThreeJSSceneExtractor.MAX_SCENES_DEFAULT,
-            maxChildrenPerScene: options?.maxChildrenPerScene ?? ThreeJSSceneExtractor.MAX_CHILDREN_DEFAULT,
-            maxDepth: options?.maxDepth ?? ThreeJSSceneExtractor.MAX_DEPTH_DEFAULT,
-            maxJsonSize: options?.maxJsonSize ?? ThreeJSSceneExtractor.MAX_JSON_SIZE_DEFAULT,
-            extractTextures: options?.extractTextures ?? true,
-            extractMaterialDetails: options?.extractMaterialDetails ?? true,
-        };
-        const errors = [];
-        const limitsApplied = {
-            sceneLimit: false,
-            childrenLimit: false,
-            depthLimit: false,
-            sizeLimit: false,
-        };
-        // 配列として扱う
-        const scenesInput = Array.isArray(scene) ? scene : [scene];
-        const originalSceneCount = scenesInput.length;
-        // シーン数制限
-        const limitedScenes = scenesInput.slice(0, opts.maxScenes);
-        limitsApplied.sceneLimit = scenesInput.length > opts.maxScenes;
-        const extractedScenes = [];
-        let totalOriginalObjects = 0;
-        let totalExtractedObjects = 0;
-        for (let i = 0; i < limitedScenes.length; i++) {
-            const sceneObj = limitedScenes[i];
-            if (!sceneObj || typeof sceneObj !== "object") {
-                continue;
-            }
-            const threeScene = sceneObj;
-            const visitedSet = new Set();
-            // シーンID
-            const sceneId = typeof threeScene.uuid === "string" ? threeScene.uuid : `scene-${i}`;
-            // シーン名
-            const sceneName = typeof threeScene.name === "string" && threeScene.name !== "" ? threeScene.name : undefined;
-            // 背景色
-            let background;
-            if (threeScene.background && typeof threeScene.background === "object") {
-                const bg = threeScene.background;
-                if (bg.isColor && typeof bg.getHexString === "function") {
-                    try {
-                        background = `#${bg.getHexString()}`;
-                    }
-                    catch {
-                        // 取得失敗は無視
-                    }
-                }
-            }
-            // フォグ情報
-            let fog;
-            if (threeScene.fog && typeof threeScene.fog === "object") {
-                const fogObj = threeScene.fog;
-                const fogColor = fogObj.color;
-                let fogColorHex = "#000000";
-                if (fogColor && typeof fogColor.getHexString === "function") {
-                    try {
-                        fogColorHex = `#${fogColor.getHexString()}`;
-                    }
-                    catch {
-                        // 取得失敗は無視
-                    }
-                }
-                fog = {
-                    type: fogObj.isFogExp2 === true ? "FogExp2" : "Fog",
-                    color: fogColorHex,
-                };
-                // FogExp2のdensity
-                if (typeof fogObj.density === "number" && Number.isFinite(fogObj.density)) {
-                    fog.density = fogObj.density;
-                }
-                // Fogのnear/far
-                if (typeof fogObj.near === "number" && Number.isFinite(fogObj.near)) {
-                    fog.near = fogObj.near;
-                }
-                if (typeof fogObj.far === "number" && Number.isFinite(fogObj.far)) {
-                    fog.far = fogObj.far;
-                }
-            }
-            // 子オブジェクト抽出
-            const sceneGraph = [];
-            let sceneObjectCount = 0;
-            let sceneTruncated = false;
-            if (Array.isArray(threeScene.children)) {
-                totalOriginalObjects += ThreeJSSceneExtractor.countObjects(threeScene);
-                const children = threeScene.children.slice(0, opts.maxChildrenPerScene);
-                limitsApplied.childrenLimit =
-                    limitsApplied.childrenLimit || threeScene.children.length > opts.maxChildrenPerScene;
-                for (const child of children) {
-                    const result = ThreeJSSceneExtractor.extractSceneGraphNode(child, opts, 1, visitedSet);
-                    if (result.node) {
-                        sceneGraph.push(result.node);
-                        sceneObjectCount += result.objectCount;
-                        sceneTruncated = sceneTruncated || result.truncated;
-                    }
-                }
-            }
-            limitsApplied.depthLimit = limitsApplied.depthLimit || sceneTruncated;
-            totalExtractedObjects += sceneObjectCount;
-            const extendedScene = {
-                id: sceneId,
-                sceneGraph,
-                totalObjects: sceneObjectCount,
-                wasTruncated: sceneTruncated,
-            };
-            if (sceneName !== undefined) {
-                extendedScene.name = sceneName;
-            }
-            if (background !== undefined) {
-                extendedScene.background = background;
-            }
-            if (fog !== undefined) {
-                extendedScene.fog = fog;
-            }
-            extractedScenes.push(extendedScene);
-        }
-        // JSONサイズ検証
-        const jsonStr = JSON.stringify({ scenes: extractedScenes });
-        const jsonSizeBytes = new TextEncoder().encode(jsonStr).length;
-        // サイズ超過時の処理
-        if (jsonSizeBytes > opts.maxJsonSize) {
-            limitsApplied.sizeLimit = true;
-            errors.push(`JSON size (${jsonSizeBytes} bytes) exceeds limit (${opts.maxJsonSize} bytes). Consider reducing depth or children limits.`);
-        }
-        const processingTimeMs = Date.now() - startTime;
-        const result = {
-            scenes: extractedScenes,
-            textures: [],
-            meta: {
-                processingTimeMs,
-                originalSceneCount,
-                extractedSceneCount: extractedScenes.length,
-                originalObjectCount: totalOriginalObjects,
-                extractedObjectCount: totalExtractedObjects,
-                jsonSizeBytes,
-                hitLimits: limitsApplied.sceneLimit ||
-                    limitsApplied.childrenLimit ||
-                    limitsApplied.depthLimit ||
-                    limitsApplied.sizeLimit,
-                limitsApplied,
-            },
-        };
-        if (errors.length > 0) {
-            result.errors = errors;
-        }
-        return result;
-    }
-    /**
-     * オブジェクト総数をカウント
-     */
-    static countObjects(obj) {
-        if (!obj || typeof obj !== "object") {
-            return 0;
-        }
-        const threeObj = obj;
-        let count = 1;
-        if (Array.isArray(threeObj.children)) {
-            for (const child of threeObj.children) {
-                count += ThreeJSSceneExtractor.countObjects(child);
-            }
-        }
-        return count;
-    }
-    // =====================================================
-    // JSONサイズ検証
-    // =====================================================
-    /**
-     * JSONサイズを検証
-     *
-     * @param data - 検証するデータ
-     * @param maxSize - 最大サイズ（バイト）
-     * @returns 検証結果
-     */
-    static validateJsonSize(data, maxSize) {
-        try {
-            const jsonStr = JSON.stringify(data);
-            const size = new TextEncoder().encode(jsonStr).length;
-            return {
-                valid: size <= maxSize,
-                size,
-                truncated: size > maxSize,
-            };
-        }
-        catch {
-            return { valid: false, size: 0, truncated: true };
-        }
-    }
-    // =====================================================
-    // テクスチャ抽出
-    // =====================================================
-    /**
-     * シーンからテクスチャURLを抽出
-     *
-     * @param scenes - シーン配列
-     * @returns テクスチャURL配列（重複なし、最大50個）
-     */
-    static extractTextures(scenes) {
-        const textureUrls = new Set();
-        const extractFromObject = (obj) => {
-            if (!obj || typeof obj !== "object") {
-                return;
-            }
-            const threeObj = obj;
-            // マテリアルからテクスチャを抽出
-            if (threeObj.material) {
-                ThreeJSSceneExtractor.extractTexturesFromMaterial(threeObj.material, textureUrls);
-            }
-            // 子オブジェクトを再帰的に処理
-            if (Array.isArray(threeObj.children)) {
-                for (const child of threeObj.children) {
-                    extractFromObject(child);
-                }
-            }
-        };
-        for (const scene of scenes) {
-            if (scene && typeof scene === "object") {
-                const sceneObj = scene;
-                // シーン直下のオブジェクト
-                if (Array.isArray(sceneObj.children)) {
-                    for (const child of sceneObj.children) {
-                        extractFromObject(child);
-                    }
-                }
-            }
-        }
-        // フィルタリング（data:, blob: を除外）
-        const filteredUrls = Array.from(textureUrls)
-            .filter((url) => !url.startsWith("data:") && !url.startsWith("blob:"))
-            .slice(0, ThreeJSSceneExtractor.MAX_TEXTURES_DEFAULT);
-        return filteredUrls;
-    }
-    /**
-     * マテリアルからテクスチャURLを抽出
-     */
-    static extractTexturesFromMaterial(material, textureUrls) {
-        if (!material || typeof material !== "object") {
-            return;
-        }
-        const mat = material;
-        const textureProps = [
-            "map",
-            "normalMap",
-            "envMap",
-            "aoMap",
-            "emissiveMap",
-            "roughnessMap",
-            "metalnessMap",
-        ];
-        for (const prop of textureProps) {
-            if (mat[prop] && typeof mat[prop] === "object") {
-                const texture = mat[prop];
-                // source.data.src からURL取得
-                if (texture.source && typeof texture.source === "object") {
-                    const source = texture.source;
-                    if (source.data && typeof source.data === "object") {
-                        const data = source.data;
-                        if (typeof data.src === "string" && data.src.length > 0) {
-                            textureUrls.add(data.src);
-                        }
-                    }
-                }
-                // image.src からURL取得（代替パス）
-                if (texture.image && typeof texture.image === "object") {
-                    const image = texture.image;
-                    if (typeof image.src === "string" && image.src.length > 0) {
-                        textureUrls.add(image.src);
-                    }
-                }
-                // name からURL取得（代替パス）
-                if (typeof texture.name === "string" && texture.name.length > 0) {
-                    // ファイル名のような文字列の場合のみ
-                    if (texture.name.includes(".")) {
-                        textureUrls.add(texture.name);
-                    }
-                }
-            }
-        }
-        // 配列マテリアルの場合
-        if (Array.isArray(material)) {
-            for (const m of material) {
-                ThreeJSSceneExtractor.extractTexturesFromMaterial(m, textureUrls);
-            }
-        }
-    }
-    // =====================================================
-    // マテリアル情報抽出
-    // =====================================================
-    /**
-     * マテリアル情報を抽出
-     *
-     * @param material - Three.jsマテリアルオブジェクト
-     * @returns マテリアル情報またはundefined
-     */
-    static extractMaterialInfo(material) {
-        if (!material || typeof material !== "object") {
-            return undefined;
-        }
-        const mat = material;
-        const type = typeof mat.type === "string" ? mat.type : "Material";
-        const info = { type };
-        // シェーダーマテリアルの場合は簡略化
-        if (type === "ShaderMaterial" || type === "RawShaderMaterial") {
-            info.hasCustomShaders = true;
-            return info;
-        }
-        // 色
-        if (mat.color && typeof mat.color === "object") {
-            const color = mat.color;
-            if (typeof color.getHexString === "function") {
-                try {
-                    info.color = `#${color.getHexString()}`;
-                }
-                catch {
-                    // 取得失敗は無視
-                }
-            }
-        }
-        // 放射色
-        if (mat.emissive && typeof mat.emissive === "object") {
-            const emissive = mat.emissive;
-            if (typeof emissive.getHexString === "function") {
-                try {
-                    info.emissive = `#${emissive.getHexString()}`;
-                }
-                catch {
-                    // 取得失敗は無視
-                }
-            }
-        }
-        // 金属度
-        const metalnessResult = ThreeJSSceneExtractor.validateNumber(mat.metalness, 0, 1);
-        if (metalnessResult.valid && metalnessResult.sanitizedValue !== undefined) {
-            info.metalness = metalnessResult.sanitizedValue;
-        }
-        // 粗さ
-        const roughnessResult = ThreeJSSceneExtractor.validateNumber(mat.roughness, 0, 1);
-        if (roughnessResult.valid && roughnessResult.sanitizedValue !== undefined) {
-            info.roughness = roughnessResult.sanitizedValue;
-        }
-        // 透明度
-        const opacityResult = ThreeJSSceneExtractor.validateNumber(mat.opacity, 0, 1);
-        if (opacityResult.valid && opacityResult.sanitizedValue !== undefined) {
-            info.opacity = opacityResult.sanitizedValue;
-        }
-        // 透明フラグ
-        if (typeof mat.transparent === "boolean") {
-            info.transparent = mat.transparent;
-        }
-        // ワイヤーフレームフラグ
-        if (typeof mat.wireframe === "boolean") {
-            info.wireframe = mat.wireframe;
-        }
-        // テクスチャマップ参照
-        if (mat.map && typeof mat.map === "object") {
-            const map = mat.map;
-            if (typeof map.name === "string") {
-                info.map = map.name;
-            }
-            else if (map.source && typeof map.source === "object") {
-                const source = map.source;
-                if (source.data && typeof source.data === "object") {
-                    const data = source.data;
-                    if (typeof data.src === "string") {
-                        info.map = data.src;
-                    }
-                }
-            }
-        }
-        // ノーマルマップ参照
-        if (mat.normalMap && typeof mat.normalMap === "object") {
-            const normalMap = mat.normalMap;
-            if (typeof normalMap.name === "string") {
-                info.normalMap = normalMap.name;
-            }
-        }
-        return info;
-    }
-    // =====================================================
-    // Playwrightページからの抽出
-    // =====================================================
-    /**
-     * Playwrightページからシーングラフを抽出
-     *
-     * @param page - Playwrightページオブジェクト
-     * @param options - 抽出オプション
-     * @returns 抽出結果またはnull
-     */
-    static async extractFromPage(page, options) {
-        const startTime = Date.now();
-        const opts = {
-            maxScenes: options?.maxScenes ?? ThreeJSSceneExtractor.MAX_SCENES_DEFAULT,
-            maxChildrenPerScene: options?.maxChildrenPerScene ?? ThreeJSSceneExtractor.MAX_CHILDREN_DEFAULT,
-            maxDepth: options?.maxDepth ?? ThreeJSSceneExtractor.MAX_DEPTH_DEFAULT,
-            maxJsonSize: options?.maxJsonSize ?? ThreeJSSceneExtractor.MAX_JSON_SIZE_DEFAULT,
-            extractTextures: options?.extractTextures ?? true,
-            extractMaterialDetails: options?.extractMaterialDetails ?? true,
-        };
-        try {
-            const rawData = await page.evaluate((evalOpts) => {
-                // windowの型拡張
-                const win = window;
-                // Three.jsが存在しない場合
-                if (typeof win.THREE === "undefined") {
-                    return null;
-                }
-                // バージョン取得
-                const revision = win.THREE.REVISION;
-                const version = typeof revision === "string"
-                    ? revision.startsWith("r")
-                        ? revision
-                        : `r${revision}`
-                    : undefined;
-                // シーン情報収集
-                const scenesData = [];
-                let webglContextCount = 0;
-                // canvas要素からWebGLコンテキスト数をカウント
-                const canvases = document.querySelectorAll("canvas");
-                canvases.forEach((canvas) => {
-                    try {
-                        const gl = canvas.getContext("webgl") || canvas.getContext("webgl2");
-                        if (gl) {
-                            webglContextCount++;
-                        }
-                    }
-                    catch {
-                        // コンテキスト取得失敗は無視
-                    }
-                });
-                // __THREE_DEVTOOLS__から詳細情報を取得
-                if (win.__THREE_DEVTOOLS__?.scenes && Array.isArray(win.__THREE_DEVTOOLS__.scenes)) {
-                    const devtoolScenes = win.__THREE_DEVTOOLS__.scenes.slice(0, evalOpts.maxScenes);
-                    for (const scene of devtoolScenes) {
-                        if (!scene || typeof scene !== "object") {
-                            continue;
-                        }
-                        const sceneObj = scene;
-                        const uuid = typeof sceneObj.uuid === "string" ? sceneObj.uuid : `auto-${scenesData.length}`;
-                        const sceneData = {
-                            uuid,
-                            children: [],
-                            totalChildrenCount: 0,
-                        };
-                        // 名前
-                        if (typeof sceneObj.name === "string" && sceneObj.name !== "") {
-                            sceneData.name = sceneObj.name;
-                        }
-                        // 背景色
-                        if (sceneObj.background && typeof sceneObj.background === "object") {
-                            const bg = sceneObj.background;
-                            if (bg.isColor && typeof bg.getHexString === "function") {
-                                try {
-                                    sceneData.background = { hex: bg.getHexString() };
-                                }
-                                catch {
-                                    // 取得失敗は無視
-                                }
-                            }
-                        }
-                        // フォグ
-                        if (sceneObj.fog && typeof sceneObj.fog === "object") {
-                            const fogObj = sceneObj.fog;
-                            const fogColor = fogObj.color;
-                            let colorHex = "000000";
-                            if (fogColor && typeof fogColor.getHexString === "function") {
-                                try {
-                                    colorHex = fogColor.getHexString();
-                                }
-                                catch {
-                                    // 取得失敗は無視
-                                }
-                            }
-                            sceneData.fog = {
-                                type: fogObj.isFogExp2 === true ? "FogExp2" : "Fog",
-                                color: colorHex,
-                            };
-                            if (typeof fogObj.density === "number" && Number.isFinite(fogObj.density)) {
-                                sceneData.fog.density = fogObj.density;
-                            }
-                            if (typeof fogObj.near === "number" && Number.isFinite(fogObj.near)) {
-                                sceneData.fog.near = fogObj.near;
-                            }
-                            if (typeof fogObj.far === "number" && Number.isFinite(fogObj.far)) {
-                                sceneData.fog.far = fogObj.far;
-                            }
-                        }
-                        // 子オブジェクト（シリアライズ可能な形式に変換）
-                        const serializeObject = (obj, depth) => {
-                            if (depth > evalOpts.maxDepth || !obj || typeof obj !== "object") {
-                                return depth > evalOpts.maxDepth ? { truncated: true } : null;
-                            }
-                            const threeObj = obj;
-                            const result = {
-                                type: typeof threeObj.type === "string" ? threeObj.type : "Object3D",
-                            };
-                            if (typeof threeObj.uuid === "string") {
-                                result.uuid = threeObj.uuid;
-                            }
-                            if (typeof threeObj.name === "string" && threeObj.name !== "") {
-                                result.name = threeObj.name;
-                            }
-                            // 位置
-                            if (threeObj.position && typeof threeObj.position === "object") {
-                                const pos = threeObj.position;
-                                if (typeof pos.x === "number" &&
-                                    typeof pos.y === "number" &&
-                                    typeof pos.z === "number" &&
-                                    Number.isFinite(pos.x) &&
-                                    Number.isFinite(pos.y) &&
-                                    Number.isFinite(pos.z)) {
-                                    result.position = { x: pos.x, y: pos.y, z: pos.z };
-                                }
-                            }
-                            // 回転
-                            if (threeObj.rotation && typeof threeObj.rotation === "object") {
-                                const rot = threeObj.rotation;
-                                if (typeof rot.x === "number" &&
-                                    typeof rot.y === "number" &&
-                                    typeof rot.z === "number" &&
-                                    Number.isFinite(rot.x) &&
-                                    Number.isFinite(rot.y) &&
-                                    Number.isFinite(rot.z)) {
-                                    result.rotation = { x: rot.x, y: rot.y, z: rot.z };
-                                }
-                            }
-                            // スケール
-                            if (threeObj.scale && typeof threeObj.scale === "object") {
-                                const scl = threeObj.scale;
-                                if (typeof scl.x === "number" &&
-                                    typeof scl.y === "number" &&
-                                    typeof scl.z === "number" &&
-                                    Number.isFinite(scl.x) &&
-                                    Number.isFinite(scl.y) &&
-                                    Number.isFinite(scl.z)) {
-                                    result.scale = { x: scl.x, y: scl.y, z: scl.z };
-                                }
-                            }
-                            // ジオメトリ
-                            if (threeObj.geometry && typeof threeObj.geometry === "object") {
-                                const geo = threeObj.geometry;
-                                result.geometry = {
-                                    type: typeof geo.type === "string" ? geo.type : "BufferGeometry",
-                                };
-                            }
-                            // マテリアル
-                            if (evalOpts.extractMaterialDetails && threeObj.material) {
-                                if (typeof threeObj.material === "object") {
-                                    const mat = threeObj.material;
-                                    const matData = {
-                                        type: typeof mat.type === "string" ? mat.type : "Material",
-                                    };
-                                    // 色
-                                    if (mat.color && typeof mat.color === "object") {
-                                        const color = mat.color;
-                                        if (typeof color.getHexString === "function") {
-                                            try {
-                                                matData.color = color.getHexString();
-                                            }
-                                            catch {
-                                                // 無視
-                                            }
-                                        }
-                                    }
-                                    // PBRプロパティ
-                                    if (typeof mat.metalness === "number" && Number.isFinite(mat.metalness)) {
-                                        matData.metalness = mat.metalness;
-                                    }
-                                    if (typeof mat.roughness === "number" && Number.isFinite(mat.roughness)) {
-                                        matData.roughness = mat.roughness;
-                                    }
-                                    if (typeof mat.opacity === "number" && Number.isFinite(mat.opacity)) {
-                                        matData.opacity = mat.opacity;
-                                    }
-                                    if (typeof mat.transparent === "boolean") {
-                                        matData.transparent = mat.transparent;
-                                    }
-                                    result.material = matData;
-                                }
-                            }
-                            // ライト固有
-                            if (result.type && typeof result.type === "string" && result.type.includes("Light")) {
-                                if (threeObj.color && typeof threeObj.color === "object") {
-                                    const color = threeObj.color;
-                                    if (typeof color.getHexString === "function") {
-                                        try {
-                                            result.lightColor = color.getHexString();
-                                        }
-                                        catch {
-                                            // 無視
-                                        }
-                                    }
-                                }
-                                if (typeof threeObj.intensity === "number" && Number.isFinite(threeObj.intensity)) {
-                                    result.intensity = threeObj.intensity;
-                                }
-                            }
-                            // InstancedMesh
-                            if (result.type === "InstancedMesh" || threeObj.isInstancedMesh === true) {
-                                if (typeof threeObj.count === "number" && Number.isFinite(threeObj.count)) {
-                                    result.instanceCount = threeObj.count;
-                                }
-                            }
-                            // 子オブジェクト
-                            if (Array.isArray(threeObj.children) && threeObj.children.length > 0) {
-                                const children = threeObj.children.slice(0, evalOpts.maxChildrenPerScene);
-                                result.children = children
-                                    .map((child) => serializeObject(child, depth + 1))
-                                    .filter((c) => c !== null);
-                                if (threeObj.children.length > evalOpts.maxChildrenPerScene) {
-                                    result.childrenTruncated = true;
-                                }
-                            }
-                            return result;
-                        };
-                        if (Array.isArray(sceneObj.children)) {
-                            sceneData.totalChildrenCount = sceneObj.children.length;
-                            const limitedChildren = sceneObj.children.slice(0, evalOpts.maxChildrenPerScene);
-                            sceneData.children = limitedChildren
-                                .map((child) => serializeObject(child, 1))
-                                .filter((c) => c !== null);
-                        }
-                        scenesData.push(sceneData);
-                    }
-                }
-                // __THREE_DEVTOOLS__がない場合、WebGLコンテキスト数に基づいてダミーシーン生成
-                if (scenesData.length === 0 && webglContextCount > 0) {
-                    for (let i = 0; i < Math.min(webglContextCount, evalOpts.maxScenes); i++) {
-                        scenesData.push({
-                            uuid: `scene-${i}`,
-                            children: [],
-                            totalChildrenCount: 0,
-                        });
-                    }
-                }
-                return {
-                    version,
-                    scenesData,
-                    webglContextCount,
-                };
-            }, opts);
-            if (!rawData) {
-                if ((0, logger_1.isDevelopment)()) {
-                    logger_1.logger.debug("[ThreeJSSceneExtractor] Three.js not detected on page");
-                }
-                return null;
-            }
-            // 抽出結果を構築
-            const errors = [];
-            const limitsApplied = {
-                sceneLimit: rawData.scenesData.length >= opts.maxScenes,
-                childrenLimit: false,
-                depthLimit: false,
-                sizeLimit: false,
-            };
-            let totalOriginalObjects = 0;
-            let totalExtractedObjects = 0;
-            const extractedScenes = [];
-            for (const sceneData of rawData.scenesData) {
-                totalOriginalObjects += sceneData.totalChildrenCount;
-                const sceneGraph = [];
-                let sceneObjectCount = 0;
-                let sceneTruncated = false;
-                // シリアライズされた子オブジェクトを変換
-                const convertToSceneGraphNode = (obj, depth) => {
-                    if (!obj || typeof obj !== "object") {
-                        return { node: null, count: 0, truncated: false };
-                    }
-                    const data = obj;
-                    if (data.truncated === true) {
-                        return {
-                            node: { type: "Group", truncated: true, depth },
-                            count: 0,
-                            truncated: true,
-                        };
-                    }
-                    const node = {
-                        type: typeof data.type === "string" ? data.type : "Object3D",
-                        depth,
-                    };
-                    if (typeof data.uuid === "string") {
-                        node.uuid = data.uuid;
-                    }
-                    if (typeof data.name === "string") {
-                        node.name = data.name;
-                    }
-                    // 位置
-                    if (data.position && typeof data.position === "object") {
-                        const pos = data.position;
-                        if (typeof pos.x === "number" &&
-                            typeof pos.y === "number" &&
-                            typeof pos.z === "number") {
-                            node.position = [pos.x, pos.y, pos.z];
-                        }
-                    }
-                    // 回転
-                    if (data.rotation && typeof data.rotation === "object") {
-                        const rot = data.rotation;
-                        if (typeof rot.x === "number" &&
-                            typeof rot.y === "number" &&
-                            typeof rot.z === "number") {
-                            node.rotation = [rot.x, rot.y, rot.z];
-                        }
-                    }
-                    // スケール
-                    if (data.scale && typeof data.scale === "object") {
-                        const scl = data.scale;
-                        if (typeof scl.x === "number" &&
-                            typeof scl.y === "number" &&
-                            typeof scl.z === "number") {
-                            node.scale = [scl.x, scl.y, scl.z];
-                        }
-                    }
-                    // ジオメトリ
-                    if (data.geometry && typeof data.geometry === "object") {
-                        const geo = data.geometry;
-                        node.geometry = typeof geo.type === "string" ? geo.type : "BufferGeometry";
-                    }
-                    // マテリアル
-                    if (data.material && typeof data.material === "object") {
-                        const mat = data.material;
-                        const materialInfo = {
-                            type: typeof mat.type === "string" ? mat.type : "Material",
-                        };
-                        if (typeof mat.color === "string") {
-                            materialInfo.color = `#${mat.color}`;
-                        }
-                        if (typeof mat.metalness === "number") {
-                            materialInfo.metalness = mat.metalness;
-                        }
-                        if (typeof mat.roughness === "number") {
-                            materialInfo.roughness = mat.roughness;
-                        }
-                        if (typeof mat.opacity === "number") {
-                            materialInfo.opacity = mat.opacity;
-                        }
-                        if (typeof mat.transparent === "boolean") {
-                            materialInfo.transparent = mat.transparent;
-                        }
-                        node.material = materialInfo;
-                    }
-                    // ライト色
-                    if (typeof data.lightColor === "string") {
-                        node.color = `#${data.lightColor}`;
-                    }
-                    if (typeof data.intensity === "number") {
-                        node.intensity = data.intensity;
-                    }
-                    // InstancedMesh
-                    if (typeof data.instanceCount === "number") {
-                        node.instanceCount = data.instanceCount;
-                    }
-                    let count = 1;
-                    let isTruncated = false;
-                    // 子オブジェクト
-                    if (Array.isArray(data.children) && data.children.length > 0) {
-                        node.children = [];
-                        for (const child of data.children) {
-                            const childResult = convertToSceneGraphNode(child, depth + 1);
-                            if (childResult.node) {
-                                node.children.push(childResult.node);
-                                count += childResult.count;
-                                isTruncated = isTruncated || childResult.truncated;
-                            }
-                        }
-                    }
-                    if (data.childrenTruncated === true) {
-                        node.truncated = true;
-                        isTruncated = true;
-                    }
-                    return { node, count, truncated: isTruncated };
-                };
-                for (const child of sceneData.children) {
-                    const result = convertToSceneGraphNode(child, 1);
-                    if (result.node) {
-                        sceneGraph.push(result.node);
-                        sceneObjectCount += result.count;
-                        sceneTruncated = sceneTruncated || result.truncated;
-                    }
-                }
-                limitsApplied.childrenLimit =
-                    limitsApplied.childrenLimit || sceneData.totalChildrenCount > opts.maxChildrenPerScene;
-                limitsApplied.depthLimit = limitsApplied.depthLimit || sceneTruncated;
-                totalExtractedObjects += sceneObjectCount;
-                const extendedScene = {
-                    id: sceneData.uuid,
-                    sceneGraph,
-                    totalObjects: sceneObjectCount,
-                    wasTruncated: sceneTruncated,
-                };
-                if (sceneData.name !== undefined) {
-                    extendedScene.name = sceneData.name;
-                }
-                if (sceneData.background !== undefined) {
-                    extendedScene.background = `#${sceneData.background.hex}`;
-                }
-                if (sceneData.fog !== undefined) {
-                    extendedScene.fog = {
-                        type: sceneData.fog.type,
-                        color: `#${sceneData.fog.color}`,
-                    };
-                    if (sceneData.fog.density !== undefined) {
-                        extendedScene.fog.density = sceneData.fog.density;
-                    }
-                    if (sceneData.fog.near !== undefined) {
-                        extendedScene.fog.near = sceneData.fog.near;
-                    }
-                    if (sceneData.fog.far !== undefined) {
-                        extendedScene.fog.far = sceneData.fog.far;
-                    }
-                }
-                extractedScenes.push(extendedScene);
-            }
-            // JSONサイズ検証
-            const jsonStr = JSON.stringify({ scenes: extractedScenes });
-            const jsonSizeBytes = new TextEncoder().encode(jsonStr).length;
-            if (jsonSizeBytes > opts.maxJsonSize) {
-                limitsApplied.sizeLimit = true;
-                errors.push(`JSON size (${jsonSizeBytes} bytes) exceeds limit (${opts.maxJsonSize} bytes)`);
-            }
-            const processingTimeMs = Date.now() - startTime;
-            const result = {
-                scenes: extractedScenes,
-                textures: [], // ブラウザコンテキスト外では取得が困難なため空
-                meta: {
-                    processingTimeMs,
-                    originalSceneCount: rawData.scenesData.length,
-                    extractedSceneCount: extractedScenes.length,
-                    originalObjectCount: totalOriginalObjects,
-                    extractedObjectCount: totalExtractedObjects,
-                    jsonSizeBytes,
-                    hitLimits: limitsApplied.sceneLimit ||
-                        limitsApplied.childrenLimit ||
-                        limitsApplied.depthLimit ||
-                        limitsApplied.sizeLimit,
-                    limitsApplied,
-                },
-            };
-            // versionがある場合のみ設定（exactOptionalPropertyTypes対応）
-            if (rawData.version !== undefined) {
-                result.version = rawData.version;
-            }
-            if (errors.length > 0) {
-                result.errors = errors;
-            }
-            if ((0, logger_1.isDevelopment)()) {
-                logger_1.logger.debug("[ThreeJSSceneExtractor] Extraction completed", {
-                    version: result.version,
-                    scenesCount: result.scenes.length,
-                    extractedObjects: totalExtractedObjects,
-                    processingTimeMs,
-                    hitLimits: result.meta.hitLimits,
-                });
-            }
-            return result;
-        }
-        catch (error) {
-            if ((0, logger_1.isDevelopment)()) {
-                logger_1.logger.error("[ThreeJSSceneExtractor] Extraction failed", { error });
-            }
-            return {
-                scenes: [],
-                textures: [],
-                meta: {
-                    processingTimeMs: Date.now() - startTime,
-                    originalSceneCount: 0,
-                    extractedSceneCount: 0,
-                    originalObjectCount: 0,
-                    extractedObjectCount: 0,
-                    jsonSizeBytes: 0,
-                    hitLimits: false,
-                    limitsApplied: {
-                        sceneLimit: false,
-                        childrenLimit: false,
-                        depthLimit: false,
-                        sizeLimit: false,
-                    },
-                },
-                errors: [error instanceof Error ? error.message : "Unknown error"],
-            };
-        }
-    }
-}
-exports.ThreeJSSceneExtractor = ThreeJSSceneExtractor;
-// =====================================================
-// ファクトリ関数
-// =====================================================
-/**
- * ThreeJSSceneExtractor インスタンスを作成
- *
- * 注: このクラスは静的メソッドのみで構成されているため、
- * インスタンス化は必要ありませんが、将来の拡張性のために提供しています。
- */
-function createThreeJSSceneExtractor() {
-    return new ThreeJSSceneExtractor();
-}
-//# sourceMappingURL=three-js-scene-extractor.js.map