sdlc-agent-4-enterprise-server 1.0.0

package/src/viewer/lod-animation.js

@@ -0,0 +1,200 @@
+/**
+ * LOD Animation — Expand/Collapse Transitions
+ * KSA-143: KB Graph Level of Detail / Semantic Zoom
+ * 
+ * Smooth 400ms animations for cluster expand/collapse.
+ * Uses easeOutCubic (expand) and easeInCubic (collapse).
+ */
+
+export class LODAnimation {
+  constructor(graph3dInstance) {
+    this._graph = graph3dInstance;
+    this._active = new Map(); // clusterId -> animation state
+  }
+
+  /**
+   * Expand a cluster: super node fades out, children orbit out.
+   * @param {Object} cluster - cluster object with center, childNodeIds, radius
+   * @param {Array} childNodes - actual node objects to show
+   * @param {Object} options - { duration, onComplete, onPhase }
+   */
+  expand(cluster, childNodes, options = {}) {
+    const duration = options.duration || 400;
+    const onComplete = options.onComplete || (() => {});
+    const startTime = performance.now();
+
+    const positions = this._computeOrbitalPositions(childNodes.length, cluster.center, cluster.radius);
+
+    const state = {
+      clusterId: cluster.id,
+      type: 'expand',
+      startTime,
+      duration,
+      childNodes,
+      positions,
+      onComplete,
+      cancelled: false
+    };
+    this._active.set(cluster.id, state);
+    this._animate(state);
+  }
+
+  /**
+   * Collapse a cluster: children move to center, super node fades in.
+   */
+  collapse(cluster, childNodes, options = {}) {
+    const duration = options.duration || 400;
+    const onComplete = options.onComplete || (() => {});
+    const startTime = performance.now();
+
+    // Store current positions as start
+    const startPositions = childNodes.map(n => ({ x: n.x || 0, y: n.y || 0, z: n.z || 0 }));
+
+    const state = {
+      clusterId: cluster.id,
+      type: 'collapse',
+      startTime,
+      duration,
+      childNodes,
+      startPositions,
+      target: cluster.center,
+      onComplete,
+      cancelled: false
+    };
+    this._active.set(cluster.id, state);
+    this._animate(state);
+  }
+
+  /**
+   * Cancel an in-progress animation.
+   */
+  cancel(clusterId) {
+    const state = this._active.get(clusterId);
+    if (state) {
+      state.cancelled = true;
+      this._active.delete(clusterId);
+    }
+  }
+
+  isAnimating(clusterId) {
+    return this._active.has(clusterId);
+  }
+
+  dispose() {
+    for (const state of this._active.values()) {
+      state.cancelled = true;
+    }
+    this._active.clear();
+  }
+
+  _animate(state) {
+    if (state.cancelled) return;
+
+    const now = performance.now();
+    const elapsed = now - state.startTime;
+    const progress = Math.min(elapsed / state.duration, 1.0);
+
+    if (state.type === 'expand') {
+      this._animateExpand(state, progress);
+    } else {
+      this._animateCollapse(state, progress);
+    }
+
+    if (progress >= 1.0) {
+      this._active.delete(state.clusterId);
+      state.onComplete();
+    } else {
+      requestAnimationFrame(() => this._animate(state));
+    }
+  }
+
+  _animateExpand(state, progress) {
+    const { childNodes, positions, clusterId } = state;
+
+    if (progress >= 0.2 && progress <= 0.8) {
+      const moveProgress = (progress - 0.2) / 0.6;
+      const eased = this._easeOutCubic(moveProgress);
+
+      for (let i = 0; i < childNodes.length; i++) {
+        const target = positions[i];
+        const node = childNodes[i];
+        node.fx = state.positions[i].x * eased + (1 - eased) * (node.__lodCenterX || 0);
+        node.fy = state.positions[i].y * eased + (1 - eased) * (node.__lodCenterY || 0);
+        node.fz = state.positions[i].z * eased + (1 - eased) * (node.__lodCenterZ || 0);
+      }
+    } else if (progress > 0.8) {
+      for (let i = 0; i < childNodes.length; i++) {
+        const node = childNodes[i];
+        node.fx = positions[i].x;
+        node.fy = positions[i].y;
+        node.fz = positions[i].z;
+      }
+    }
+  }
+
+  _animateCollapse(state, progress) {
+    const { childNodes, startPositions, target } = state;
+
+    if (progress >= 0.2 && progress <= 0.8) {
+      const moveProgress = (progress - 0.2) / 0.6;
+      const eased = this._easeInCubic(moveProgress);
+
+      for (let i = 0; i < childNodes.length; i++) {
+        const start = startPositions[i];
+        const node = childNodes[i];
+        node.fx = start.x + (target.x - start.x) * eased;
+        node.fy = start.y + (target.y - start.y) * eased;
+        node.fz = start.z + (target.z - start.z) * eased;
+      }
+    } else if (progress > 0.8) {
+      for (const node of childNodes) {
+        node.fx = target.x;
+        node.fy = target.y;
+        node.fz = target.z;
+      }
+    }
+  }
+
+  /**
+   * Compute orbital positions for children around cluster center.
+   * <= 20: single ring. > 20: two concentric rings.
+   */
+  _computeOrbitalPositions(count, center, radius) {
+    const positions = [];
+    if (count <= 20) {
+      for (let i = 0; i < count; i++) {
+        const angle = (2 * Math.PI * i) / count;
+        positions.push({
+          x: center.x + Math.cos(angle) * radius,
+          y: center.y + Math.sin(angle * 0.3) * radius * 0.2,
+          z: center.z + Math.sin(angle) * radius
+        });
+      }
+    } else {
+      const innerCount = Math.floor(count * 0.4);
+      const outerCount = count - innerCount;
+      const innerRadius = radius * 0.6;
+
+      for (let i = 0; i < innerCount; i++) {
+        const angle = (2 * Math.PI * i) / innerCount;
+        positions.push({
+          x: center.x + Math.cos(angle) * innerRadius,
+          y: center.y + Math.sin(angle * 0.3) * innerRadius * 0.2,
+          z: center.z + Math.sin(angle) * innerRadius
+        });
+      }
+      for (let i = 0; i < outerCount; i++) {
+        const angle = (2 * Math.PI * i) / outerCount;
+        positions.push({
+          x: center.x + Math.cos(angle) * radius,
+          y: center.y + Math.sin(angle * 0.3) * radius * 0.2,
+          z: center.z + Math.sin(angle) * radius
+        });
+      }
+    }
+    return positions;
+  }
+
+  _easeOutCubic(t) { return 1 - Math.pow(1 - t, 3); }
+  _easeInCubic(t) { return t * t * t; }
+}

package/src/viewer/lod-clustering.js

@@ -0,0 +1,227 @@
+/**
+ * LOD Clustering — Louvain Community Detection
+ * KSA-143: KB Graph Level of Detail / Semantic Zoom
+ * 
+ * Deterministic clustering algorithm for graph nodes.
+ * Produces communities of 5-50 nodes for LOD rendering.
+ */
+
+export class LODClustering {
+  constructor(options = {}) {
+    this._minSize = options.minClusterSize || 5;
+    this._maxSize = options.maxClusterSize || 50;
+    this._maxClusters = options.maxClusters || 100;
+  }
+
+  compute(nodes, edges) {
+    if (!nodes || nodes.length === 0) return [];
+    const edgeCount = new Map();
+    for (const e of edges) {
+      edgeCount.set(e.source, (edgeCount.get(e.source) || 0) + 1);
+      edgeCount.set(e.target, (edgeCount.get(e.target) || 0) + 1);
+    }
+    const connected = nodes.filter(n => (edgeCount.get(n.id) || 0) > 0);
+    const isolated = nodes.filter(n => (edgeCount.get(n.id) || 0) === 0);
+    let connectedClusters = [];
+    if (connected.length >= this._minSize) {
+      connected.sort((a, b) => String(a.id).localeCompare(String(b.id)));
+      const adj = this._buildAdjacency(connected, edges);
+      const communities = this._louvainPhase1(connected, adj);
+      const processed = this._enforceSizeConstraints(communities, connected);
+      connectedClusters = this._buildClusters(processed, nodes);
+    }
+    let isolatedClusters = [];
+    if (isolated.length > 0) {
+      const typeGroups = new Map();
+      for (const n of isolated) {
+        const key = n.type || 'UNKNOWN';
+        if (!typeGroups.has(key)) typeGroups.set(key, []);
+        typeGroups.get(key).push(n.id);
+      }
+      const isoCommunities = [];
+      for (const [type, ids] of typeGroups) {
+        for (let i = 0; i < ids.length; i += this._maxSize) {
+          const chunk = ids.slice(i, i + this._maxSize);
+          if (chunk.length >= 2) isoCommunities.push(chunk);
+        }
+      }
+      isolatedClusters = this._buildClusters(isoCommunities, nodes, connectedClusters.length);
+    }
+    const allClusters = [...connectedClusters, ...isolatedClusters];
+    return this._enforceMaxClusters(allClusters);
+  }
+
+  recompute(nodes, edges) { return this.compute(nodes, edges); }
+
+  getClusterForNode(nodeId, clusters) {
+    for (const c of clusters) { if (c.childNodeIds.includes(nodeId)) return c; }
+    return null;
+  }
+
+  _buildAdjacency(nodes, edges) {
+    const nodeSet = new Set(nodes.map(n => n.id));
+    const nodeTypeMap = new Map(nodes.map(n => [n.id, n.type || '']));
+    const adj = new Map();
+    for (const n of nodes) adj.set(n.id, []);
+    for (const e of edges) {
+      const s = typeof e.source === 'object' ? e.source.id : e.source;
+      const t = typeof e.target === 'object' ? e.target.id : e.target;
+      if (!nodeSet.has(s) || !nodeSet.has(t)) continue;
+      const typeMatch = nodeTypeMap.get(s) === nodeTypeMap.get(t) ? 1 : 0;
+      const weight = 2 + typeMatch;
+      adj.get(s).push({ target: t, weight });
+      adj.get(t).push({ target: s, weight });
+    }
+    return adj;
+  }
+
+  _louvainPhase1(nodes, adj) {
+    const community = new Map();
+    nodes.forEach((n, i) => community.set(n.id, i));
+    const totalWeight = this._totalWeight(adj);
+    let improved = true;
+    let iterations = 0;
+    const maxIter = 20;
+    while (improved && iterations < maxIter) {
+      improved = false;
+      iterations++;
+      for (const node of nodes) {
+        const nodeId = node.id;
+        const currentComm = community.get(nodeId);
+        const neighborComms = new Map();
+        for (const { target, weight } of adj.get(nodeId)) {
+          const nc = community.get(target);
+          neighborComms.set(nc, (neighborComms.get(nc) || 0) + weight);
+        }
+        let bestComm = currentComm;
+        let bestGain = 0;
+        for (const [comm, edgeWeight] of neighborComms) {
+          if (comm === currentComm) continue;
+          const gain = this._modularityGain(nodeId, comm, community, adj, totalWeight, edgeWeight);
+          if (gain > bestGain) { bestGain = gain; bestComm = comm; }
+        }
+        if (bestComm !== currentComm) { community.set(nodeId, bestComm); improved = true; }
+      }
+    }
+    const groups = new Map();
+    for (const [nodeId, comm] of community) {
+      if (!groups.has(comm)) groups.set(comm, []);
+      groups.get(comm).push(nodeId);
+    }
+    return Array.from(groups.values());
+  }
+
+  _modularityGain(nodeId, targetComm, community, adj, totalWeight, edgeWeightToComm) {
+    if (totalWeight === 0) return 0;
+    const ki = adj.get(nodeId).reduce((sum, e) => sum + e.weight, 0);
+    let sumIn = 0;
+    for (const [nid, comm] of community) {
+      if (comm !== targetComm) continue;
+      for (const { target, weight } of adj.get(nid)) {
+        if (community.get(target) === targetComm) sumIn += weight;
+      }
+    }
+    sumIn /= 2;
+    let sumTot = 0;
+    for (const [nid, comm] of community) {
+      if (comm !== targetComm) continue;
+      sumTot += adj.get(nid).reduce((s, e) => s + e.weight, 0);
+    }
+    const m2 = totalWeight * 2;
+    return (edgeWeightToComm / m2) - (sumTot * ki) / (m2 * m2);
+  }
+
+  _totalWeight(adj) {
+    let total = 0;
+    for (const edges of adj.values()) { for (const e of edges) total += e.weight; }
+    return total / 2;
+  }
+
+  _enforceSizeConstraints(communities, nodes) {
+    const result = [];
+    for (const group of communities) {
+      if (group.length < this._minSize) { result.push(group); }
+      else if (group.length > this._maxSize) {
+        for (let i = 0; i < group.length; i += this._maxSize) {
+          const chunk = group.slice(i, i + this._maxSize);
+          if (chunk.length >= this._minSize) result.push(chunk);
+          else if (result.length > 0) result[result.length - 1].push(...chunk);
+        }
+      } else { result.push(group); }
+    }
+    const valid = [];
+    const tooSmall = [];
+    for (const g of result) {
+      if (g.length >= this._minSize) valid.push(g);
+      else tooSmall.push(g);
+    }
+    for (const small of tooSmall) {
+      if (valid.length === 0) { valid.push(small); continue; }
+      valid.sort((a, b) => a.length - b.length);
+      valid[0].push(...small);
+    }
+    return valid;
+  }
+
+  _enforceMaxClusters(clusters) {
+    while (clusters.length > this._maxClusters) {
+      clusters.sort((a, b) => {
+        const aLen = a.childNodeIds ? a.childNodeIds.length : a.length;
+        const bLen = b.childNodeIds ? b.childNodeIds.length : b.length;
+        return aLen - bLen;
+      });
+      const smallest = clusters[0];
+      const second = clusters[1];
+      if (smallest.childNodeIds && second.childNodeIds) {
+        second.childNodeIds.push(...smallest.childNodeIds);
+        second.label = `${second.dominantType} (${second.childNodeIds.length})`;
+      }
+      clusters = clusters.slice(1);
+    }
+    return clusters;
+  }
+
+  _buildClusters(communities, allNodes, idOffset = 0) {
+    const nodeMap = new Map(allNodes.map(n => [n.id, n]));
+    return communities.map((childIds, idx) => {
+      const children = childIds.map(id => nodeMap.get(id)).filter(Boolean);
+      const center = this._centroid(children);
+      const radius = this._radius(children, center);
+      const dominantType = this._dominantType(children);
+      return {
+        id: `cluster-${String(idx + idOffset).padStart(3, '0')}`,
+        label: `${dominantType} (${childIds.length})`,
+        childNodeIds: childIds,
+        center,
+        radius: Math.max(radius, 10),
+        dominantType,
+        state: 'COLLAPSED'
+      };
+    });
+  }
+
+  _centroid(nodes) {
+    if (nodes.length === 0) return { x: 0, y: 0, z: 0 };
+    const sum = nodes.reduce((acc, n) => ({ x: acc.x + (n.x || 0), y: acc.y + (n.y || 0), z: acc.z + (n.z || 0) }), { x: 0, y: 0, z: 0 });
+    return { x: sum.x / nodes.length, y: sum.y / nodes.length, z: sum.z / nodes.length };
+  }
+
+  _radius(nodes, center) {
+    if (nodes.length === 0) return 0;
+    let maxDist = 0;
+    for (const n of nodes) {
+      const dx = (n.x || 0) - center.x, dy = (n.y || 0) - center.y, dz = (n.z || 0) - center.z;
+      const dist = Math.sqrt(dx * dx + dy * dy + dz * dz);
+      if (dist > maxDist) maxDist = dist;
+    }
+    return maxDist;
+  }
+
+  _dominantType(nodes) {
+    const counts = {};
+    for (const n of nodes) { const t = n.type || 'UNKNOWN'; counts[t] = (counts[t] || 0) + 1; }
+    let max = 0, dominant = 'UNKNOWN';
+    for (const [type, count] of Object.entries(counts)) { if (count > max) { max = count; dominant = type; } }
+    return dominant;
+  }
+}

package/src/viewer/lod-manager.js

@@ -0,0 +1,274 @@
+/**
+ * LOD Manager — Orchestrates Level of Detail for 3D KB Graph
+ * KSA-143: KB Graph Level of Detail / Semantic Zoom
+ * 
+ * Integrates clustering + animation with ForceGraph3D.
+ * Manages camera distance checks, budget enforcement, state machine.
+ */
+
+import { LODClustering } from './lod-clustering.js';
+import { LODAnimation } from './lod-animation.js';
+
+const COLORS = {
+  CONTEXT: '#38bdf8', DECISION: '#f472b6', ERROR_PATTERN: '#fb923c',
+  ARCHITECTURE: '#a78bfa', REQUIREMENT: '#34d399', PROCEDURE: '#facc15',
+  LESSON_LEARNED: '#f87171', CODE_ENTITY: '#e2e8f0', API_DESIGN: '#2dd4bf',
+};
+
+export class LODManager {
+  constructor(graph3dInstance, config = {}) {
+    this._graph = graph3dInstance;
+    this._config = {
+      expandThreshold: config.expandThreshold || 50,
+      collapseThreshold: config.collapseThreshold || (config.expandThreshold || 50) * 1.4,
+      animationDuration: config.animationDuration || 400,
+      maxVisibleNodes: config.maxVisibleNodes || 100,
+      minClusterSize: config.minClusterSize || 5,
+      maxClusterSize: config.maxClusterSize || 50,
+      lodEnabled: config.lodEnabled !== false
+    };
+
+    this._clustering = new LODClustering({
+      minClusterSize: this._config.minClusterSize,
+      maxClusterSize: this._config.maxClusterSize
+    });
+    this._animation = new LODAnimation(graph3dInstance);
+
+    this._clusters = new Map();
+    this._allNodes = [];
+    this._allEdges = [];
+    this._visibleNodes = new Set();
+    this._rafId = null;
+    this._initialized = false;
+  }
+
+  initialize(nodes, edges) {
+    this._allNodes = nodes;
+    this._allEdges = edges;
+    if (nodes.length <= this._config.maxVisibleNodes) { this._initialized = false; return; }
+    if (!this._config.lodEnabled) { this._initialized = false; return; }
+
+    const startTime = performance.now();
+    const clusters = this._clustering.compute(nodes, edges);
+    const elapsed = performance.now() - startTime;
+    console.log(`[LOD] Clustering: ${clusters.length} clusters from ${nodes.length} nodes in ${elapsed.toFixed(0)}ms`);
+    if (elapsed > 5000) console.warn('[LOD] Clustering took', elapsed, 'ms');
+
+    for (const cluster of clusters) this._clusters.set(cluster.id, cluster);
+    this._showSuperNodes();
+    this._initialized = true;
+    this._startTick();
+    console.log(`[LOD] Initialized: ${clusters.length} clusters from ${nodes.length} nodes (${elapsed.toFixed(0)}ms)`);
+  }
+
+  expandCluster(clusterId) {
+    const cluster = this._clusters.get(clusterId);
+    if (!cluster || cluster.state !== 'COLLAPSED') return false;
+    if (!this._budgetAllows(cluster)) {
+      if (!this._freeBudget(cluster.childNodeIds.length)) return false;
+    }
+    cluster.state = 'EXPANDING';
+    const childNodes = this._getChildNodes(cluster);
+    for (const node of childNodes) {
+      node.__lodCenterX = cluster.center.x;
+      node.__lodCenterY = cluster.center.y;
+      node.__lodCenterZ = cluster.center.z;
+    }
+    this._animation.expand(cluster, childNodes, {
+      duration: this._config.animationDuration,
+      onComplete: () => {
+        cluster.state = 'EXPANDED';
+        for (const id of cluster.childNodeIds) this._visibleNodes.add(id);
+        this._visibleNodes.delete(cluster.id);
+        this._updateGraphData();
+      }
+    });
+    return true;
+  }
+
+  collapseCluster(clusterId) {
+    const cluster = this._clusters.get(clusterId);
+    if (!cluster || cluster.state !== 'EXPANDED') return false;
+    if (cluster.interacting) return false;
+    cluster.state = 'COLLAPSING';
+    const childNodes = this._getChildNodes(cluster);
+    this._animation.collapse(cluster, childNodes, {
+      duration: this._config.animationDuration,
+      onComplete: () => {
+        cluster.state = 'COLLAPSED';
+        for (const id of cluster.childNodeIds) this._visibleNodes.delete(id);
+        this._visibleNodes.add(cluster.id);
+        this._updateGraphData();
+      }
+    });
+    return true;
+  }
+
+  getVisibleNodeCount() { return this._visibleNodes.size; }
+
+  setConfig(config) {
+    Object.assign(this._config, config);
+    if (config.expandThreshold && !config.collapseThreshold) {
+      this._config.collapseThreshold = this._config.expandThreshold * 1.4;
+    }
+    if (config.lodEnabled === false) this._disableLOD();
+    else if (config.lodEnabled === true && !this._initialized) this.initialize(this._allNodes, this._allEdges);
+  }
+
+  dispose() {
+    if (this._rafId) { cancelAnimationFrame(this._rafId); this._rafId = null; }
+    this._animation.dispose();
+    this._clusters.clear();
+    this._visibleNodes.clear();
+    this._initialized = false;
+  }
+
+  // --- Private methods ---
+
+  _startTick() {
+    let lastCheckTime = 0;
+    const CHECK_INTERVAL = 500; // Only check every 500ms to avoid interfering with zoom
+    const tick = () => {
+      if (!this._initialized) return;
+      const now = performance.now();
+      if (now - lastCheckTime >= CHECK_INTERVAL) {
+        lastCheckTime = now;
+        this._checkDistances();
+      }
+      this._rafId = requestAnimationFrame(tick);
+    };
+    this._rafId = requestAnimationFrame(tick);
+  }
+
+  _checkDistances() {
+    const cam = this._graph.camera().position;
+    for (const [id, cluster] of this._clusters) {
+      if (this._animation.isAnimating(id)) continue;
+
+      if (cluster.state === 'COLLAPSED') {
+        const dist = this._distance(cam, cluster.center);
+        if (dist < this._config.expandThreshold) {
+          if (this._budgetAllows(cluster)) this.expandCluster(id);
+        }
+      } else if (cluster.state === 'EXPANDED') {
+        const centroid = this._getExpandedCentroid(cluster);
+        const dist = this._distance(cam, centroid);
+        if (dist > this._config.collapseThreshold) {
+          if (!cluster.interacting) this.collapseCluster(id);
+        }
+      }
+    }
+  }
+
+  _budgetAllows(cluster) {
+    return (this._visibleNodes.size - 1 + cluster.childNodeIds.length) <= this._config.maxVisibleNodes;
+  }
+
+  _freeBudget(needed) {
+    const cam = this._graph.camera().position;
+    const expanded = Array.from(this._clusters.values())
+      .filter(c => c.state === 'EXPANDED' && !c.interacting)
+      .sort((a, b) => {
+        const distA = this._distance(cam, this._getExpandedCentroid(a));
+        const distB = this._distance(cam, this._getExpandedCentroid(b));
+        return distB - distA;
+      });
+    for (const cluster of expanded) {
+      this.collapseCluster(cluster.id);
+      if (this._visibleNodes.size - 1 + needed <= this._config.maxVisibleNodes) return true;
+    }
+    return false;
+  }
+
+  _showSuperNodes() {
+    const superNodes = [];
+    for (const [id, cluster] of this._clusters) {
+      superNodes.push({
+        id: cluster.id, name: cluster.label, type: cluster.dominantType,
+        x: cluster.center.x, y: cluster.center.y, z: cluster.center.z,
+        __isSuper: true, __childCount: cluster.childNodeIds.length, __cluster: cluster
+      });
+      this._visibleNodes.add(cluster.id);
+    }
+    const visibleEdges = this._getVisibleEdges(superNodes);
+    this._graph.graphData({ nodes: superNodes, links: visibleEdges });
+    this._graph.nodeVal(n => n.__isSuper ? 2 + Math.log(n.__childCount) * 2 : 4);
+    this._graph.nodeColor(n => COLORS[n.type] || '#38bdf8');
+    this._graph.nodeLabel(n => n.__isSuper ? `${n.name} (${n.__childCount} nodes)` : `[${n.type}] ${n.name}`);
+    // Auto fit view after LOD initializes
+    setTimeout(() => { try { this._graph.zoomToFit(400, 50); } catch(e){} }, 1000);
+  }
+
+  _getChildNodes(cluster) {
+    const nodeMap = new Map(this._allNodes.map(n => [n.id, n]));
+    return cluster.childNodeIds.map(id => nodeMap.get(id)).filter(Boolean);
+  }
+
+  _getVisibleEdges(visibleNodes) {
+    const visibleIds = new Set(visibleNodes.map(n => n.id));
+    return this._allEdges.filter(e => {
+      const s = typeof e.source === 'object' ? e.source.id : e.source;
+      const t = typeof e.target === 'object' ? e.target.id : e.target;
+      return visibleIds.has(s) && visibleIds.has(t);
+    });
+  }
+
+  _updateGraphData() {
+    const nodes = [];
+    const nodeMap = new Map(this._allNodes.map(n => [n.id, n]));
+    for (const [id, cluster] of this._clusters) {
+      if (cluster.state === 'COLLAPSED' || cluster.state === 'COLLAPSING') {
+        nodes.push({
+          id: cluster.id, name: cluster.label, type: cluster.dominantType,
+          x: cluster.center.x, y: cluster.center.y, z: cluster.center.z,
+          __isSuper: true, __childCount: cluster.childNodeIds.length, __cluster: cluster
+        });
+      } else {
+        for (const nid of cluster.childNodeIds) {
+          const node = nodeMap.get(nid);
+          if (node) nodes.push(node);
+        }
+      }
+    }
+    const links = this._getVisibleEdges(nodes);
+    // Preserve camera position across graph data updates
+    let camPos = null;
+    let camLookAt = null;
+    try {
+      const cam = this._graph.camera();
+      camPos = { x: cam.position.x, y: cam.position.y, z: cam.position.z };
+      const controls = this._graph.controls();
+      if (controls && controls.target) {
+        camLookAt = { x: controls.target.x, y: controls.target.y, z: controls.target.z };
+      }
+    } catch(e) {}
+    this._graph.graphData({ nodes, links });
+    // Restore camera position after graphData update
+    if (camPos) {
+      this._graph.cameraPosition(camPos, camLookAt, 0);
+    }
+  }
+
+  _disableLOD() {
+    this.dispose();
+    this._graph.graphData({ nodes: this._allNodes, links: this._allEdges });
+  }
+
+  _getExpandedCentroid(cluster) {
+    const childNodes = this._getChildNodes(cluster);
+    if (childNodes.length === 0) return cluster.center;
+    let sumX = 0, sumY = 0, sumZ = 0;
+    const len = childNodes.length;
+    for (let i = 0; i < len; i++) {
+      sumX += childNodes[i].x || 0;
+      sumY += childNodes[i].y || 0;
+      sumZ += childNodes[i].z || 0;
+    }
+    return { x: sumX / len, y: sumY / len, z: sumZ / len };
+  }
+
+  _distance(a, b) {
+    const dx = a.x - b.x, dy = a.y - b.y, dz = a.z - b.z;
+    return Math.sqrt(dx * dx + dy * dy + dz * dz);
+  }
+}