@opendata-ai/openchart-vanilla 8.4.1 → 8.5.1

package/dist/graph-3d/index.js

@@ -0,0 +1,1556 @@
+import {
+  ENTRANCE_STAGGER_MAX_NODES,
+  GraphSearchManager,
+  categoryHighlightSet,
+  composeStandingFocus,
+  createGraph,
+  createGraphLegend,
+  diffGraphUpdate,
+  entranceOrder,
+  layerHoverFocus,
+  popAlpha,
+  popScale,
+  registerGraphRenderer,
+  resolveHighlightTarget,
+  seedNodePositions
+} from "../chunk-WOLX5EZT.js";
+import {
+  AnimationScheduler,
+  createTween,
+  linear,
+  prefersReducedMotion,
+  resolveEase
+} from "../chunk-2OJZBMXM.js";
+import {
+  resolvedSurface
+} from "../chunk-NG7CVCI2.js";
+
+// src/graph-3d/mount.ts
+import { buildEdgeTooltip } from "@opendata-ai/openchart-engine";
+import ForceGraph3D from "3d-force-graph";
+import { Raycaster, Vector2 } from "three";
+
+// src/graph-3d/emphasis.ts
+var EDGE_ALPHA_DEFAULT = 0.3;
+var EDGE_ALPHA_CONNECTED = 1;
+var SEARCH_NON_MATCH_ALPHA = 0.25;
+function resolveEmphasis(input) {
+  const { focus, exemptIds, dimOpacity, edgeBaseAlpha } = input;
+  const search = focus.searchMatches;
+  const nodes = /* @__PURE__ */ new Map();
+  for (const n of input.nodes) {
+    let alpha = 1;
+    if (focus.hasActive && !exemptIds.has(n.id) && !focus.connected.has(n.id)) {
+      alpha = dimOpacity;
+    }
+    if (search !== null && !search.has(n.id)) alpha *= SEARCH_NON_MATCH_ALPHA;
+    nodes.set(n.id, alpha * n.opacity);
+  }
+  const edges = /* @__PURE__ */ new Map();
+  for (let i = 0; i < input.edges.length; i++) {
+    const e = input.edges[i];
+    const resting = edgeBaseAlpha?.get(i) ?? EDGE_ALPHA_DEFAULT;
+    let alpha;
+    if (!focus.hasActive) {
+      alpha = resting;
+    } else if (focus.connected.has(e.source) && focus.connected.has(e.target)) {
+      alpha = EDGE_ALPHA_CONNECTED;
+    } else {
+      alpha = dimOpacity / 3;
+    }
+    if (search !== null && !search.has(e.source) && !search.has(e.target)) {
+      alpha *= SEARCH_NON_MATCH_ALPHA;
+    }
+    edges.set(i, alpha);
+  }
+  return { nodes, edges };
+}
+
+// src/graph-3d/entrance.ts
+var ENTRANCE_STAGGER_FRACTION = 0.5;
+var LINK_ENTRANCE_DELAY = 0.25;
+var ENTRANCE_CAMERA_PULLBACK = 1.6;
+function planEntrance(nodes, edges, duration, stagger) {
+  const nodeOffset = /* @__PURE__ */ new Map();
+  const linkOffset = /* @__PURE__ */ new Map();
+  if (!stagger || nodes.length === 0) {
+    for (const n of nodes) nodeOffset.set(n.id, 0);
+    for (let i = 0; i < edges.length; i++) linkOffset.set(i, duration * LINK_ENTRANCE_DELAY);
+    return { nodeOffset, linkOffset, span: duration * (1 + LINK_ENTRANCE_DELAY) };
+  }
+  const rank = entranceOrder(nodes);
+  const last = Math.max(1, nodes.length - 1);
+  const spread = duration * ENTRANCE_STAGGER_FRACTION;
+  let maxOffset = 0;
+  for (const n of nodes) {
+    const offset = (rank.get(n.id) ?? 0) / last * spread;
+    nodeOffset.set(n.id, offset);
+    if (offset > maxOffset) maxOffset = offset;
+  }
+  const delay = duration * LINK_ENTRANCE_DELAY;
+  for (let i = 0; i < edges.length; i++) {
+    const a = nodeOffset.get(edges[i].source) ?? 0;
+    const b = nodeOffset.get(edges[i].target) ?? 0;
+    const offset = Math.max(a, b) + delay;
+    linkOffset.set(i, offset);
+    if (offset > maxOffset) maxOffset = offset;
+  }
+  return { nodeOffset, linkOffset, span: duration + maxOffset };
+}
+function elementProgress(elapsed, offset, duration, ease) {
+  if (duration <= 0) return elapsed >= offset ? 1 : 0;
+  const local = (elapsed - offset) / duration;
+  if (local <= 0) return 0;
+  if (local >= 1) return 1;
+  return ease(local);
+}
+
+// src/graph-3d/fit.ts
+var MIN_FIT_DISTANCE = 60;
+function normalize(v) {
+  const len = Math.hypot(v.x, v.y, v.z);
+  if (!(len > 1e-6)) return { x: 0, y: 0, z: 1 };
+  return { x: v.x / len, y: v.y / len, z: v.z / len };
+}
+function cross(a, b) {
+  return {
+    x: a.y * b.z - a.z * b.y,
+    y: a.z * b.x - a.x * b.z,
+    z: a.x * b.y - a.y * b.x
+  };
+}
+function computeFit(points, view) {
+  let minX = Number.POSITIVE_INFINITY;
+  let minY = Number.POSITIVE_INFINITY;
+  let minZ = Number.POSITIVE_INFINITY;
+  let maxX = Number.NEGATIVE_INFINITY;
+  let maxY = Number.NEGATIVE_INFINITY;
+  let maxZ = Number.NEGATIVE_INFINITY;
+  for (const p of points) {
+    if (p.x < minX) minX = p.x;
+    if (p.y < minY) minY = p.y;
+    if (p.z < minZ) minZ = p.z;
+    if (p.x > maxX) maxX = p.x;
+    if (p.y > maxY) maxY = p.y;
+    if (p.z > maxZ) maxZ = p.z;
+  }
+  if (!Number.isFinite(minX) || !Number.isFinite(minY) || !Number.isFinite(minZ) || !Number.isFinite(maxX) || !Number.isFinite(maxY) || !Number.isFinite(maxZ)) {
+    return null;
+  }
+  const center = { x: (minX + maxX) / 2, y: (minY + maxY) / 2, z: (minZ + maxZ) / 2 };
+  const dir = normalize({
+    x: view.cameraPos.x - center.x,
+    y: view.cameraPos.y - center.y,
+    z: view.cameraPos.z - center.z
+  });
+  const worldUp = Math.abs(dir.y) > 0.999 ? { x: 0, y: 0, z: 1 } : { x: 0, y: 1, z: 0 };
+  const right = normalize(cross(worldUp, dir));
+  const up = cross(dir, right);
+  let halfRight = 0;
+  let halfUp = 0;
+  let nearDepth = 0;
+  for (const p of points) {
+    const dx = p.x - center.x;
+    const dy = p.y - center.y;
+    const dz = p.z - center.z;
+    halfRight = Math.max(
+      halfRight,
+      Math.abs(dx * right.x + dy * right.y + dz * right.z) + p.radius
+    );
+    halfUp = Math.max(halfUp, Math.abs(dx * up.x + dy * up.y + dz * up.z) + p.radius);
+    nearDepth = Math.max(nearDepth, dx * dir.x + dy * dir.y + dz * dir.z + p.radius);
+  }
+  const vFov = view.fovDeg * Math.PI / 180;
+  const hFov = 2 * Math.atan(Math.tan(vFov / 2) * view.aspect);
+  const slack = 1 + Math.min(0.5, 2 * view.paddingPx / (view.viewportHeight || 1));
+  const distance = Math.max(
+    halfUp * slack / Math.tan(vFov / 2),
+    halfRight * slack / Math.tan(hFov / 2),
+    MIN_FIT_DISTANCE
+  ) + Math.max(0, nearDepth);
+  return { center, dir, distance };
+}
+
+// src/graph-3d/forces.ts
+import { forceCenter, forceCollide } from "d3-force-3d";
+var DEFAULT_ALPHA_MIN = 1e-3;
+var MAX_COOLDOWN_TICKS = 800;
+var COLLIDE_ITERATIONS = 1;
+var WARMUP_MS_PER_NODE_TICK = 35e-4;
+var MIN_WARMUP_TICKS = 5;
+var DEFAULT_WARMUP_BUDGET_MS = 250;
+function budgetedWarmupTicks(requested, nodeCount, budgetMs = DEFAULT_WARMUP_BUDGET_MS) {
+  if (requested <= 0 || nodeCount <= 0) return Math.max(0, requested);
+  const perTickMs = Math.max(WARMUP_MS_PER_NODE_TICK * nodeCount, 0.05);
+  const affordable = Math.floor(budgetMs / perTickMs);
+  return Math.max(MIN_WARMUP_TICKS, Math.min(requested, affordable));
+}
+function ticksToSettle(alphaDecay, alphaMin = DEFAULT_ALPHA_MIN) {
+  if (!(alphaDecay > 0) || alphaDecay >= 1) return MAX_COOLDOWN_TICKS;
+  const n = Math.ceil(Math.log(alphaMin) / Math.log(1 - alphaDecay));
+  return Math.min(MAX_COOLDOWN_TICKS, Math.max(1, n));
+}
+function forceCluster3D(strength) {
+  let nodes = [];
+  const force = (alpha) => {
+    const cx = /* @__PURE__ */ new Map();
+    const cy = /* @__PURE__ */ new Map();
+    const cz = /* @__PURE__ */ new Map();
+    const count = /* @__PURE__ */ new Map();
+    for (const node of nodes) {
+      const c = node.node?.community;
+      if (!c) continue;
+      cx.set(c, (cx.get(c) ?? 0) + (node.x ?? 0));
+      cy.set(c, (cy.get(c) ?? 0) + (node.y ?? 0));
+      cz.set(c, (cz.get(c) ?? 0) + (node.z ?? 0));
+      count.set(c, (count.get(c) ?? 0) + 1);
+    }
+    for (const [c, n] of count) {
+      cx.set(c, cx.get(c) / n);
+      cy.set(c, cy.get(c) / n);
+      cz.set(c, cz.get(c) / n);
+    }
+    const k = strength * alpha;
+    for (const node of nodes) {
+      const c = node.node?.community;
+      if (!c) continue;
+      node.vx = (node.vx ?? 0) + (cx.get(c) - (node.x ?? 0)) * k;
+      node.vy = (node.vy ?? 0) + (cy.get(c) - (node.y ?? 0)) * k;
+      node.vz = (node.vz ?? 0) + (cz.get(c) - (node.z ?? 0)) * k;
+    }
+  };
+  force.initialize = (ns) => {
+    nodes = ns;
+  };
+  return force;
+}
+function applySimulationConfig(graph, config, nodeCount) {
+  const charge = graph.d3Force("charge");
+  if (charge && typeof charge.strength === "function") {
+    charge.strength(config.chargeStrength);
+  }
+  const link = graph.d3Force("link");
+  if (link) {
+    const l = link;
+    l.distance?.(config.linkDistance);
+    if (config.linkStrength !== void 0) l.strength?.(config.linkStrength);
+  }
+  const padding = config.collisionPadding ?? 2;
+  graph.d3Force(
+    "collide",
+    forceCollide((n) => (n.node?.radius ?? 1) + padding).iterations(COLLIDE_ITERATIONS)
+  );
+  graph.d3Force("cluster", config.clustering ? forceCluster3D(config.clustering.strength) : null);
+  graph.d3Force(
+    "center",
+    config.centerForce === false ? null : graph.d3Force("center") ?? forceCenter()
+  );
+  graph.d3VelocityDecay(config.velocityDecay);
+  graph.d3AlphaDecay(config.alphaDecay);
+  graph.warmupTicks(budgetedWarmupTicks(config.warmupTicks ?? 0, nodeCount, config.warmupBudgetMs));
+  graph.cooldownTicks(ticksToSettle(config.alphaDecay));
+}
+
+// src/graph-3d/labels.ts
+var LABEL_BUDGET_3D = 40;
+function resolveVisibleLabels(nodes, forced, cameraPos, budget) {
+  const visible = [];
+  for (const n of nodes) if (forced.has(n.id)) visible.push(n.id);
+  if (budget <= 0) return visible;
+  const ranked = [];
+  for (const n of nodes) {
+    if (forced.has(n.id)) continue;
+    const dx = n.x - cameraPos.x;
+    const dy = n.y - cameraPos.y;
+    const dz = n.z - cameraPos.z;
+    ranked.push({ id: n.id, priority: n.priority, dist: dx * dx + dy * dy + dz * dz });
+  }
+  ranked.sort((a, b) => b.priority - a.priority || a.dist - b.dist || (a.id < b.id ? -1 : 1));
+  for (let i = 0; i < ranked.length && i < budget; i++) visible.push(ranked[i].id);
+  return visible;
+}
+var LABEL_BOX_PAD = 2;
+function labelBox(projected, text, heightPx) {
+  if (!projected || !Number.isFinite(projected.x) || !Number.isFinite(projected.y)) return null;
+  const width = Math.max(1, text.length) * heightPx * 0.55;
+  const cy = projected.y - heightPx;
+  return {
+    x0: projected.x - width / 2 - LABEL_BOX_PAD,
+    x1: projected.x + width / 2 + LABEL_BOX_PAD,
+    y0: cy - heightPx / 2 - LABEL_BOX_PAD,
+    y1: cy + heightPx / 2 + LABEL_BOX_PAD
+  };
+}
+function overlaps(a, b) {
+  return a.x0 < b.x1 && a.x1 > b.x0 && a.y0 < b.y1 && a.y1 > b.y0;
+}
+
+// src/graph-3d/links.ts
+import {
+  BufferAttribute,
+  BufferGeometry,
+  CylinderGeometry,
+  Line,
+  LineBasicMaterial,
+  LineDashedMaterial,
+  Matrix4,
+  Mesh,
+  MeshLambertMaterial
+} from "three";
+var LINK_WIDTH_MAX_EDGES = 2e3;
+var CYLINDER_SEGMENTS = 6;
+var DASH = { dashed: { dash: 6, gap: 4 }, dotted: { dash: 1.5, gap: 3 } };
+function isDashed(edge) {
+  return edge.style === "dashed" || edge.style === "dotted";
+}
+function cylinderRadius(edge) {
+  return Math.max(edge.strokeWidth, 0.1) / 2;
+}
+function buildCylinder(edge) {
+  const r = cylinderRadius(edge);
+  const geometry = new CylinderGeometry(r, r, 1, CYLINDER_SEGMENTS, 1, false);
+  geometry.applyMatrix4(new Matrix4().makeTranslation(0, 0.5, 0));
+  geometry.applyMatrix4(new Matrix4().makeRotationX(Math.PI / 2));
+  return geometry;
+}
+function buildLineMaterial(edge, opacity) {
+  if (!isDashed(edge)) {
+    return new LineBasicMaterial({
+      color: edge.stroke,
+      transparent: true,
+      opacity,
+      depthWrite: false
+    });
+  }
+  const dash = DASH[edge.style];
+  return new LineDashedMaterial({
+    color: edge.stroke,
+    transparent: true,
+    opacity,
+    depthWrite: false,
+    dashSize: dash.dash,
+    gapSize: dash.gap
+  });
+}
+function createLinkObject(edge, useWidth, restingAlpha) {
+  if (useWidth) {
+    const geometry2 = buildCylinder(edge);
+    const material2 = new MeshLambertMaterial({
+      color: edge.stroke,
+      transparent: true,
+      opacity: restingAlpha,
+      depthWrite: false
+    });
+    return { object: new Mesh(geometry2, material2), geometry: geometry2, material: material2, dashed: false };
+  }
+  const geometry = new BufferGeometry();
+  geometry.setAttribute("position", new BufferAttribute(new Float32Array(2 * 3), 3));
+  const material = buildLineMaterial(edge, restingAlpha);
+  return { object: new Line(geometry, material), geometry, material, dashed: isDashed(edge) };
+}
+function applyLinkVisuals(obj, edge, useWidth) {
+  obj.material.color.set(edge.stroke);
+  if (useWidth) {
+    const r = cylinderRadius(edge);
+    if (obj.geometry.parameters.radiusTop === r) return;
+    const next2 = buildCylinder(edge);
+    obj.object.geometry = next2;
+    obj.geometry.dispose();
+    obj.geometry = next2;
+    return;
+  }
+  const dashed = isDashed(edge);
+  const current = obj.material;
+  const dash = dashed ? DASH[edge.style] : null;
+  const sameDash = dashed === obj.dashed && (dash === null || current.dashSize === dash.dash && current.gapSize === dash.gap);
+  if (sameDash) return;
+  const next = buildLineMaterial(edge, obj.material.opacity);
+  obj.object.material = next;
+  obj.material.dispose();
+  obj.material = next;
+  obj.dashed = dashed;
+  if (dashed) obj.object.computeLineDistances();
+}
+function linkShapeMatches(obj, useWidth) {
+  return useWidth ? obj.object instanceof Mesh : obj.object instanceof Line;
+}
+function updateLinkPosition(obj, start, end) {
+  if (!(obj.object instanceof Line)) return false;
+  const attr = obj.geometry.getAttribute("position");
+  const a = attr.array;
+  a[0] = start.x;
+  a[1] = start.y || 0;
+  a[2] = start.z || 0;
+  a[3] = end.x;
+  a[4] = end.y || 0;
+  a[5] = end.z || 0;
+  attr.needsUpdate = true;
+  obj.geometry.computeBoundingSphere();
+  if (obj.dashed) obj.object.computeLineDistances();
+  return true;
+}
+function disposeLinkObject(obj) {
+  obj.geometry.dispose();
+  obj.material.dispose();
+}
+function widthAsAlpha(edges, min = 0.15) {
+  const out = /* @__PURE__ */ new Map();
+  if (edges.length === 0) return out;
+  let lo = Number.POSITIVE_INFINITY;
+  let hi = Number.NEGATIVE_INFINITY;
+  for (const e of edges) {
+    if (e.strokeWidth < lo) lo = e.strokeWidth;
+    if (e.strokeWidth > hi) hi = e.strokeWidth;
+  }
+  const span = hi - lo;
+  for (let i = 0; i < edges.length; i++) {
+    const t = span > 0 ? (edges[i].strokeWidth - lo) / span : 1;
+    const step = Math.round(t * 3) / 3;
+    out.set(i, min + (1 - min) * step);
+  }
+  return out;
+}
+
+// src/graph-3d/nodes.ts
+import { Group, Mesh as Mesh2, MeshLambertMaterial as MeshLambertMaterial2, SphereGeometry } from "three";
+import SpriteText from "three-spritetext";
+var SPHERE_SEGMENTS = 12;
+var LABEL_TEXT_HEIGHT = 4;
+var LABEL_GAP = 2;
+function createNodeObject(node, labelColor) {
+  const geometry = new SphereGeometry(node.radius, SPHERE_SEGMENTS, SPHERE_SEGMENTS);
+  const material = new MeshLambertMaterial2({
+    color: node.fill,
+    transparent: true,
+    opacity: node.opacity
+  });
+  const mesh = new Mesh2(geometry, material);
+  const group = new Group();
+  group.add(mesh);
+  return {
+    group,
+    mesh,
+    geometry,
+    material,
+    sprite: null,
+    labelBaseScale: null,
+    labelText: node.label ?? null,
+    labelColor,
+    labelOffset: node.radius + LABEL_GAP
+  };
+}
+function ensureLabelSprite(obj) {
+  if (obj.sprite) return obj.sprite;
+  if (!obj.labelText) return null;
+  const sprite = new SpriteText(obj.labelText, LABEL_TEXT_HEIGHT, obj.labelColor);
+  sprite.position.y = obj.labelOffset;
+  sprite.raycast = () => {
+  };
+  sprite.visible = false;
+  obj.group.add(sprite);
+  obj.sprite = sprite;
+  obj.labelBaseScale = { x: sprite.scale.x, y: sprite.scale.y };
+  return sprite;
+}
+function applyNodeVisuals(obj, node, labelColor) {
+  obj.material.color.set(node.fill);
+  if (obj.geometry.parameters.radius !== node.radius) {
+    const next = new SphereGeometry(node.radius, SPHERE_SEGMENTS, SPHERE_SEGMENTS);
+    obj.mesh.geometry = next;
+    obj.geometry.dispose();
+    obj.geometry = next;
+  }
+  obj.labelText = node.label ?? null;
+  obj.labelColor = labelColor;
+  obj.labelOffset = node.radius + LABEL_GAP;
+  if (obj.sprite) {
+    const regenerates = node.label && obj.sprite.text !== node.label || obj.sprite.color !== labelColor;
+    if (node.label && obj.sprite.text !== node.label) obj.sprite.text = node.label;
+    obj.sprite.color = labelColor;
+    obj.sprite.position.y = obj.labelOffset;
+    if (regenerates) obj.labelBaseScale = { x: obj.sprite.scale.x, y: obj.sprite.scale.y };
+  }
+}
+function disposeNodeObject(obj) {
+  obj.geometry.dispose();
+  obj.material.dispose();
+  if (obj.sprite) {
+    const mat = obj.sprite.material;
+    mat.map?.dispose();
+    mat.dispose();
+  }
+}
+
+// src/graph-3d/mount.ts
+var FIT_DISTANCE = 1e3;
+var FIT_PADDING_PX = 40;
+var LABEL_SCREEN_PX = 11;
+var LABEL_SCALE_MIN = 0.4;
+var LABEL_SCALE_MAX = 8;
+var MAX_PIXEL_RATIO = 2;
+var DEFAULT_FOV_DEG = 50;
+var AUTO_FIT_INTERVAL_MS = 250;
+var NODE_FOCUS_DISTANCE = 120;
+var AUTO_FLIGHT_MS = 800;
+var ENTRANCE_MIN_SCALE = 0.01;
+var LABEL_ENTRANCE_MIN = 0.4;
+var LABEL_RERANK_MS = 100;
+var K_MIN = 0.05;
+var K_MAX = 40;
+var Z_SEED_SALT = 2654435769;
+function createGraph3DRenderer(ctx) {
+  const { shell, options } = ctx;
+  let currentSpec = ctx.spec;
+  let compilation = ctx.compilation;
+  let destroyed = false;
+  const surfaceEl = document.createElement("div");
+  surfaceEl.className = "oc-graph-3d";
+  surfaceEl.setAttribute("role", "img");
+  if (compilation.a11y?.altText) surfaceEl.setAttribute("aria-label", compilation.a11y.altText);
+  surfaceEl.style.position = "absolute";
+  surfaceEl.style.inset = "0";
+  shell.mountSurface(surfaceEl);
+  const graph = new ForceGraph3D(surfaceEl, {
+    controlType: "trackball",
+    // `alpha` is what lets a transparent theme show the host page through the
+    // canvas; both are constructor-only in 3d-force-graph.
+    rendererConfig: { alpha: true, antialias: true }
+  });
+  const nodeObjects = /* @__PURE__ */ new Map();
+  const linkObjects = /* @__PURE__ */ new Map();
+  let nodeData = [];
+  let nodeById = /* @__PURE__ */ new Map();
+  let linkData = [];
+  let adjacency = /* @__PURE__ */ new Map();
+  let nodeDataMap = /* @__PURE__ */ new Map();
+  let nodeCategory = /* @__PURE__ */ new Map();
+  let seedIds = /* @__PURE__ */ new Set();
+  let edgeBaseAlpha;
+  let useLinkWidth = false;
+  const searchManager = new GraphSearchManager();
+  let legendController = null;
+  let hoveredNodeId = null;
+  let hoveredLinkIndex = null;
+  let selectedNodeIds = /* @__PURE__ */ new Set();
+  let activeCategories = /* @__PURE__ */ new Set();
+  let transientHighlight = null;
+  let transientTarget = null;
+  let highlightSet = null;
+  let highlightDimOpacity = null;
+  const displayNodeAlpha = /* @__PURE__ */ new Map();
+  const displayEdgeAlpha = /* @__PURE__ */ new Map();
+  let entranceActive = false;
+  const entranceNodeAlpha = /* @__PURE__ */ new Map();
+  const entranceNodeScale = /* @__PURE__ */ new Map();
+  const entranceEdgeAlpha = /* @__PURE__ */ new Map();
+  let entranceCameraPull = 1;
+  let emphasisTween = null;
+  let pumpId = null;
+  const scheduler = new AnimationScheduler(() => pump());
+  function pump() {
+    if (pumpId !== null || destroyed) return;
+    pumpId = requestAnimationFrame((now) => {
+      pumpId = null;
+      if (destroyed) return;
+      scheduler.tick(now);
+      if (scheduler.active) pump();
+    });
+  }
+  let autoFit = true;
+  let lastAutoFit = 0;
+  let cameraChangeQueued = false;
+  const labelShown = /* @__PURE__ */ new Set();
+  let lastLabelRank = 0;
+  let labelRankQueued = false;
+  let controlsListener = null;
+  let openTooltip = null;
+  let renderedTooltip = null;
+  function rebuildDerived() {
+    adjacency = /* @__PURE__ */ new Map();
+    for (const e of compilation.edges) {
+      if (!adjacency.has(e.source)) adjacency.set(e.source, /* @__PURE__ */ new Set());
+      if (!adjacency.has(e.target)) adjacency.set(e.target, /* @__PURE__ */ new Set());
+      adjacency.get(e.source).add(e.target);
+      adjacency.get(e.target).add(e.source);
+    }
+    nodeDataMap = new Map(compilation.nodes.map((n) => [n.id, n.data ?? {}]));
+    nodeCategory = /* @__PURE__ */ new Map();
+    const field = compilation.legendField;
+    if (field) {
+      for (const n of compilation.nodes) {
+        const v = n.data?.[field];
+        if (v != null) nodeCategory.set(n.id, String(v));
+      }
+    }
+    seedIds = new Set(compilation.seedNodeIds);
+    const widthEncoded = currentSpec.encoding?.edgeWidth != null;
+    useLinkWidth = widthEncoded && compilation.edges.length <= LINK_WIDTH_MAX_EDGES;
+    edgeBaseAlpha = widthEncoded && !useLinkWidth ? widthAsAlpha(compilation.edges) : void 0;
+  }
+  function labelColor() {
+    return compilation.theme.colors.text;
+  }
+  function seedPositions(nodes) {
+    const xy = nodes.map((n) => ({
+      id: n.id,
+      radius: n.radius,
+      community: n.community
+    }));
+    const seed = compilation.simulationConfig.seed ?? 0;
+    seedNodePositions(xy, seed);
+    const z = nodes.map((n) => ({
+      id: n.id,
+      radius: n.radius,
+      community: n.community
+    }));
+    seedNodePositions(z, seed ^ Z_SEED_SALT);
+    const out = /* @__PURE__ */ new Map();
+    for (let i = 0; i < nodes.length; i++) {
+      out.set(nodes[i].id, [xy[i].x ?? 0, xy[i].y ?? 0, z[i].x ?? 0]);
+    }
+    return out;
+  }
+  function seedZ(id, radius, community) {
+    const one = [{ id, radius, community }];
+    seedNodePositions(one, (compilation.simulationConfig.seed ?? 0) ^ Z_SEED_SALT);
+    return one[0].x ?? 0;
+  }
+  function buildGraphData(positions) {
+    nodeData = compilation.nodes.map((node) => {
+      const p = positions.get(node.id) ?? [0, 0, 0];
+      return { id: node.id, node, x: p[0], y: p[1], z: p[2] };
+    });
+    linkData = compilation.edges.map((edge, edgeIndex) => ({
+      source: edge.source,
+      target: edge.target,
+      edge,
+      edgeIndex
+    }));
+    nodeById = new Map(nodeData.map((d) => [d.id, d]));
+    graph.graphData({ nodes: nodeData, links: linkData });
+  }
+  function nodeObjectFor(datum) {
+    let obj = nodeObjects.get(datum.id);
+    if (!obj) {
+      obj = createNodeObject(datum.node, labelColor());
+      obj.group.userData.nodeId = datum.id;
+      nodeObjects.set(datum.id, obj);
+      const base = displayNodeAlpha.get(datum.id) ?? datum.node.opacity;
+      if (entranceActive) {
+        obj.material.opacity = base * (entranceNodeAlpha.get(datum.id) ?? 0);
+        obj.mesh.scale.setScalar(entranceNodeScale.get(datum.id) ?? ENTRANCE_MIN_SCALE);
+      } else {
+        obj.material.opacity = base;
+      }
+    }
+    return obj;
+  }
+  const linkThreeObject = (datum) => linkObjectFor(datum).object;
+  function linkObjectFor(datum) {
+    let obj = linkObjects.get(datum.edgeIndex);
+    if (!obj) {
+      const resting = edgeBaseAlpha?.get(datum.edgeIndex) ?? 0.3;
+      obj = createLinkObject(datum.edge, useLinkWidth, resting);
+      linkObjects.set(datum.edgeIndex, obj);
+      const base = displayEdgeAlpha.get(datum.edgeIndex) ?? resting;
+      obj.material.opacity = entranceActive ? base * (entranceEdgeAlpha.get(datum.edgeIndex) ?? 0) : base;
+    }
+    return obj;
+  }
+  function hoverConnectedSet(nodeId) {
+    if (nodeId === null) return null;
+    if (compilation.interaction.hoverMode === "none") return null;
+    if (compilation.interaction.hoverMode === "category") {
+      const cat = nodeCategory.get(nodeId);
+      const set2 = /* @__PURE__ */ new Set([nodeId]);
+      if (cat !== void 0) {
+        for (const [id, c] of nodeCategory) if (c === cat) set2.add(id);
+      }
+      return set2;
+    }
+    if (compilation.interaction.hoverMode === "node") return /* @__PURE__ */ new Set([nodeId]);
+    const set = /* @__PURE__ */ new Set([nodeId]);
+    const neighbors = adjacency.get(nodeId);
+    if (neighbors) for (const nid of neighbors) set.add(nid);
+    return set;
+  }
+  function currentFocus() {
+    const standing = composeStandingFocus(
+      highlightSet,
+      searchManager.getMatches(),
+      selectedNodeIds,
+      adjacency
+    );
+    return layerHoverFocus(standing, hoveredNodeId, hoverConnectedSet(hoveredNodeId));
+  }
+  function effectiveDimOpacity() {
+    const custom = transientHighlight !== null ? highlightDimOpacity : null;
+    return custom ?? compilation.interaction.dimOpacity;
+  }
+  function paint() {
+    for (const [id, obj] of nodeObjects) {
+      const a = displayNodeAlpha.get(id);
+      if (a === void 0) continue;
+      if (entranceActive) {
+        const factor = entranceNodeAlpha.get(id) ?? 0;
+        obj.material.opacity = a * factor;
+        obj.mesh.scale.setScalar(entranceNodeScale.get(id) ?? ENTRANCE_MIN_SCALE);
+        if (obj.sprite) obj.sprite.visible = labelShown.has(id) && factor > LABEL_ENTRANCE_MIN;
+      } else {
+        obj.material.opacity = a;
+      }
+    }
+    for (const [index, obj] of linkObjects) {
+      const a = displayEdgeAlpha.get(index);
+      if (a === void 0) continue;
+      obj.material.opacity = entranceActive ? a * (entranceEdgeAlpha.get(index) ?? 0) : a;
+    }
+  }
+  function armEmphasis() {
+    const targets = resolveEmphasis({
+      nodes: compilation.nodes,
+      edges: compilation.edges,
+      focus: currentFocus(),
+      exemptIds: seedIds,
+      dimOpacity: effectiveDimOpacity(),
+      edgeBaseAlpha
+    });
+    if (emphasisTween) {
+      scheduler.remove(emphasisTween);
+      emphasisTween = null;
+    }
+    const hoverCfg = compilation.animation?.hover ?? null;
+    const duration = hoverCfg && !prefersReducedMotion() ? hoverCfg.duration : 0;
+    if (duration <= 0) {
+      for (const [id, a] of targets.nodes) displayNodeAlpha.set(id, a);
+      for (const [i, a] of targets.edges) displayEdgeAlpha.set(i, a);
+      paint();
+      refreshLabels();
+      return;
+    }
+    const fromNodes = new Map(displayNodeAlpha);
+    const fromEdges = new Map(displayEdgeAlpha);
+    const tween = createTween({
+      duration,
+      ease: resolveEase(hoverCfg?.ease ?? "smooth"),
+      apply: (t) => {
+        for (const [id, to] of targets.nodes) {
+          const from = fromNodes.get(id) ?? to;
+          displayNodeAlpha.set(id, from + (to - from) * t);
+        }
+        for (const [i, to] of targets.edges) {
+          const from = fromEdges.get(i) ?? to;
+          displayEdgeAlpha.set(i, from + (to - from) * t);
+        }
+        paint();
+      },
+      onDone: () => {
+        emphasisTween = null;
+      }
+    });
+    emphasisTween = tween;
+    scheduler.add(tween);
+    refreshLabels();
+  }
+  function resolveHighlightTarget2(target) {
+    return resolveHighlightTarget(target, compilation.nodes, adjacency);
+  }
+  function categoryHighlightSet2() {
+    return categoryHighlightSet(activeCategories, nodeCategory);
+  }
+  function recomputeHighlight() {
+    const filter = categoryHighlightSet2();
+    const transient = transientHighlight !== null && transientHighlight.size > 0 ? transientHighlight : null;
+    if (filter !== null && transient !== null) {
+      const inter = /* @__PURE__ */ new Set();
+      for (const id of transient) if (filter.has(id)) inter.add(id);
+      highlightSet = inter.size > 0 ? inter : transient;
+      return;
+    }
+    highlightSet = filter ?? transient;
+  }
+  function refreshTransientHighlight() {
+    if (transientTarget === null) {
+      transientHighlight = null;
+      return;
+    }
+    const nextIds = new Set(compilation.nodes.map((n) => n.id));
+    const resolved = new Set(
+      [...resolveHighlightTarget2(transientTarget)].filter((id) => nextIds.has(id))
+    );
+    transientHighlight = resolved.size > 0 ? resolved : null;
+  }
+  function emitHighlightChange() {
+    options?.onHighlightChange?.(highlightSet ? [...highlightSet] : null);
+  }
+  function forcedLabelIds() {
+    const forced = /* @__PURE__ */ new Set();
+    for (const id of seedIds) forced.add(id);
+    for (const [id, override] of Object.entries(currentSpec.nodeOverrides ?? {})) {
+      if (override?.alwaysShowLabel) forced.add(id);
+    }
+    if (hoveredNodeId) forced.add(hoveredNodeId);
+    for (const id of selectedNodeIds) forced.add(id);
+    const matches = searchManager.getMatches();
+    if (matches) for (const id of matches) forced.add(id);
+    return forced;
+  }
+  function refreshLabels() {
+    if (destroyed || nodeObjects.size === 0) return;
+    const camera = graph.camera();
+    const cameraPos = camera?.position ?? { x: 0, y: 0, z: FIT_DISTANCE };
+    const forced = forcedLabelIds();
+    const ranked = resolveVisibleLabels(
+      // Only nodes that actually compiled a label are candidates. Filtering on
+      // the datum rather than `nodeObjects` matters: the library's digest is
+      // deferred, so on the first rank the objects may not exist yet and an
+      // object-side filter would let unlabelled nodes eat budget slots.
+      nodeData.filter((d) => d.node.label).map((d) => ({
+        id: d.id,
+        priority: d.node.labelPriority,
+        x: d.x ?? 0,
+        y: d.y ?? 0,
+        z: d.z ?? 0
+      })),
+      forced,
+      cameraPos,
+      LABEL_BUDGET_3D
+    );
+    const fov = (camera?.fov ?? DEFAULT_FOV_DEG) * (Math.PI / 180);
+    const viewportHeight = shell.getSize().height || 1;
+    const worldPerPixel = 2 * Math.tan(fov / 2) / viewportHeight;
+    labelShown.clear();
+    const placed = [];
+    for (const id of ranked) {
+      const obj = nodeObjects.get(id);
+      const datum = nodeById.get(id);
+      if (!obj || !datum || !obj.labelText) continue;
+      const dist = Math.hypot(
+        (datum.x ?? 0) - cameraPos.x,
+        (datum.y ?? 0) - cameraPos.y,
+        (datum.z ?? 0) - cameraPos.z
+      );
+      const desiredHeight = LABEL_SCREEN_PX * worldPerPixel * dist;
+      const factor = Math.min(
+        LABEL_SCALE_MAX,
+        Math.max(LABEL_SCALE_MIN, desiredHeight / LABEL_TEXT_HEIGHT)
+      );
+      const projected = graph.graph2ScreenCoords(datum.x ?? 0, datum.y ?? 0, datum.z ?? 0);
+      const box = labelBox(projected, obj.labelText, LABEL_SCREEN_PX * factor);
+      if (box && !forced.has(id) && placed.some((other) => overlaps(box, other))) continue;
+      if (box) placed.push(box);
+      const sprite = ensureLabelSprite(obj);
+      if (!sprite) continue;
+      labelShown.add(id);
+      if (obj.labelBaseScale) {
+        sprite.scale.set(obj.labelBaseScale.x * factor, obj.labelBaseScale.y * factor, 0);
+      }
+    }
+    for (const [id, obj] of nodeObjects) {
+      if (obj.sprite) {
+        obj.sprite.visible = labelShown.has(id) && (!entranceActive || (entranceNodeAlpha.get(id) ?? 0) > LABEL_ENTRANCE_MIN);
+      }
+    }
+    lastLabelRank = performance.now();
+  }
+  function scheduleLabelRank() {
+    if (labelRankQueued || destroyed) return;
+    const wait = Math.max(0, LABEL_RERANK_MS - (performance.now() - lastLabelRank));
+    labelRankQueued = true;
+    setTimeout(() => {
+      labelRankQueued = false;
+      if (!destroyed) refreshLabels();
+    }, wait);
+  }
+  function controlsTarget() {
+    const t = graph.controls().target;
+    return t ? { x: t.x, y: t.y, z: t.z } : { x: 0, y: 0, z: 0 };
+  }
+  function getCamera() {
+    const pos = graph.cameraPosition();
+    const target = controlsTarget();
+    const dist = Math.hypot(pos.x - target.x, pos.y - target.y, pos.z - target.z) || FIT_DISTANCE;
+    return {
+      x: target.x,
+      y: target.y,
+      k: FIT_DISTANCE / dist,
+      position: { x: pos.x, y: pos.y, z: pos.z },
+      target
+    };
+  }
+  function flightMs(opts) {
+    const cfg = compilation.animation?.camera ?? null;
+    if (cfg === null || prefersReducedMotion() || opts?.duration === 0) return 0;
+    const requested = opts?.duration ?? cfg.duration;
+    return requested === "auto" ? AUTO_FLIGHT_MS : requested;
+  }
+  function clampK(k) {
+    return Math.min(K_MAX, Math.max(K_MIN, k));
+  }
+  function flyTo(target, opts) {
+    if (destroyed) return;
+    autoFit = false;
+    const ms = flightMs(opts);
+    if (target.position) {
+      graph.cameraPosition(
+        target.position,
+        target.target ?? { x: target.x, y: target.y, z: 0 },
+        ms
+      );
+      queueCameraChange();
+      return;
+    }
+    const look = { x: target.x, y: target.y, z: 0 };
+    const cam = getCamera();
+    const dist = FIT_DISTANCE / clampK(target.k ?? cam.k);
+    const dir = normalize({
+      x: cam.position.x - cam.target.x,
+      y: cam.position.y - cam.target.y,
+      z: cam.position.z - cam.target.z
+    });
+    graph.cameraPosition(
+      { x: look.x + dir.x * dist, y: look.y + dir.y * dist, z: look.z + dir.z * dist },
+      look,
+      ms
+    );
+    queueCameraChange();
+  }
+  function zoomToFit(opts) {
+    autoFit = false;
+    fitNow(opts);
+  }
+  function fitNow(opts) {
+    if (destroyed || nodeData.length === 0) return;
+    const camera = graph.camera();
+    const fit = computeFit(
+      nodeData.map((d) => ({
+        x: d.x ?? 0,
+        y: d.y ?? 0,
+        z: d.z ?? 0,
+        radius: d.node.radius ?? 0
+      })),
+      {
+        cameraPos: getCamera().position,
+        fovDeg: camera?.fov ?? DEFAULT_FOV_DEG,
+        aspect: camera?.aspect ?? 1,
+        viewportHeight: shell.getSize().height,
+        paddingPx: opts?.padding ?? FIT_PADDING_PX
+      }
+    );
+    if (!fit) return;
+    const distance = fit.distance * entranceCameraPull;
+    graph.cameraPosition(
+      {
+        x: fit.center.x + fit.dir.x * distance,
+        y: fit.center.y + fit.dir.y * distance,
+        z: fit.center.z + fit.dir.z * distance
+      },
+      fit.center,
+      flightMs(opts)
+    );
+    queueCameraChange();
+  }
+  function zoomToNode(nodeId, opts) {
+    if (destroyed) return;
+    autoFit = false;
+    const datum = nodeById.get(nodeId);
+    if (!datum) return;
+    const at = { x: datum.x ?? 0, y: datum.y ?? 0, z: datum.z ?? 0 };
+    const dir = normalize(at);
+    const dist = opts?.scale ? NODE_FOCUS_DISTANCE / clampK(opts.scale) : NODE_FOCUS_DISTANCE;
+    graph.cameraPosition(
+      { x: at.x + dir.x * dist, y: at.y + dir.y * dist, z: at.z + dir.z * dist },
+      at,
+      flightMs(opts)
+    );
+    queueCameraChange();
+  }
+  function queueCameraChange() {
+    if (cameraChangeQueued || destroyed || !options?.onCameraChange) return;
+    cameraChangeQueued = true;
+    requestAnimationFrame(() => {
+      cameraChangeQueued = false;
+      if (destroyed) return;
+      options.onCameraChange?.(getCamera());
+    });
+  }
+  function tooltipFormatter() {
+    const t = options?.tooltip;
+    return t && typeof t === "object" ? t.formatter ?? null : null;
+  }
+  function toWrapperXY(p) {
+    const screen = graph.graph2ScreenCoords(p.x, p.y, p.z);
+    if (!screen || !Number.isFinite(screen.x) || !Number.isFinite(screen.y)) return null;
+    const s = surfaceEl.getBoundingClientRect();
+    const w = shell.wrapper.getBoundingClientRect();
+    return { x: screen.x + (s.left - w.left), y: screen.y + (s.top - w.top) };
+  }
+  function applyFormatterResult(result, x, y) {
+    const tm = shell.tooltipManager;
+    if (!tm) return;
+    if (result === null) hideTooltip();
+    else if (typeof result === "string") tm.show({ text: result }, x, y);
+    else if (result instanceof HTMLElement) tm.show({ element: result }, x, y);
+    else tm.show(result, x, y);
+  }
+  function anchorTooltip() {
+    const tm = shell.tooltipManager;
+    if (!tm || openTooltip === null) return;
+    const formatter = tooltipFormatter();
+    const key = openTooltip.kind === "node" ? `node:${openTooltip.id}` : `edge:${openTooltip.index}`;
+    if (openTooltip.kind === "node") {
+      const id = openTooltip.id;
+      const datum = nodeById.get(id);
+      const defaults2 = compilation.tooltipDescriptors.get(id);
+      if (!datum || !defaults2) return;
+      const at2 = toWrapperXY({ x: datum.x ?? 0, y: datum.y ?? 0, z: datum.z ?? 0 });
+      if (!at2) return;
+      if (key === renderedTooltip) {
+        tm.move(at2.x, at2.y);
+        return;
+      }
+      renderedTooltip = key;
+      if (!formatter) {
+        tm.show(defaults2, at2.x, at2.y);
+        return;
+      }
+      applyFormatterResult(
+        formatter({ kind: "node", data: nodeDataMap.get(id) ?? {} }, defaults2),
+        at2.x,
+        at2.y
+      );
+      return;
+    }
+    const link = linkData[openTooltip.index];
+    if (!link) return;
+    const a = endpointPos(link.source);
+    const b = endpointPos(link.target);
+    const at = toWrapperXY({ x: (a.x + b.x) / 2, y: (a.y + b.y) / 2, z: (a.z + b.z) / 2 });
+    if (!at) return;
+    if (key === renderedTooltip) {
+      tm.move(at.x, at.y);
+      return;
+    }
+    renderedTooltip = key;
+    const defaults = buildEdgeTooltip(link.edge);
+    if (!formatter) {
+      tm.show(defaults, at.x, at.y);
+      return;
+    }
+    applyFormatterResult(
+      formatter({ kind: "edge", data: link.edge.data ?? {} }, defaults),
+      at.x,
+      at.y
+    );
+  }
+  function endpointPos(endpoint) {
+    if (typeof endpoint !== "string") {
+      return { x: endpoint.x ?? 0, y: endpoint.y ?? 0, z: endpoint.z ?? 0 };
+    }
+    const datum = nodeById.get(endpoint);
+    return { x: datum?.x ?? 0, y: datum?.y ?? 0, z: datum?.z ?? 0 };
+  }
+  function hideTooltip() {
+    openTooltip = null;
+    renderedTooltip = null;
+    shell.tooltipManager?.hide();
+  }
+  function legendSetting() {
+    return options?.legend ?? currentSpec.legend;
+  }
+  function legendConfig() {
+    const l = legendSetting();
+    if (l && typeof l === "object") {
+      return { interactive: l.interactive ?? true, counts: l.counts ?? true };
+    }
+    return { interactive: true, counts: true };
+  }
+  function getLegend() {
+    const nodeEntries = "entries" in compilation.legend ? compilation.legend.entries : [];
+    return {
+      field: compilation.legendField,
+      nodes: nodeEntries.filter((e) => !e.overflow).map((e) => ({
+        label: e.label,
+        color: e.color,
+        count: e.count,
+        active: activeCategories.size === 0 || activeCategories.has(e.label)
+      })),
+      edges: (compilation.edgeLegend ?? []).map((e) => ({
+        label: e.label,
+        color: e.color,
+        count: e.count
+      }))
+    };
+  }
+  function renderLegend() {
+    if (!shell.legendEl) return;
+    const view = { nodes: getLegend().nodes, edges: getLegend().edges };
+    if (!legendController) {
+      const cfg = legendConfig();
+      legendController = createGraphLegend(shell.legendEl, view, {
+        interactive: cfg.interactive,
+        counts: cfg.counts,
+        onToggle: (value) => toggleLegendCategory(value),
+        onHover: (value) => {
+          const field = compilation.legendField;
+          options?.onLegendHover?.(value !== null && field ? { field, value } : null);
+        }
+      });
+    } else {
+      legendController.update(view);
+    }
+    shell.syncChromeInset();
+  }
+  function toggleLegendCategory(value) {
+    if (activeCategories.has(value)) activeCategories.delete(value);
+    else activeCategories.add(value);
+    recomputeHighlight();
+    renderLegend();
+    armEmphasis();
+    options?.onLegendToggle?.([...activeCategories]);
+    emitHighlightChange();
+  }
+  function handleNodeClick(nodeId, shiftKey) {
+    if (shiftKey) {
+      if (selectedNodeIds.has(nodeId)) selectedNodeIds.delete(nodeId);
+      else selectedNodeIds.add(nodeId);
+    } else {
+      selectedNodeIds = /* @__PURE__ */ new Set([nodeId]);
+    }
+    armEmphasis();
+    options?.onSelectionChange?.([...selectedNodeIds]);
+    options?.onNodeClick?.(nodeDataMap.get(nodeId) ?? {});
+  }
+  const raycaster = new Raycaster();
+  const pointer = new Vector2();
+  function pickNode(event) {
+    const canvas = graph.renderer()?.domElement;
+    const camera = graph.camera();
+    if (!canvas || !camera) return null;
+    const rect = canvas.getBoundingClientRect();
+    pointer.x = (event.clientX - rect.left) / (rect.width || 1) * 2 - 1;
+    pointer.y = -((event.clientY - rect.top) / (rect.height || 1)) * 2 + 1;
+    raycaster.setFromCamera(pointer, camera);
+    const groups = [...nodeObjects.values()].map((o) => o.group);
+    const hits = raycaster.intersectObjects(groups, true);
+    for (const hit of hits) {
+      let obj = hit.object;
+      while (obj) {
+        const id = obj.userData?.nodeId;
+        if (typeof id === "string") return id;
+        obj = obj.parent;
+      }
+    }
+    return null;
+  }
+  const onCanvasCameraInput = () => {
+    autoFit = false;
+  };
+  const onCanvasDblClick = (event) => {
+    const id = pickNode(event);
+    if (id) options?.onNodeDoubleClick?.(nodeDataMap.get(id) ?? {});
+  };
+  const onContextLost = (event) => {
+    event.preventDefault();
+  };
+  function endEntrance() {
+    entranceActive = false;
+    entranceCameraPull = 1;
+    for (const obj of nodeObjects.values()) obj.mesh.scale.setScalar(1);
+    paint();
+  }
+  function startEntrance() {
+    const enter = compilation.animation?.enter ?? null;
+    if (options?.suppressEntrance || !enter || prefersReducedMotion()) {
+      endEntrance();
+      return;
+    }
+    const stagger = enter.stagger && compilation.nodes.length <= ENTRANCE_STAGGER_MAX_NODES;
+    const plan = planEntrance(
+      nodeData.map((d) => ({ id: d.id, x: d.x ?? 0, y: d.y ?? 0 })),
+      compilation.edges,
+      enter.duration,
+      stagger
+    );
+    const ease = resolveEase(enter.ease);
+    entranceActive = true;
+    entranceCameraPull = enter.cameraFit ? ENTRANCE_CAMERA_PULLBACK : 1;
+    for (const id of plan.nodeOffset.keys()) {
+      entranceNodeAlpha.set(id, 0);
+      entranceNodeScale.set(id, ENTRANCE_MIN_SCALE);
+    }
+    for (const index of plan.linkOffset.keys()) entranceEdgeAlpha.set(index, 0);
+    paint();
+    const tween = createTween({
+      duration: plan.span,
+      ease: linear,
+      apply: (t) => {
+        const elapsed = t * plan.span;
+        for (const [id, offset] of plan.nodeOffset) {
+          const p = elementProgress(elapsed, offset, enter.duration, ease);
+          entranceNodeAlpha.set(id, popAlpha(p));
+          entranceNodeScale.set(id, Math.max(ENTRANCE_MIN_SCALE, popScale(p)));
+        }
+        for (const [index, offset] of plan.linkOffset) {
+          entranceEdgeAlpha.set(index, elementProgress(elapsed, offset, enter.duration, ease));
+        }
+        if (enter.cameraFit) {
+          entranceCameraPull = ENTRANCE_CAMERA_PULLBACK + (1 - ENTRANCE_CAMERA_PULLBACK) * ease(t);
+          if (autoFit && options?.fitOnLoad !== false) fitNow({ duration: 0 });
+        }
+        paint();
+      },
+      onDone: endEntrance
+    });
+    scheduler.add(tween);
+  }
+  function search(query) {
+    if (destroyed) return;
+    searchManager.search(query, compilation.nodes);
+    armEmphasis();
+  }
+  function clearSearch() {
+    if (destroyed) return;
+    searchManager.clearSearch();
+    armEmphasis();
+  }
+  function selectNode(nodeId, opts) {
+    if (destroyed) return;
+    selectedNodeIds = /* @__PURE__ */ new Set([nodeId]);
+    armEmphasis();
+    options?.onSelectionChange?.([nodeId]);
+    const shouldFly = opts?.fly ?? compilation.interaction.selectFlyTo;
+    if (shouldFly) zoomToNode(nodeId, opts);
+  }
+  function highlight(target, opts) {
+    if (destroyed) return;
+    transientTarget = target;
+    refreshTransientHighlight();
+    highlightDimOpacity = opts?.dimOpacity ?? null;
+    recomputeHighlight();
+    armEmphasis();
+    emitHighlightChange();
+  }
+  function clearHighlight() {
+    if (destroyed) return;
+    transientTarget = null;
+    transientHighlight = null;
+    highlightDimOpacity = null;
+    recomputeHighlight();
+    armEmphasis();
+    emitHighlightChange();
+  }
+  function setActiveCategories(values) {
+    if (destroyed) return;
+    activeCategories = new Set(values);
+    recomputeHighlight();
+    renderLegend();
+    armEmphasis();
+    emitHighlightChange();
+  }
+  function doResize() {
+    if (destroyed) return;
+    const renderer = graph.renderer();
+    const dpr = Math.min(MAX_PIXEL_RATIO, globalThis.devicePixelRatio || 1);
+    if (renderer?.getPixelRatio?.() !== dpr) renderer?.setPixelRatio?.(dpr);
+    const { width: width2, height: height2 } = shell.getSize();
+    graph.width(width2).height(height2);
+    shell.syncChromeInset();
+  }
+  function update(newSpec) {
+    if (destroyed) return;
+    const next = ctx.compile(newSpec);
+    if (next.numDimensions !== 3) {
+      shell.warn("createGraph: update() cannot change dimensions; remount the graph");
+      return;
+    }
+    scheduler.finishAll();
+    const prevNodes = nodeData.map((d, index) => ({
+      ...d.node,
+      x: d.x ?? 0,
+      y: d.y ?? 0,
+      index
+    }));
+    const prevEdges = compilation.edges.map((edge) => {
+      const a = endpointPos(edge.source);
+      const b = endpointPos(edge.target);
+      return { ...edge, sourceX: a.x, sourceY: a.y, targetX: b.x, targetY: b.y };
+    });
+    const prevConfig = compilation.simulationConfig;
+    const prevUseLinkWidth = useLinkWidth;
+    currentSpec = newSpec;
+    compilation = next;
+    renderedTooltip = null;
+    const diff = diffGraphUpdate(
+      prevNodes,
+      prevEdges,
+      compilation,
+      prevConfig,
+      prevConfig.seed ?? 0
+    );
+    rebuildDerived();
+    shell.renderChrome(compilation);
+    renderLegend();
+    refreshTransientHighlight();
+    recomputeHighlight();
+    reRunSearch();
+    const shapeClassChanged = useLinkWidth !== prevUseLinkWidth || [...linkObjects.values()].some((obj) => !linkShapeMatches(obj, useLinkWidth));
+    if (useLinkWidth !== prevUseLinkWidth) graph.linkHoverPrecision(useLinkWidth ? 4 : 8);
+    if (diff.visualOnly) {
+      for (let i = 0; i < compilation.nodes.length; i++) {
+        const node = compilation.nodes[i];
+        nodeData[i].node = node;
+        const obj = nodeObjects.get(node.id);
+        if (obj) applyNodeVisuals(obj, node, labelColor());
+      }
+      for (let i = 0; i < compilation.edges.length; i++) {
+        const edge = compilation.edges[i];
+        linkData[i].edge = edge;
+        if (shapeClassChanged) continue;
+        const obj = linkObjects.get(i);
+        if (obj) applyLinkVisuals(obj, edge, useLinkWidth);
+      }
+      if (shapeClassChanged) {
+        for (const obj of linkObjects.values()) disposeLinkObject(obj);
+        linkObjects.clear();
+        graph.linkThreeObject(linkThreeObject);
+      }
+      pruneInteractionState();
+      armEmphasis();
+      return;
+    }
+    const nextNodeIds = new Set(compilation.nodes.map((n) => n.id));
+    for (const [id, obj] of nodeObjects) {
+      if (!nextNodeIds.has(id)) {
+        disposeNodeObject(obj);
+        nodeObjects.delete(id);
+        displayNodeAlpha.delete(id);
+        entranceNodeAlpha.delete(id);
+        entranceNodeScale.delete(id);
+      }
+    }
+    for (const obj of linkObjects.values()) disposeLinkObject(obj);
+    linkObjects.clear();
+    displayEdgeAlpha.clear();
+    entranceEdgeAlpha.clear();
+    const survivors = new Map(nodeById);
+    nodeData = compilation.nodes.map((node) => {
+      const existing = survivors.get(node.id);
+      if (existing) {
+        existing.node = node;
+        const obj = nodeObjects.get(node.id);
+        if (obj) applyNodeVisuals(obj, node, labelColor());
+        return existing;
+      }
+      const spawn = diff.spawnPositions.get(node.id) ?? { x: 0, y: 0 };
+      return {
+        id: node.id,
+        node,
+        x: spawn.x,
+        y: spawn.y,
+        z: seedZ(node.id, node.radius, node.community)
+      };
+    });
+    linkData = compilation.edges.map((edge, edgeIndex) => ({
+      source: edge.source,
+      target: edge.target,
+      edge,
+      edgeIndex
+    }));
+    nodeById = new Map(nodeData.map((d) => [d.id, d]));
+    applySimulationConfig(graph, compilation.simulationConfig, nodeData.length);
+    graph.graphData({ nodes: nodeData, links: linkData });
+    pruneInteractionState();
+    armEmphasis();
+  }
+  function pruneInteractionState() {
+    const ids = new Set(compilation.nodes.map((n) => n.id));
+    if (hoveredNodeId && !ids.has(hoveredNodeId)) hoveredNodeId = null;
+    const hadEdgeHover = hoveredLinkIndex !== null;
+    hoveredLinkIndex = null;
+    if (hadEdgeHover) options?.onEdgeHover?.(null);
+    selectedNodeIds = new Set([...selectedNodeIds].filter((id) => ids.has(id)));
+    if (openTooltip?.kind === "node" && !ids.has(openTooltip.id)) hideTooltip();
+    if (openTooltip?.kind === "edge") hideTooltip();
+  }
+  function reRunSearch() {
+    const q = searchManager.getQuery();
+    if (q !== null) searchManager.search(q, compilation.nodes);
+  }
+  function destroy() {
+    if (destroyed) return;
+    destroyed = true;
+    scheduler.cancelAll();
+    if (pumpId !== null) {
+      cancelAnimationFrame(pumpId);
+      pumpId = null;
+    }
+    const canvas = graph.renderer()?.domElement;
+    canvas?.removeEventListener("dblclick", onCanvasDblClick);
+    canvas?.removeEventListener("pointerdown", onCanvasCameraInput);
+    canvas?.removeEventListener("wheel", onCanvasCameraInput);
+    canvas?.removeEventListener("webglcontextlost", onContextLost);
+    if (controlsListener) {
+      graph.controls().removeEventListener?.("change", controlsListener);
+      controlsListener = null;
+    }
+    disconnectResize();
+    const renderer = graph.renderer();
+    graph._destructor();
+    for (const obj of nodeObjects.values()) disposeNodeObject(obj);
+    nodeObjects.clear();
+    for (const obj of linkObjects.values()) disposeLinkObject(obj);
+    linkObjects.clear();
+    renderer?.dispose();
+    renderer?.forceContextLoss?.();
+    legendController?.destroy();
+    legendController = null;
+    shell.destroy();
+  }
+  rebuildDerived();
+  shell.renderChrome(compilation);
+  renderLegend();
+  const initial = compilation.initialHighlight;
+  if (initial) {
+    activeCategories = new Set(initial.values);
+    recomputeHighlight();
+  }
+  const requestedBackground = themeBackground(options?.theme) ?? themeBackground(currentSpec.theme);
+  if (requestedBackground === "transparent") {
+    graph.backgroundColor("rgba(0,0,0,0)");
+    shell.wrapper.style.background = "transparent";
+  } else {
+    graph.backgroundColor(resolvedSurface(compilation.theme));
+  }
+  graph.showNavInfo(false).enableNodeDrag(false).nodeId("id").nodeLabel("").linkLabel("").nodeVal((d) => d.node.radius).nodeColor((d) => d.node.fill).nodeThreeObject((d) => nodeObjectFor(d).group).linkColor((d) => d.edge.stroke).linkWidth((d) => useLinkWidth ? d.edge.strokeWidth : 0).linkThreeObject(linkThreeObject).linkPositionUpdate((_obj, coords, d) => {
+    const link = linkObjects.get(d.edgeIndex);
+    return link ? updateLinkPosition(link, coords.start, coords.end) : false;
+  }).linkHoverPrecision(useLinkWidth ? 4 : 8);
+  const { width, height } = shell.getSize();
+  graph.width(width).height(height);
+  applySimulationConfig(graph, compilation.simulationConfig, compilation.nodes.length);
+  buildGraphData(seedPositions(compilation.nodes));
+  for (const n of compilation.nodes) displayNodeAlpha.set(n.id, n.opacity);
+  for (let i = 0; i < compilation.edges.length; i++) {
+    displayEdgeAlpha.set(i, edgeBaseAlpha?.get(i) ?? 0.3);
+  }
+  armEmphasis();
+  startEntrance();
+  graph.onNodeHover((node) => {
+    const id = node ? node.id : null;
+    if (id === hoveredNodeId) return;
+    hoveredNodeId = id;
+    if (id && hoveredLinkIndex !== null) {
+      hoveredLinkIndex = null;
+      options?.onEdgeHover?.(null);
+    }
+    armEmphasis();
+    options?.onNodeHover?.(id ? nodeDataMap.get(id) ?? {} : null);
+    if (id && shell.tooltipManager) {
+      openTooltip = { kind: "node", id };
+      anchorTooltip();
+    } else {
+      hideTooltip();
+    }
+  }).onLinkHover((link) => {
+    const index = link ? link.edgeIndex : null;
+    if (index === hoveredLinkIndex) return;
+    if (hoveredNodeId !== null) return;
+    hoveredLinkIndex = index;
+    options?.onEdgeHover?.(link ? link.edge.data ?? {} : null);
+    if (index !== null && shell.tooltipManager) {
+      openTooltip = { kind: "edge", index };
+      anchorTooltip();
+    } else {
+      hideTooltip();
+    }
+  }).onNodeClick((node, event) => {
+    handleNodeClick(node.id, Boolean(event?.shiftKey));
+  }).onBackgroundClick(() => {
+    if (selectedNodeIds.size === 0) return;
+    selectedNodeIds = /* @__PURE__ */ new Set();
+    armEmphasis();
+    options?.onSelectionChange?.([]);
+  }).onEngineTick(() => {
+    if (destroyed) return;
+    anchorTooltip();
+    if (autoFit && options?.fitOnLoad !== false) {
+      const now = performance.now();
+      if (now - lastAutoFit > AUTO_FIT_INTERVAL_MS) {
+        lastAutoFit = now;
+        fitNow({ duration: 0 });
+        refreshLabels();
+      }
+    }
+  }).onEngineStop(() => {
+    if (destroyed) return;
+    if (autoFit && options?.fitOnLoad !== false) {
+      autoFit = false;
+      fitNow({ duration: 0 });
+    }
+    refreshLabels();
+  });
+  controlsListener = () => {
+    if (destroyed) return;
+    scheduleLabelRank();
+    anchorTooltip();
+    queueCameraChange();
+  };
+  graph.controls().addEventListener?.(
+    "change",
+    controlsListener
+  );
+  const canvasEl = graph.renderer()?.domElement;
+  canvasEl?.addEventListener("dblclick", onCanvasDblClick);
+  canvasEl?.addEventListener("pointerdown", onCanvasCameraInput);
+  canvasEl?.addEventListener("wheel", onCanvasCameraInput, { passive: true });
+  canvasEl?.addEventListener("webglcontextlost", onContextLost);
+  const disconnectResize = shell.observeResize(() => doResize());
+  return {
+    update,
+    // `update()` already routes an id-set-preserving change through the
+    // material-mutation path, which never touches `graphData()`.
+    updateVisuals: update,
+    search,
+    clearSearch,
+    zoomToFit,
+    zoomToNode,
+    flyTo,
+    centerAt: (x, y, opts) => flyTo({ x, y }, opts),
+    getCamera,
+    selectNode,
+    getSelectedNodes: () => [...selectedNodeIds],
+    getSearchMatches: () => [...searchManager.getMatches() ?? []],
+    highlight,
+    clearHighlight,
+    getHighlight: () => highlightSet ? [...highlightSet] : null,
+    getLegend,
+    setActiveCategories,
+    getActiveCategories: () => [...activeCategories],
+    resize: doResize,
+    destroy
+  };
+}
+function themeBackground(theme) {
+  const colors = theme?.colors;
+  if (!colors || Array.isArray(colors)) return void 0;
+  return typeof colors.background === "string" ? colors.background : void 0;
+}
+
+// src/graph-3d/index.ts
+registerGraphRenderer(3, createGraph3DRenderer);
+function createGraph3D(container, spec, options) {
+  return createGraph(container, { ...spec, dimensions: 3 }, options);
+}
+export {
+  FIT_DISTANCE,
+  LABEL_BUDGET_3D,
+  LINK_WIDTH_MAX_EDGES,
+  NODE_FOCUS_DISTANCE,
+  createGraph3D,
+  createGraph3DRenderer,
+  forceCluster3D,
+  resolveEmphasis,
+  resolveVisibleLabels
+};
+//# sourceMappingURL=index.js.map