@mindexec/cli 0.2.339 → 0.2.341

package/wwwroot/_content/MindExecution.Shared/js/mind-map-object-manager.js

@@ -1,489 +0,0 @@
-// File: mind-map-object-manager.js
-// [Refactor] Creates and updates WebGL node groups (THREE.Group / THREE.Mesh).
-(function () {
-    'use strict';
-    // Keep glow purely in CSS layers; avoid spending WebGL budget on halo effects.
-    const ENABLE_WEBGL_GLOW = false;
-    const MEMO_WEBGL_THEMES = {
-        coral: { fill: 0xfff1eb, border: 0xf7b08d, accent: 0xff8052 },
-        amber: { fill: 0xfff7df, border: 0xf4d06f, accent: 0xf59e0b },
-        sun: { fill: 0xfff9d7, border: 0xe7d668, accent: 0xca8a04 },
-        sage: { fill: 0xeef6e7, border: 0xbed79f, accent: 0x65a30d },
-        mint: { fill: 0xe8faf4, border: 0x8fd8c1, accent: 0x10b981 },
-        sky: { fill: 0xe8f4ff, border: 0x9dc7f7, accent: 0x3b82f6 },
-        indigo: { fill: 0xeef0ff, border: 0xbcc2ff, accent: 0x6366f1 },
-        violet: { fill: 0xf5ecff, border: 0xd6b8ff, accent: 0x8b5cf6 },
-        rose: { fill: 0xffeef2, border: 0xf5b2c2, accent: 0xf43f5e },
-        gray: { fill: 0xf3f4f6, border: 0xd1d5db, accent: 0x6b7280 },
-        slate: { fill: 0xf3f5f7, border: 0xcbd5e1, accent: 0x64748b }
-    };
-
-    function getNodeMetadata(nodeModel) {
-        return nodeModel?.metadata || nodeModel?.Metadata || null;
-    }
-
-    function isAgentStyledMemoNode(nodeModel) {
-        const metadata = getNodeMetadata(nodeModel);
-        const semanticType = String(metadata?.SemanticType || metadata?.semanticType || '').trim();
-        return semanticType === 'MindCanvasAgent' || semanticType === 'AgentCommand';
-    }
-
-    function getMemoWebglTheme(nodeModel) {
-        const fallbackKey = 'coral';
-        const key = String(getNodeMetadata(nodeModel)?.memoColor || fallbackKey).toLowerCase();
-        return MEMO_WEBGL_THEMES[key] || MEMO_WEBGL_THEMES[fallbackKey];
-    }
-
-    function createRoundedRectGeometry(width, height, radius) {
-        const shape = new THREE.Shape();
-        const x = -width / 2;
-        const y = -height / 2;
-
-        // Start at bottom-left, go clockwise
-        shape.moveTo(x, y + radius);
-        shape.quadraticCurveTo(x, y, x + radius, y);
-
-        shape.lineTo(x + width - radius, y);
-        shape.quadraticCurveTo(x + width, y, x + width, y + radius);
-
-        shape.lineTo(x + width, y + height - radius);
-        shape.quadraticCurveTo(x + width, y + height, x + width - radius, y + height);
-
-        shape.lineTo(x + radius, y + height);
-        shape.quadraticCurveTo(x, y + height, x, y + height - radius);
-
-        shape.lineTo(x, y + radius);
-
-        const points = shape.getPoints();
-        return new THREE.BufferGeometry().setFromPoints(points);
-    }
-
-    // ▼▼▼ [New] Create FILLED rounded rectangle for scrollbar ▼▼▼
-    // Note: This draws DOWNWARD (negative Y) to match node coordinate system
-    function createRoundedRectFilledGeometry(width, height, radius) {
-        const shape = new THREE.Shape();
-        const x = 0;
-        const y = 0;
-        const r = Math.min(radius, width / 2, height / 2);
-        const h = -height; // Draw downward (negative Y direction)
-
-        // Start at top-left corner, draw clockwise (going down)
-        shape.moveTo(x + r, y);
-        shape.lineTo(x + width - r, y);
-        shape.quadraticCurveTo(x + width, y, x + width, y - r);
-        shape.lineTo(x + width, y + h + r);
-        shape.quadraticCurveTo(x + width, y + h, x + width - r, y + h);
-        shape.lineTo(x + r, y + h);
-        shape.quadraticCurveTo(x, y + h, x, y + h + r);
-        shape.lineTo(x, y - r);
-        shape.quadraticCurveTo(x, y, x + r, y);
-
-        return new THREE.ShapeGeometry(shape);
-    }
-    // ▲▲▲ [New] ▲▲▲
-
-    const IMAGE_SELECTION_GLOW_PAD = 18;
-    const IMAGE_SELECTION_GLOW_COLOR = 0x1e3a8a;
-    const IMAGE_SELECTION_GLOW_OPACITY = 0.18;
-
-    function syncImageSelectionGlow(group, width, height, baseRenderOrder, isSelected) {
-        if (!group) return null;
-
-        let outline = group.getObjectByName('outline');
-        if (!outline) {
-            outline = new THREE.Mesh(
-                createRoundedRectFilledGeometry(
-                    width + IMAGE_SELECTION_GLOW_PAD,
-                    height + IMAGE_SELECTION_GLOW_PAD,
-                    20 + (IMAGE_SELECTION_GLOW_PAD * 0.5)
-                ),
-                new THREE.MeshBasicMaterial({
-                    color: IMAGE_SELECTION_GLOW_COLOR,
-                    transparent: true,
-                    opacity: 0,
-                    depthWrite: false,
-                    depthTest: false
-                })
-            );
-            outline.name = 'outline';
-            outline.userData = { ...(outline.userData || {}), isImageSelectionGlow: true };
-            group.add(outline);
-        }
-
-        if (outline.geometry) {
-            outline.geometry.dispose?.();
-        }
-        outline.geometry = createRoundedRectFilledGeometry(
-            width + IMAGE_SELECTION_GLOW_PAD,
-            height + IMAGE_SELECTION_GLOW_PAD,
-            20 + (IMAGE_SELECTION_GLOW_PAD * 0.5)
-        );
-        outline.position.set(-(IMAGE_SELECTION_GLOW_PAD / 2), IMAGE_SELECTION_GLOW_PAD / 2, 0);
-        outline.renderOrder = baseRenderOrder - 1;
-        outline.visible = !!isSelected;
-
-        if (outline.material) {
-            outline.material.color.setHex(IMAGE_SELECTION_GLOW_COLOR);
-            outline.material.opacity = isSelected ? IMAGE_SELECTION_GLOW_OPACITY : 0;
-            outline.material.transparent = true;
-            outline.material.depthWrite = false;
-            outline.material.depthTest = false;
-            outline.material.needsUpdate = true;
-        }
-
-        return outline;
-    }
-
-    // ▲▲▲ [Change] ▲▲▲
-
-    async function createOrUpdateCanvasTextureNode(module, nodeModel, existingGroup = null, zPos = 0, textures, width, height) {
-        // ▼▼▼ [Changed] Identify nodes handled by CSS3D (Text, Note, Code) ▼▼▼
-        // These nodes render as simple background meshes in WebGL (Mesh), content is in DOM.
-        const isCss3dNode = ['text', 'note', 'memo', 'code', 'markdown'].includes(nodeModel.contentType);
-        // ▲▲▲ [Changed] ▲▲▲
-
-        // For non-CSS3D nodes, validate textures
-        if (!isCss3dNode && (!textures || !textures.default || !textures.selected)) {
-            console.error(`[MindMapObjectManager] Cannot create node ${nodeModel.id}: Invalid textures object provided.`);
-            return null;
-        }
-
-        const TAIL_HEIGHT = 12;
-        const HANDLE_SIZE = 16; // Changed from 36 to 16 to match CSS handles and prevent ghost touches
-        const CORNER_RADIUS = 20;
-        const DEFAULT_OUTLINE_COLOR = 0x374151;
-        const SELECTED_OUTLINE_COLOR = 0x7b7ff2;
-        const memoTheme = String(nodeModel?.contentType ?? '').toLowerCase() === 'memo' ? getMemoWebglTheme(nodeModel) : null;
-        const defaultBorderHex = memoTheme ? memoTheme.border : DEFAULT_OUTLINE_COLOR;
-        const bodyFillHex = memoTheme ? memoTheme.fill : 0xfefefe;
-        const isSelected = module.multiSelectedNodeIds.has(nodeModel.id);
-        const selectedBorderHex = isCss3dNode
-            ? SELECTED_OUTLINE_COLOR
-            : (memoTheme ? memoTheme.accent : SELECTED_OUTLINE_COLOR);
-        const outlineColor = isSelected ? selectedBorderHex : defaultBorderHex;
-        const OUTLINE_SHRINK = 2;
-        const OUTLINE_RADIUS = Math.max(1, CORNER_RADIUS - 1);
-
-        if (existingGroup) {
-            const active = isSelected ? (textures?.selected || {}) : (textures?.default || {});
-            const bodyMesh = existingGroup.getObjectByName('body');
-            const tailMesh = existingGroup.getObjectByName('tail');
-            const glowMesh = existingGroup.getObjectByName('glow');
-            let outline = existingGroup.getObjectByName('outline');
-            let baseRenderOrder = existingGroup.userData?.baseRenderOrder;
-            if (baseRenderOrder === undefined) {
-                baseRenderOrder = bodyMesh?.renderOrder ?? module.nodeZCounter++;
-                existingGroup.userData = {
-                    ...(existingGroup.userData || {}),
-                    baseRenderOrder
-                };
-            }
-
-            if (bodyMesh) {
-                const gp = bodyMesh.geometry && bodyMesh.geometry.parameters;
-                if (!gp || gp.width !== width || gp.height !== height) {
-                    bodyMesh.geometry.dispose();
-                    bodyMesh.geometry = new THREE.PlaneGeometry(width, height);
-
-                    if (outline) {
-                        outline.geometry.dispose();
-                        outline.geometry = createRoundedRectGeometry(
-                            width - OUTLINE_SHRINK,
-                            height - OUTLINE_SHRINK,
-                            OUTLINE_RADIUS
-                        );
-                    }
-                }
-                bodyMesh.position.set(width / 2, -height / 2, 0);
-                if (nodeModel.contentType === 'image') {
-                    syncImageSelectionGlow(existingGroup, width, height, baseRenderOrder, isSelected);
-                    window.MindMapNodes?.syncImageMidLodDecorations?.(existingGroup, width, height, baseRenderOrder, isSelected);
-                } else if (outline) {
-                    outline.position.copy(bodyMesh.position);
-                    outline.position.z = 0; // [Fix] Z=0 for parallax elimination
-                    outline.visible = false;
-                    if (outline.material) {
-                        outline.material.color.setHex(isSelected ? selectedBorderHex : defaultBorderHex);
-                        outline.material.opacity = isSelected ? 1.0 : 0.5;
-                    }
-                }
-
-                if (bodyMesh.material?.uniforms) {
-                    if (bodyMesh.material.uniforms.bgColor) {
-                        bodyMesh.material.uniforms.bgColor.value.setHex(bodyFillHex);
-                    }
-                    if (bodyMesh.material.uniforms.borderColor) {
-                        bodyMesh.material.uniforms.borderColor.value.setHex(isSelected ? selectedBorderHex : defaultBorderHex);
-                    }
-                }
-            }
-            if (tailMesh) {
-                tailMesh.position.set(width / 2, -height - (TAIL_HEIGHT / 2), 0);
-                if (active?.tail && tailMesh.material) {
-                    tailMesh.material.map = active.tail;
-                    tailMesh.material.needsUpdate = true;
-                }
-            }
-            // Update resize handles (omitted for brevity, handled by existing code flow if not changed)
-            if (nodeModel.contentType !== 'pdf') {
-                const edgeWidthLength = Math.max(10, width - HANDLE_SIZE * 2);
-                const edgeHeightLength = Math.max(10, height - HANDLE_SIZE * 2);
-                const handleConfigs = {
-                    // ▼▼▼ [Fix] Z값을 0으로 통일하여 시차(Parallax) 완전 제거 ▼▼▼
-                    'resizeHandle_TL': { x: HANDLE_SIZE / 2, y: -HANDLE_SIZE / 2, w: HANDLE_SIZE, h: HANDLE_SIZE, z: 0 },
-                    'resizeHandle_TR': { x: width - HANDLE_SIZE / 2, y: -HANDLE_SIZE / 2, w: HANDLE_SIZE, h: HANDLE_SIZE, z: 0 },
-                    'resizeHandle_BL': { x: HANDLE_SIZE / 2, y: -height + HANDLE_SIZE / 2, w: HANDLE_SIZE, h: HANDLE_SIZE, z: 0 },
-                    'resizeHandle_BR': { x: width - HANDLE_SIZE / 2, y: -height + HANDLE_SIZE / 2, w: HANDLE_SIZE, h: HANDLE_SIZE, z: 0 }
-                    // ▲▲▲ [Fix] ▲▲▲
-                };
-                if (nodeModel.contentType !== 'image') {
-                    Object.assign(handleConfigs, {
-                        'resizeHandle_T': { x: width / 2, y: -HANDLE_SIZE / 2, w: edgeWidthLength, h: HANDLE_SIZE, z: 0 },
-                        'resizeHandle_B': { x: width / 2, y: -height + HANDLE_SIZE / 2, w: edgeWidthLength, h: HANDLE_SIZE, z: 0 },
-                        'resizeHandle_L': { x: HANDLE_SIZE / 2, y: -height / 2, w: HANDLE_SIZE, h: edgeHeightLength, z: 0 },
-                        'resizeHandle_R': { x: width - HANDLE_SIZE / 2, y: -height / 2, w: HANDLE_SIZE, h: edgeHeightLength, z: 0 }
-                    });
-                }
-                Object.entries(handleConfigs).forEach(([name, cfg]) => {
-                    const handle = existingGroup.getObjectByName(name);
-                    if (handle) {
-                        handle.position.set(cfg.x, cfg.y, cfg.z);
-                        const gp = handle.geometry?.parameters;
-                        if (gp && (gp.width !== cfg.w || gp.height !== cfg.h)) {
-                            handle.geometry.dispose();
-                            handle.geometry = new THREE.PlaneGeometry(cfg.w, cfg.h);
-                        }
-                        if (nodeModel.contentType === 'image' && handle.material) {
-                            handle.material.opacity = 0.0;
-                            handle.material.colorWrite = false;
-                            handle.material.needsUpdate = true;
-                        }
-                    }
-                });
-                if (nodeModel.contentType === 'image') {
-                    ['resizeHandle_T', 'resizeHandle_B', 'resizeHandle_L', 'resizeHandle_R'].forEach(name => {
-                        const handle = existingGroup.getObjectByName(name);
-                        if (handle) {
-                            handle.visible = false;
-                        }
-                    });
-                }
-            }
-
-            // ▼▼▼ [Changed] CSS3D nodes: keep simplified material (or shader), skip texture update ▼▼▼
-            if (!isCss3dNode) {
-                const active = isSelected ? textures.selected : textures.default;
-                if (bodyMesh && bodyMesh.material) { bodyMesh.material.map = active.body; bodyMesh.material.needsUpdate = true; }
-                if (tailMesh && tailMesh.material) { tailMesh.material.map = active.tail; tailMesh.material.needsUpdate = true; }
-            }
-            // ▲▲▲ [Changed] ▲▲▲
-
-            if (!ENABLE_WEBGL_GLOW && glowMesh) {
-                existingGroup.remove(glowMesh);
-                try { glowMesh.geometry?.dispose?.(); } catch { }
-                try { glowMesh.material?.dispose?.(); } catch { }
-            } else if (ENABLE_WEBGL_GLOW && window.MindMapGlowShader) {
-                const contentType = nodeModel.contentType || 'text';
-                if (!glowMesh) {
-                    const glow = window.MindMapGlowShader.createSDFGlowMesh(width, height, isSelected, contentType);
-                    glow.position.set(width / 2, -height / 2, 0.0);
-                    glow.renderOrder = baseRenderOrder - 5;
-                    const cameraZ = module.camera?.position?.z ?? Infinity;
-                    const threshold = 4000;
-                    glow.visible = cameraZ < threshold;
-                    existingGroup.add(glow);
-                } else {
-                    window.MindMapGlowShader.updateGlowSize(glowMesh, width, height, contentType);
-                    window.MindMapGlowShader.updateGlowSelection(glowMesh, isSelected);
-                    glowMesh.position.set(width / 2, -height / 2, 0.0);
-                    glowMesh.renderOrder = baseRenderOrder - 5;
-                }
-            }
-
-            existingGroup.userData.worldWidth = width;
-            existingGroup.userData.worldHeight = height;
-            existingGroup.userData.baseRenderOrder = baseRenderOrder;
-
-            return existingGroup;
-
-        } else {
-            // --- Create new group ---
-            const group = new THREE.Group();
-            const baseRenderOrder = module.nodeZCounter++;
-            const active = isSelected ? (textures?.selected || {}) : (textures?.default || {});
-
-            // SDF Glow (disabled by default; use CSS selected states instead)
-            if (ENABLE_WEBGL_GLOW && window.MindMapGlowShader) {
-                const contentType = nodeModel.contentType || 'text';
-                const glowMesh = window.MindMapGlowShader.createSDFGlowMesh(width, height, isSelected, contentType);
-                glowMesh.position.set(width / 2, -height / 2, 0.0);
-                glowMesh.renderOrder = baseRenderOrder - 5;
-                const cameraZ = module.camera?.position?.z ?? Infinity;
-                const threshold = 4000;
-                glowMesh.visible = cameraZ < threshold;
-                group.add(glowMesh);
-            }
-
-            // Body
-            const bodyGeometry = new THREE.PlaneGeometry(width, height);
-            let bodyMaterial;
-
-            if (isCss3dNode) {
-                // ▼▼▼ [Optimized] CSS3D nodes: use SDF shader for border (no texture = saves memory) ▼▼▼
-                // This replaces the textured material for text/note/code
-                bodyMaterial = new THREE.ShaderMaterial({
-                    transparent: false,  // ★ 불투명하게 변경 - 그리드가 비치지 않도록
-                    depthWrite: true,
-                    depthTest: true,
-                    uniforms: {
-                        bgColor: { value: new THREE.Color(bodyFillHex) },
-                        borderColor: { value: new THREE.Color(isSelected ? selectedBorderHex : defaultBorderHex) },
-                        borderWidth: { value: 3.0 },
-                        meshSize: { value: new THREE.Vector2(width, height) }
-                    },
-                    vertexShader: `
-                        varying vec2 vUv;
-                        void main() {
-                            vUv = uv;
-                            gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
-                        }
-                    `,
-                    fragmentShader: `
-                        precision highp float;
-                        varying vec2 vUv;
-                        uniform vec3 bgColor;
-                        uniform vec3 borderColor;
-                        uniform float borderWidth;
-                        uniform vec2 meshSize;
-                        
-                        void main() {
-                            vec2 pixelCoord = vUv * meshSize;
-                            bool inBorder = pixelCoord.x < borderWidth || 
-                                           pixelCoord.x > meshSize.x - borderWidth ||
-                                           pixelCoord.y < borderWidth || 
-                                           pixelCoord.y > meshSize.y - borderWidth;
-                            vec3 finalColor = inBorder ? borderColor : bgColor;
-                            gl_FragColor = vec4(finalColor, 1.0);  // ★ 항상 불투명
-                        }
-                    `
-                });
-                // ▲▲▲ [Optimized] ▲▲▲
-            } else {
-                // Standard mode (Image nodes): use individual texture
-                // ★ [Fix] Image nodes: use fallback color if texture is missing (0xaaaaaa), otherwise white
-                const isImage = nodeModel.contentType === 'image';
-                const hasTexture = !!active.body;
-
-                bodyMaterial = new THREE.MeshBasicMaterial({
-                    map: active.body,
-                    transparent: false,  // ★ 불투명하게 변경 - 그리드가 비치지 않도록
-                    depthWrite: true,
-                    depthTest: true,
-                    color: 0xffffff
-                    // [Fix] polygonOffset 제거 - Z=0 평면에서 renderOrder로만 제어
-                });
-            }
-
-            const bodyMesh = new THREE.Mesh(bodyGeometry, bodyMaterial);
-            bodyMesh.renderOrder = baseRenderOrder;
-            bodyMesh.name = 'body';
-            bodyMesh.position.set(width / 2, -height / 2, 0.0); // ★ z=0.0: 그리드(z=0)와 밀착
-            bodyMesh.userData.nodeId = nodeModel.id;
-            group.add(bodyMesh);
-
-            if (nodeModel.contentType === 'image') {
-                syncImageSelectionGlow(group, width, height, baseRenderOrder, isSelected);
-                window.MindMapNodes?.syncImageMidLodDecorations?.(group, width, height, baseRenderOrder, isSelected);
-            }
-
-            // Tail
-            const tailGeometry = new THREE.PlaneGeometry(TAIL_HEIGHT * 2, TAIL_HEIGHT);
-            let tailMaterial;
-            if (isCss3dNode && !active?.tail) {
-                tailMaterial = new THREE.MeshBasicMaterial({ color: 0xfefefe, transparent: true, opacity: 0.9, depthWrite: false, depthTest: false });
-            } else {
-                tailMaterial = new THREE.MeshBasicMaterial({ map: active?.tail, transparent: true, depthWrite: false, depthTest: false });
-            }
-            const tailMesh = new THREE.Mesh(tailGeometry, tailMaterial);
-            tailMesh.renderOrder = baseRenderOrder;
-            tailMesh.name = 'tail';
-            tailMesh.position.set(width / 2, -height - (TAIL_HEIGHT / 2), 0.0); // ★ z=0.0
-            tailMesh.userData = { nodeId: nodeModel.id, isTailHandle: true };
-            group.add(tailMesh);
-
-            // ▼▼▼ [Removed] Scrollbar creation for CSS3D nodes (DOM handles it) ▼▼▼
-            // (Original code had special logic for code nodes, now removed/skipped)
-            // ▲▲▲ [Removed] ▲▲▲
-
-            // ▼▼▼ [Changed] Add eight resize handles (4 corners + 4 edges spanning full length) ▼▼▼
-            if (nodeModel.contentType !== 'pdf') {
-                // Edge handles span from corner to corner (minus corner handle size)
-                const edgeWidthLength = Math.max(10, width - HANDLE_SIZE * 2);   // horizontal edge length
-                const edgeHeightLength = Math.max(10, height - HANDLE_SIZE * 2); // vertical edge length
-
-                const handles = [];
-
-                // Add edges only if NOT an image node
-                if (nodeModel.contentType !== 'image') {
-                    handles.push(
-                        { name: 'resizeHandle_T', corner: 'T', x: width / 2, y: -HANDLE_SIZE / 2, w: edgeWidthLength, h: HANDLE_SIZE, order: 0 },
-                        { name: 'resizeHandle_B', corner: 'B', x: width / 2, y: -height + HANDLE_SIZE / 2, w: edgeWidthLength, h: HANDLE_SIZE, order: 0 },
-                        { name: 'resizeHandle_L', corner: 'L', x: HANDLE_SIZE / 2, y: -height / 2, w: HANDLE_SIZE, h: edgeHeightLength, order: 0 },
-                        { name: 'resizeHandle_R', corner: 'R', x: width - HANDLE_SIZE / 2, y: -height / 2, w: HANDLE_SIZE, h: edgeHeightLength, order: 0 }
-                    );
-                }
-
-                // Corners always present
-                handles.push(
-                    { name: 'resizeHandle_TL', corner: 'TL', x: HANDLE_SIZE / 2, y: -HANDLE_SIZE / 2, w: HANDLE_SIZE, h: HANDLE_SIZE, order: 1 },
-                    { name: 'resizeHandle_TR', corner: 'TR', x: width - HANDLE_SIZE / 2, y: -HANDLE_SIZE / 2, w: HANDLE_SIZE, h: HANDLE_SIZE, order: 1 },
-                    { name: 'resizeHandle_BL', corner: 'BL', x: HANDLE_SIZE / 2, y: -height + HANDLE_SIZE / 2, w: HANDLE_SIZE, h: HANDLE_SIZE, order: 1 },
-                    { name: 'resizeHandle_BR', corner: 'BR', x: width - HANDLE_SIZE / 2, y: -height + HANDLE_SIZE / 2, w: HANDLE_SIZE, h: HANDLE_SIZE, order: 1 }
-                );
-
-                handles.forEach(c => {
-                    const handleGeom = new THREE.PlaneGeometry(c.w, c.h);
-                    // Use opacity 0.01 instead of 0.0 to ensure Raycaster hits it (some implementations optimize out 0.0)
-                    const handleMat = new THREE.MeshBasicMaterial({ color: 0xff0000, transparent: true, opacity: 0.01, depthWrite: false, depthTest: false });
-                    const handleMesh = new THREE.Mesh(handleGeom, handleMat);
-                    handleMesh.name = c.name;
-                    handleMesh.userData = { nodeId: nodeModel.id, isResizeHandle: true, corner: c.corner };
-                    handleMesh.renderOrder = baseRenderOrder + 10 + c.order; // Boost renderOrder significantly
-                    // ▼▼▼ [Fix] Z값을 0으로 설정 (그리드와 평탄화하여 시차 제거) ▼▼▼
-                    handleMesh.position.set(c.x, c.y, 0);
-                    // ▲▲▲ [Fix] ▲▲▲
-                    group.add(handleMesh);
-                });
-            }
-            // ▲▲▲ [Changed] ▲▲▲
-
-            group.position.set(nodeModel.positionX, nodeModel.positionY, zPos);
-            group.userData = { worldWidth: width, worldHeight: height, nodeId: nodeModel.id, baseRenderOrder };
-            return group;
-        }
-    }
-
-    function createDeferredNodeShell(nodeModel, width, height, zPos = 0, baseRenderOrder = 0) {
-        const group = new THREE.Group();
-        group.position.set(nodeModel.positionX || 0, nodeModel.positionY || 0, zPos);
-        group.visible = false;
-        group.userData = {
-            worldWidth: width,
-            worldHeight: height,
-            nodeId: nodeModel.id,
-            baseRenderOrder,
-            isDeferredShell: true,
-            spatialGridKeys: new Set()
-        };
-        return group;
-    }
-
-    // Expose MindMapObjectManager globally
-    window.MindMapObjectManager = {
-        createOrUpdateCanvasTextureNode: createOrUpdateCanvasTextureNode,
-        createDeferredNodeShell: createDeferredNodeShell,
-        createRoundedRectFilledGeometry: createRoundedRectFilledGeometry // For scrollbar resize in pipeline
-    };
-
-    console.log('✅ mind-map-object-manager.js loaded (Rounded Outline)');
-})();