@almadar/shell-web 0.0.0-stage → 0.1.0

package/dist/chunk-DJ433ET5.js

@@ -0,0 +1,1327 @@
+import { useAvl3DPalette } from './chunk-EOWMARUB.js';
+import { avlBlend, AVL_INK, EFFECT_CATEGORY_COLORS, OPERATOR_CATEGORY_COLORS, avlTint, effectCategoryOf } from './chunk-DFNZUYX4.js';
+import { Typography, Box, VStack, useTranslate } from './chunk-MBQAMMSE.js';
+import { Vector3, QuadraticBezierCurve3, MathUtils, Quaternion } from 'three';
+import { EntityPersistenceSchema } from '@almadar/core';
+import { getStdOperatorMeta } from '@almadar/std/registry';
+import { Html, RoundedBox } from '@react-three/drei';
+import { jsx, jsxs, Fragment } from 'react/jsx-runtime';
+import { useRef, useState, useMemo } from 'react';
+import { useFrame } from '@react-three/fiber';
+
+function operatorPaletteKey(category) {
+  return `op:${category}`;
+}
+function operatorCategoryPalette() {
+  const out = {};
+  for (const [category, color] of Object.entries(OPERATOR_CATEGORY_COLORS)) out[operatorPaletteKey(category)] = color;
+  return out;
+}
+var AVL_3D_COLORS = {
+  orbitalSphere: "var(--color-card)",
+  orbitalRim: "var(--color-info)",
+  entityCore: "var(--color-warning)",
+  entityCoreGlow: avlBlend("var(--color-warning)", 70, "var(--color-background)"),
+  traitOrbit: "var(--color-info)",
+  traitOrbitHighlight: "var(--color-primary)",
+  stateIdle: "var(--color-muted)",
+  stateEdge: "var(--color-info)",
+  stateActive: "var(--color-primary)",
+  transitionArc: "var(--color-muted-foreground)",
+  transitionArcHover: "var(--color-primary)",
+  guardPass: "var(--color-success)",
+  guardFail: "var(--color-error)",
+  crossWire: "var(--color-accent)",
+  crossWireGlow: avlBlend("var(--color-accent)", 70, "var(--color-background)"),
+  pagePortal: "var(--color-success)",
+  background: "var(--color-background)",
+  backgroundSurface: "var(--color-card)",
+  fog: "var(--color-background)",
+  sparkle: "var(--color-info)",
+  sparkleWarm: "var(--color-warning)",
+  // Entity persistence badge (Avl3DEntityCore ring + micro-icons)
+  persistencePersistent: "var(--color-info)",
+  persistenceRuntime: "var(--color-success)",
+  persistenceUnknown: "var(--color-muted-foreground)",
+  // Expression tree (Avl3DExprTree): operator categories, bindings, literals
+  ...operatorCategoryPalette(),
+  exprOperatorUnknown: "var(--color-muted-foreground)",
+  exprBinding: "var(--color-accent)",
+  exprLiteral: "var(--color-muted-foreground)",
+  // Effect category (Avl3DTransitionArc micro-icons)
+  effectUi: EFFECT_CATEGORY_COLORS.ui.color,
+  effectData: EFFECT_CATEGORY_COLORS.data.color,
+  effectCommunication: EFFECT_CATEGORY_COLORS.communication.color,
+  effectLifecycle: EFFECT_CATEGORY_COLORS.lifecycle.color,
+  effectControl: EFFECT_CATEGORY_COLORS.control.color,
+  effectAsync: EFFECT_CATEGORY_COLORS.async.color,
+  effectCompute: EFFECT_CATEGORY_COLORS.compute.color,
+  effectSystem: EFFECT_CATEGORY_COLORS.system.color,
+  effectUnknown: "var(--color-muted-foreground)",
+  // Misc mesh accents
+  fieldParticle: "var(--color-foreground)",
+  lightAmbient: "var(--color-info)",
+  lightDirectional: avlBlend("var(--color-info)", 50, AVL_INK.onFocus),
+  lightFill: avlBlend("var(--color-info)", 70, AVL_INK.canvas)
+};
+var PERSISTENCE_PALETTE_KEY = {
+  persistent: "persistencePersistent",
+  runtime: "persistenceRuntime"
+};
+function persistencePaletteKey(persistence) {
+  const parsed = EntityPersistenceSchema.safeParse(persistence);
+  return parsed.success ? PERSISTENCE_PALETTE_KEY[parsed.data] : "persistenceUnknown";
+}
+function exprOperatorPaletteKey(label) {
+  const meta = getStdOperatorMeta(label);
+  return meta ? operatorPaletteKey(meta.category) : "exprOperatorUnknown";
+}
+var EFFECT_CATEGORY_PALETTE_KEY = {
+  ui: "effectUi",
+  data: "effectData",
+  communication: "effectCommunication",
+  lifecycle: "effectLifecycle",
+  control: "effectControl",
+  async: "effectAsync",
+  compute: "effectCompute",
+  system: "effectSystem"
+};
+function effectTypePaletteKey(type) {
+  const category = effectCategoryOf(type);
+  return category ? EFFECT_CATEGORY_PALETTE_KEY[category] : "effectUnknown";
+}
+var GOLDEN_ANGLE = Math.PI * (3 - Math.sqrt(5));
+function goldenSpiralPositions(count, baseRadius) {
+  if (count === 0) return [];
+  if (count === 1) return [{ x: 0, y: 0, z: 0 }];
+  const positions = [];
+  for (let i = 0; i < count; i++) {
+    const angle = i * GOLDEN_ANGLE;
+    const r = baseRadius * Math.sqrt(i / count);
+    positions.push({
+      x: r * Math.cos(angle),
+      y: 0,
+      z: r * Math.sin(angle)
+    });
+  }
+  return positions;
+}
+function forceDirectedPositions(count, edges, baseRadius, iterations = 80) {
+  if (count === 0) return [];
+  if (count === 1) return [{ x: 0, y: 0, z: 0 }];
+  const positions = goldenSpiralPositions(count, baseRadius);
+  const repulsionStrength = baseRadius * baseRadius * 0.5;
+  const attractionStrength = 0.15;
+  const damping = 0.85;
+  const velocities = positions.map(() => ({ x: 0, y: 0, z: 0 }));
+  for (let iter = 0; iter < iterations; iter++) {
+    for (let i = 0; i < count; i++) {
+      for (let j = i + 1; j < count; j++) {
+        const dx = positions[i].x - positions[j].x;
+        const dz = positions[i].z - positions[j].z;
+        const distSq = dx * dx + dz * dz + 0.01;
+        const force = repulsionStrength / distSq;
+        const dist = Math.sqrt(distSq);
+        const fx = dx / dist * force;
+        const fz = dz / dist * force;
+        velocities[i].x += fx;
+        velocities[i].z += fz;
+        velocities[j].x -= fx;
+        velocities[j].z -= fz;
+      }
+    }
+    for (const edge of edges) {
+      const dx = positions[edge.to].x - positions[edge.from].x;
+      const dz = positions[edge.to].z - positions[edge.from].z;
+      const dist = Math.sqrt(dx * dx + dz * dz + 0.01);
+      const force = dist * attractionStrength;
+      const fx = dx / dist * force;
+      const fz = dz / dist * force;
+      velocities[edge.from].x += fx;
+      velocities[edge.from].z += fz;
+      velocities[edge.to].x -= fx;
+      velocities[edge.to].z -= fz;
+    }
+    for (let i = 0; i < count; i++) {
+      positions[i].x += velocities[i].x * 0.1;
+      positions[i].z += velocities[i].z * 0.1;
+      velocities[i].x *= damping;
+      velocities[i].z *= damping;
+    }
+  }
+  let cx = 0, cz = 0;
+  for (const p of positions) {
+    cx += p.x;
+    cz += p.z;
+  }
+  cx /= count;
+  cz /= count;
+  for (const p of positions) {
+    p.x -= cx;
+    p.z -= cz;
+  }
+  return positions;
+}
+function fibonacciSpherePositions(count, radius) {
+  if (count === 0) return [];
+  if (count === 1) return [{ x: 0, y: 0, z: 0 }];
+  const positions = [];
+  for (let i = 0; i < count; i++) {
+    const y = 1 - 2 * i / (count - 1);
+    const radiusAtY = Math.sqrt(1 - y * y);
+    const theta = GOLDEN_ANGLE * i;
+    positions.push({
+      x: radius * radiusAtY * Math.cos(theta),
+      y: radius * y,
+      z: radius * radiusAtY * Math.sin(theta)
+    });
+  }
+  return positions;
+}
+function orbitRingPositions(count, radius, tilt) {
+  if (count === 0) return [];
+  const positions = [];
+  const step = 2 * Math.PI / count;
+  for (let i = 0; i < count; i++) {
+    const angle = i * step;
+    const x = radius * Math.cos(angle);
+    const flatZ = radius * Math.sin(angle);
+    const y = flatZ * Math.sin(tilt);
+    const z = flatZ * Math.cos(tilt);
+    positions.push({ x, y, z });
+  }
+  return positions;
+}
+function arcCurve3D(from, to, offset) {
+  const start = new Vector3(...from);
+  const end = new Vector3(...to);
+  const mid = new Vector3().addVectors(start, end).multiplyScalar(0.5);
+  const dir = new Vector3().subVectors(end, start).normalize();
+  const up = new Vector3(0, 1, 0);
+  const perp = new Vector3().crossVectors(dir, up).normalize();
+  if (perp.length() < 1e-3) {
+    perp.crossVectors(dir, new Vector3(1, 0, 0)).normalize();
+  }
+  const control = mid.clone().add(perp.multiplyScalar(offset));
+  control.y += Math.abs(offset) * 0.3;
+  return new QuadraticBezierCurve3(start, control, end);
+}
+function selfLoopCurve3D(position, loopRadius) {
+  const base = new Vector3(...position);
+  const start = base.clone().add(new Vector3(-loopRadius * 0.3, 0, 0));
+  const end = base.clone().add(new Vector3(loopRadius * 0.3, 0, 0));
+  const control = base.clone().add(new Vector3(0, loopRadius, 0));
+  return new QuadraticBezierCurve3(start, control, end);
+}
+function treeLayout3D(node, origin, horizontalSpacing, verticalSpacing = 2) {
+  const results = [];
+  function layoutNode(n, pos, depth) {
+    results.push({ node: n, position: pos });
+    if (!n.children || n.children.length === 0) return;
+    const childCount = n.children.length;
+    const totalWidth = (childCount - 1) * horizontalSpacing / (depth + 1);
+    const startX = pos.x - totalWidth / 2;
+    for (let i = 0; i < childCount; i++) {
+      const childPos = {
+        x: startX + i * totalWidth / Math.max(childCount - 1, 1),
+        y: pos.y - verticalSpacing,
+        z: pos.z
+      };
+      layoutNode(n.children[i], childPos, depth + 1);
+    }
+  }
+  layoutNode(node, origin, 0);
+  return results;
+}
+var CAMERA_POSITIONS = {
+  application: { position: [0, 20, 30], target: [0, 0, 0] },
+  orbital: { position: [0, 8, 12], target: [0, 0, 0] },
+  trait: { position: [0, 6, 10], target: [0, 0, 0] },
+  transition: { position: [0, 4, 8], target: [0, 0, 0] }
+};
+
+// src/lib/avl-zoom-state.ts
+var initialZoomState = {
+  level: "application",
+  selectedOrbital: null,
+  selectedTrait: null,
+  selectedTransition: null,
+  animating: false,
+  animationDirection: "in",
+  animationTarget: null
+};
+function zoomReducer(state, action) {
+  switch (action.type) {
+    case "ZOOM_INTO_ORBITAL": {
+      if (state.level !== "application" || state.animating) return state;
+      return {
+        ...state,
+        animating: true,
+        animationDirection: "in",
+        animationTarget: { x: action.targetPosition.x, y: action.targetPosition.y, scale: 3 },
+        selectedOrbital: action.orbital
+      };
+    }
+    case "ZOOM_INTO_TRAIT": {
+      if (state.level !== "orbital" || state.animating) return state;
+      return {
+        ...state,
+        animating: true,
+        animationDirection: "in",
+        animationTarget: { x: action.targetPosition.x, y: action.targetPosition.y, scale: 3 },
+        selectedTrait: action.trait
+      };
+    }
+    case "ZOOM_INTO_TRANSITION": {
+      if (state.level !== "trait" || state.animating) return state;
+      return {
+        ...state,
+        animating: true,
+        animationDirection: "in",
+        animationTarget: { x: action.targetPosition.x, y: action.targetPosition.y, scale: 3 },
+        selectedTransition: action.transitionIndex
+      };
+    }
+    case "JUMP_TO_TRAIT_CIRCUIT": {
+      if (state.level !== "application" || state.animating) return state;
+      return {
+        ...state,
+        level: "trait",
+        selectedOrbital: action.orbital,
+        selectedTrait: null,
+        selectedTransition: null,
+        animating: false,
+        animationDirection: "in",
+        animationTarget: null
+      };
+    }
+    case "SELECT_TRAIT": {
+      return { ...state, selectedTrait: action.trait };
+    }
+    case "ZOOM_OUT": {
+      if (state.level === "application" || state.animating) return state;
+      return {
+        ...state,
+        animating: true,
+        animationDirection: "out",
+        animationTarget: { x: 300, y: 200, scale: 0.3 }
+      };
+    }
+    case "ANIMATION_COMPLETE": {
+      if (!state.animating) return state;
+      if (state.animationDirection === "in") {
+        const nextLevel = state.level === "application" ? "orbital" : state.level === "orbital" ? "trait" : "transition";
+        return {
+          ...state,
+          level: nextLevel,
+          animating: false,
+          animationTarget: null
+        };
+      }
+      if (state.level === "transition") {
+        return {
+          ...state,
+          level: "trait",
+          selectedTransition: null,
+          animating: false,
+          animationTarget: null
+        };
+      }
+      if (state.level === "trait") {
+        return {
+          ...state,
+          level: "application",
+          selectedOrbital: null,
+          selectedTrait: null,
+          animating: false,
+          animationTarget: null
+        };
+      }
+      if (state.level === "orbital") {
+        return {
+          ...state,
+          level: "application",
+          selectedOrbital: null,
+          animating: false,
+          animationTarget: null
+        };
+      }
+      return state;
+    }
+    case "SWITCH_TRAIT": {
+      if (state.level !== "trait" || state.animating) return state;
+      return {
+        ...state,
+        selectedTrait: action.trait,
+        selectedTransition: null
+      };
+    }
+    case "RESET": {
+      return initialZoomState;
+    }
+    default:
+      return state;
+  }
+}
+function getBreadcrumbs(state) {
+  const crumbs = [{ labelKey: "avl.glyph.application", level: "application" }];
+  if (state.selectedOrbital) {
+    crumbs.push({ label: state.selectedOrbital, level: "orbital" });
+  }
+  if (state.selectedTrait) {
+    crumbs.push({ label: state.selectedTrait, level: "trait" });
+  }
+  if (state.selectedTransition !== null) {
+    crumbs.push({ labelKey: "avl.breadcrumb.transitionNumber", labelParams: { n: state.selectedTransition }, level: "transition" });
+  }
+  return crumbs;
+}
+var Avl3DLabel = ({
+  position,
+  text,
+  color = AVL_INK.text,
+  fontSize = 12,
+  className,
+  occlude = false
+}) => {
+  return /* @__PURE__ */ jsx(
+    Html,
+    {
+      position,
+      center: true,
+      distanceFactor: 10,
+      occlude: occlude ? "blending" : void 0,
+      className,
+      style: { pointerEvents: "none" },
+      children: /* @__PURE__ */ jsx(
+        Typography,
+        {
+          variant: "small",
+          style: {
+            color,
+            fontSize: `${fontSize}px`,
+            whiteSpace: "nowrap",
+            textShadow: `0 0 4px ${avlTint(AVL_INK.canvas, 80)}`,
+            userSelect: "none"
+          },
+          children: text
+        }
+      )
+    }
+  );
+};
+Avl3DLabel.displayName = "Avl3DLabel";
+var Avl3DTooltip = ({
+  position,
+  title,
+  rows,
+  accentColor = AVL_INK.focus
+}) => {
+  return /* @__PURE__ */ jsx(
+    Html,
+    {
+      position,
+      center: true,
+      distanceFactor: 8,
+      style: { pointerEvents: "none" },
+      zIndexRange: [100, 0],
+      children: /* @__PURE__ */ jsx(
+        Box,
+        {
+          style: {
+            background: avlTint(AVL_INK.surface, 92),
+            backdropFilter: "blur(8px)",
+            borderLeft: `3px solid ${accentColor}`,
+            borderRadius: "6px",
+            padding: "8px 12px",
+            minWidth: "140px",
+            maxWidth: "220px",
+            boxShadow: "var(--shadow-lg)"
+          },
+          children: /* @__PURE__ */ jsxs(VStack, { gap: "xs", children: [
+            /* @__PURE__ */ jsx(
+              Typography,
+              {
+                variant: "small",
+                style: {
+                  color: AVL_INK.text,
+                  fontWeight: 600,
+                  fontSize: "12px",
+                  lineHeight: 1.3
+                },
+                children: title
+              }
+            ),
+            rows.map((row) => /* @__PURE__ */ jsxs(
+              Box,
+              {
+                style: {
+                  display: "flex",
+                  justifyContent: "space-between",
+                  gap: "12px"
+                },
+                children: [
+                  /* @__PURE__ */ jsx(
+                    Typography,
+                    {
+                      variant: "small",
+                      style: {
+                        color: AVL_INK.quiet,
+                        fontSize: "10px",
+                        whiteSpace: "nowrap"
+                      },
+                      children: row.label
+                    }
+                  ),
+                  /* @__PURE__ */ jsx(
+                    Typography,
+                    {
+                      variant: "small",
+                      style: {
+                        color: AVL_INK.text,
+                        fontSize: "10px",
+                        fontWeight: 500,
+                        textAlign: "right"
+                      },
+                      children: row.value
+                    }
+                  )
+                ]
+              },
+              row.label
+            ))
+          ] })
+        }
+      )
+    }
+  );
+};
+Avl3DTooltip.displayName = "Avl3DTooltip";
+var Avl3DOrbitalNode = ({
+  name,
+  entityName,
+  traitCount,
+  pageCount = 0,
+  persistence = "persistent",
+  position,
+  onClick
+}) => {
+  const groupRef = useRef(null);
+  const [hovered, setHovered] = useState(false);
+  const palette = useAvl3DPalette();
+  const { t } = useTranslate();
+  const scale = useMemo(() => 0.6 + Math.min(traitCount, 8) * 0.3, [traitCount]);
+  const currentScale = useRef(scale);
+  const targetScale = hovered ? scale * 1.06 : scale;
+  useFrame((_, delta) => {
+    if (!groupRef.current) return;
+    groupRef.current.rotation.y += delta * (hovered ? 0.4 : 0.2);
+    groupRef.current.rotation.x += delta * 0.05;
+    currentScale.current = MathUtils.damp(currentScale.current, targetScale, 6, delta);
+  });
+  const baseBrightness = 0.3 + Math.min(pageCount, 5) * 0.05;
+  const emissiveIntensity = hovered ? 0.8 : baseBrightness;
+  if (!palette) return null;
+  return /* @__PURE__ */ jsxs("group", { position, children: [
+    /* @__PURE__ */ jsxs("mesh", { scale: scale * 1.3, children: [
+      /* @__PURE__ */ jsx("sphereGeometry", { args: [1, 16, 16] }),
+      /* @__PURE__ */ jsx(
+        "meshStandardMaterial",
+        {
+          color: palette.orbitalRim,
+          emissive: palette.orbitalRim,
+          emissiveIntensity: hovered ? 0.2 : 0.06,
+          transparent: true,
+          opacity: hovered ? 0.08 : 0.03,
+          depthWrite: false
+        }
+      )
+    ] }),
+    /* @__PURE__ */ jsxs("group", { ref: groupRef, children: [
+      /* @__PURE__ */ jsxs(
+        "mesh",
+        {
+          onClick: (e) => {
+            e.stopPropagation();
+            onClick?.();
+          },
+          onPointerOver: (e) => {
+            e.stopPropagation();
+            setHovered(true);
+            document.body.style.cursor = "pointer";
+          },
+          onPointerOut: () => {
+            setHovered(false);
+            document.body.style.cursor = "auto";
+          },
+          scale: currentScale.current,
+          rotation: [Math.PI / 4, 0, 0],
+          children: [
+            /* @__PURE__ */ jsx("torusGeometry", { args: [1, 0.18, 24, 64] }),
+            /* @__PURE__ */ jsx(
+              "meshStandardMaterial",
+              {
+                color: palette.orbitalSphere,
+                emissive: palette.orbitalRim,
+                emissiveIntensity,
+                roughness: 0.2,
+                metalness: 0.7
+              }
+            )
+          ]
+        }
+      ),
+      /* @__PURE__ */ jsxs(
+        "mesh",
+        {
+          scale: scale * 0.9,
+          rotation: [Math.PI / 2 + 0.3, Math.PI / 5, 0],
+          children: [
+            /* @__PURE__ */ jsx("torusGeometry", { args: [1, 0.06, 12, 64] }),
+            /* @__PURE__ */ jsx(
+              "meshStandardMaterial",
+              {
+                color: palette.traitOrbit,
+                emissive: palette.traitOrbit,
+                emissiveIntensity: 0.25,
+                transparent: true,
+                opacity: 0.4
+              }
+            )
+          ]
+        }
+      )
+    ] }),
+    /* @__PURE__ */ jsxs("mesh", { scale: scale * 0.25, children: [
+      /* @__PURE__ */ jsx("icosahedronGeometry", { args: [1, 1] }),
+      /* @__PURE__ */ jsx(
+        "meshStandardMaterial",
+        {
+          color: palette.entityCore,
+          emissive: palette.entityCoreGlow,
+          emissiveIntensity: 2,
+          roughness: 0.1
+        }
+      )
+    ] }),
+    /* @__PURE__ */ jsx(
+      "pointLight",
+      {
+        color: palette.entityCoreGlow,
+        intensity: 0.5,
+        distance: 3,
+        decay: 2
+      }
+    ),
+    /* @__PURE__ */ jsx(
+      Avl3DLabel,
+      {
+        position: [0, scale + 0.6, 0],
+        text: name,
+        color: AVL_INK.text,
+        fontSize: hovered ? 14 : 12
+      }
+    ),
+    /* @__PURE__ */ jsx(
+      Avl3DLabel,
+      {
+        position: [0, -(scale + 0.4), 0],
+        text: entityName,
+        color: AVL_INK.quiet,
+        fontSize: 10
+      }
+    ),
+    hovered && /* @__PURE__ */ jsx(
+      Avl3DTooltip,
+      {
+        position: [scale + 1.2, 0.3, 0],
+        title: name,
+        accentColor: AVL_3D_COLORS.orbitalRim,
+        rows: [
+          { label: t("avl.entity"), value: entityName },
+          { label: t("avl.glyph.persistence"), value: persistence },
+          { label: t("avl.traits"), value: String(traitCount) },
+          { label: t("avl3d.pages"), value: String(pageCount) }
+        ]
+      }
+    )
+  ] });
+};
+Avl3DOrbitalNode.displayName = "Avl3DOrbitalNode";
+var Avl3DCrossWire = ({
+  from,
+  to,
+  eventName,
+  color
+}) => {
+  const palette = useAvl3DPalette();
+  const { tubeArgs, midpoint } = useMemo(() => {
+    const curve = arcCurve3D(from, to, 2);
+    const mid = curve.getPoint(0.5);
+    return {
+      tubeArgs: [curve, 32, 0.03, 8, false],
+      midpoint: [mid.x, mid.y, mid.z]
+    };
+  }, [from, to]);
+  if (!palette) return null;
+  const wireColor = color ?? palette.crossWire;
+  return /* @__PURE__ */ jsxs("group", { children: [
+    /* @__PURE__ */ jsxs("mesh", { children: [
+      /* @__PURE__ */ jsx("tubeGeometry", { args: [tubeArgs[0], tubeArgs[1], tubeArgs[2], tubeArgs[3], tubeArgs[4]] }),
+      /* @__PURE__ */ jsx(
+        "meshStandardMaterial",
+        {
+          color: wireColor,
+          emissive: wireColor,
+          emissiveIntensity: 0.4,
+          transparent: true,
+          opacity: 0.6,
+          roughness: 0.5
+        }
+      )
+    ] }),
+    /* @__PURE__ */ jsx(
+      Avl3DLabel,
+      {
+        position: midpoint,
+        text: eventName,
+        color: wireColor,
+        fontSize: 9
+      }
+    )
+  ] });
+};
+Avl3DCrossWire.displayName = "Avl3DCrossWire";
+function fieldPositions(count, radius) {
+  const positions = [];
+  const goldenAngle = Math.PI * (3 - Math.sqrt(5));
+  for (let i = 0; i < Math.min(count, 12); i++) {
+    const y = 1 - 2 * i / Math.max(count - 1, 1);
+    const r = Math.sqrt(1 - y * y);
+    const theta = goldenAngle * i;
+    positions.push([
+      radius * r * Math.cos(theta),
+      radius * y,
+      radius * r * Math.sin(theta)
+    ]);
+  }
+  return positions;
+}
+var Avl3DEntityCore = ({
+  name,
+  fieldCount,
+  persistence,
+  position,
+  fields
+}) => {
+  const coreRef = useRef(null);
+  const palette = useAvl3DPalette();
+  const { t } = useTranslate();
+  useFrame((_, delta) => {
+    if (!coreRef.current) return;
+    coreRef.current.rotation.y += delta * 0.3;
+    coreRef.current.rotation.x += delta * 0.1;
+  });
+  if (!palette) return null;
+  const fieldPos = fieldPositions(fieldCount, 1.4);
+  const pColor = palette[persistencePaletteKey(persistence)];
+  return /* @__PURE__ */ jsxs("group", { position, children: [
+    /* @__PURE__ */ jsxs("mesh", { ref: coreRef, children: [
+      /* @__PURE__ */ jsx("icosahedronGeometry", { args: [1, 2] }),
+      /* @__PURE__ */ jsx(
+        "meshStandardMaterial",
+        {
+          color: palette.entityCore,
+          emissive: palette.entityCoreGlow,
+          emissiveIntensity: 2,
+          roughness: 0.15,
+          metalness: 0.85
+        }
+      )
+    ] }),
+    /* @__PURE__ */ jsxs("mesh", { scale: 1.2, children: [
+      /* @__PURE__ */ jsx("sphereGeometry", { args: [1, 24, 24] }),
+      /* @__PURE__ */ jsx(
+        "meshStandardMaterial",
+        {
+          color: palette.entityCoreGlow,
+          emissive: palette.entityCoreGlow,
+          emissiveIntensity: 0.6,
+          transparent: true,
+          opacity: 0.1,
+          depthWrite: false
+        }
+      )
+    ] }),
+    /* @__PURE__ */ jsxs("mesh", { scale: 1.6, children: [
+      /* @__PURE__ */ jsx("sphereGeometry", { args: [1, 16, 16] }),
+      /* @__PURE__ */ jsx(
+        "meshStandardMaterial",
+        {
+          color: palette.entityCore,
+          emissive: palette.entityCore,
+          emissiveIntensity: 0.2,
+          transparent: true,
+          opacity: 0.04,
+          depthWrite: false
+        }
+      )
+    ] }),
+    /* @__PURE__ */ jsx(
+      "pointLight",
+      {
+        color: palette.entityCoreGlow,
+        intensity: 2.5,
+        distance: 10,
+        decay: 2
+      }
+    ),
+    fieldPos.map((pos, i) => {
+      const fieldType = fields?.[i];
+      return /* @__PURE__ */ jsxs("mesh", { position: pos, scale: 0.08, rotation: [Math.PI / 6, Math.PI / 4, 0], children: [
+        fieldType === "number" ? /* @__PURE__ */ jsx("tetrahedronGeometry", { args: [1, 0] }) : fieldType === "boolean" ? /* @__PURE__ */ jsx("boxGeometry", { args: [1.2, 1.2, 1.2] }) : fieldType === "date" ? /* @__PURE__ */ jsx("octahedronGeometry", { args: [1, 0] }) : fieldType === "enum" ? /* @__PURE__ */ jsx("torusGeometry", { args: [0.8, 0.3, 6, 12] }) : fieldType === "object" ? /* @__PURE__ */ jsx("dodecahedronGeometry", { args: [1, 0] }) : fieldType === "array" ? /* @__PURE__ */ jsx("cylinderGeometry", { args: [0.8, 0.8, 1.5, 6] }) : (
+          // string (default): sphere
+          /* @__PURE__ */ jsx("sphereGeometry", { args: [1, 8, 8] })
+        ),
+        /* @__PURE__ */ jsx(
+          "meshStandardMaterial",
+          {
+            color: palette.fieldParticle,
+            emissive: palette.fieldParticle,
+            emissiveIntensity: 0.8,
+            transparent: true,
+            opacity: 0.7
+          }
+        )
+      ] }, i);
+    }),
+    persistence === "singleton" ? (
+      // Singleton: double concentric rings (thick outer + thin inner)
+      /* @__PURE__ */ jsxs(Fragment, { children: [
+        /* @__PURE__ */ jsxs("mesh", { rotation: [Math.PI / 2, 0, 0], children: [
+          /* @__PURE__ */ jsx("torusGeometry", { args: [1.6, 0.04, 8, 64] }),
+          /* @__PURE__ */ jsx("meshStandardMaterial", { color: pColor, emissive: pColor, emissiveIntensity: 0.6, transparent: true, opacity: 0.6 })
+        ] }),
+        /* @__PURE__ */ jsxs("mesh", { rotation: [Math.PI / 2, 0, 0], children: [
+          /* @__PURE__ */ jsx("torusGeometry", { args: [1.4, 0.02, 8, 64] }),
+          /* @__PURE__ */ jsx("meshStandardMaterial", { color: pColor, emissive: pColor, emissiveIntensity: 0.4, transparent: true, opacity: 0.4 })
+        ] })
+      ] })
+    ) : persistence === "runtime" ? (
+      // Runtime: segmented ring (8 arc segments with gaps)
+      /* @__PURE__ */ jsx(Fragment, { children: Array.from({ length: 8 }).map((_, i) => {
+        const angle = i / 8 * Math.PI * 2;
+        const x = 1.6 * Math.cos(angle);
+        const z = 1.6 * Math.sin(angle);
+        return /* @__PURE__ */ jsxs("mesh", { position: [x, 0, z], rotation: [Math.PI / 2, 0, angle], children: [
+          /* @__PURE__ */ jsx("torusGeometry", { args: [0.25, 0.025, 6, 12, Math.PI * 0.7] }),
+          /* @__PURE__ */ jsx("meshStandardMaterial", { color: pColor, emissive: pColor, emissiveIntensity: 0.6, transparent: true, opacity: 0.6 })
+        ] }, i);
+      }) })
+    ) : persistence === "instance" ? (
+      // Instance: dotted ring (small spheres in a circle)
+      /* @__PURE__ */ jsx(Fragment, { children: Array.from({ length: 16 }).map((_, i) => {
+        const angle = i / 16 * Math.PI * 2;
+        const x = 1.6 * Math.cos(angle);
+        const z = 1.6 * Math.sin(angle);
+        return /* @__PURE__ */ jsxs("mesh", { position: [x, 0, z], scale: 0.04, children: [
+          /* @__PURE__ */ jsx("sphereGeometry", { args: [1, 6, 6] }),
+          /* @__PURE__ */ jsx("meshStandardMaterial", { color: pColor, emissive: pColor, emissiveIntensity: 0.8 })
+        ] }, i);
+      }) })
+    ) : (
+      // Persistent (default): solid torus ring
+      /* @__PURE__ */ jsxs("mesh", { rotation: [Math.PI / 2, 0, 0], children: [
+        /* @__PURE__ */ jsx("torusGeometry", { args: [1.6, 0.03, 8, 64] }),
+        /* @__PURE__ */ jsx("meshStandardMaterial", { color: pColor, emissive: pColor, emissiveIntensity: 0.6, transparent: true, opacity: 0.6 })
+      ] })
+    ),
+    /* @__PURE__ */ jsx(
+      Avl3DLabel,
+      {
+        position: [0, -1.8, 0],
+        text: name,
+        color: AVL_3D_COLORS.entityCore,
+        fontSize: 14
+      }
+    ),
+    /* @__PURE__ */ jsx(
+      Avl3DLabel,
+      {
+        position: [0, -2.3, 0],
+        text: t(fieldCount === 1 ? "avl3d.fieldCountOne" : "avl3d.fieldCountOther", { count: fieldCount }),
+        color: AVL_INK.quiet,
+        fontSize: 10
+      }
+    )
+  ] });
+};
+Avl3DEntityCore.displayName = "Avl3DEntityCore";
+var Avl3DStateNode = ({
+  name,
+  isInitial = false,
+  isTerminal = false,
+  position,
+  active = false,
+  incomingCount = 0,
+  outgoingCount = 0,
+  onClick
+}) => {
+  const [hovered, setHovered] = useState(false);
+  const palette = useAvl3DPalette();
+  const { t } = useTranslate();
+  const targetScale = hovered ? 1.08 : 1;
+  const currentScale = useRef(1);
+  useFrame((_, delta) => {
+    currentScale.current = MathUtils.damp(currentScale.current, targetScale, 6, delta);
+  });
+  const scale = currentScale.current;
+  if (!palette) return null;
+  const baseColor = active ? palette.stateActive : palette.stateIdle;
+  const emissiveColor = active ? palette.stateActive : palette.stateEdge;
+  const emissiveIntensity = active ? 2 : hovered ? 0.8 : 0.3;
+  return /* @__PURE__ */ jsxs("group", { position, children: [
+    /* @__PURE__ */ jsxs("mesh", { scale: scale * 1.4, children: [
+      /* @__PURE__ */ jsx("boxGeometry", { args: [1.2, 0.7, 0.5] }),
+      /* @__PURE__ */ jsx(
+        "meshStandardMaterial",
+        {
+          color: emissiveColor,
+          emissive: emissiveColor,
+          emissiveIntensity: active ? 0.3 : hovered ? 0.1 : 0.03,
+          transparent: true,
+          opacity: active ? 0.08 : 0.03,
+          depthWrite: false
+        }
+      )
+    ] }),
+    /* @__PURE__ */ jsx(
+      RoundedBox,
+      {
+        args: [1, 0.55, 0.35],
+        radius: 0.12,
+        smoothness: 4,
+        scale,
+        onClick: (e) => {
+          e.stopPropagation();
+          onClick?.();
+        },
+        onPointerOver: (e) => {
+          e.stopPropagation();
+          setHovered(true);
+          document.body.style.cursor = "pointer";
+        },
+        onPointerOut: () => {
+          setHovered(false);
+          document.body.style.cursor = "auto";
+        },
+        children: /* @__PURE__ */ jsx(
+          "meshStandardMaterial",
+          {
+            color: baseColor,
+            emissive: emissiveColor,
+            emissiveIntensity,
+            roughness: 0.35,
+            metalness: 0.5
+          }
+        )
+      }
+    ),
+    isInitial && /* @__PURE__ */ jsxs("group", { position: [-0.75, 0, 0], children: [
+      /* @__PURE__ */ jsxs("mesh", { rotation: [0, 0, -Math.PI / 2], children: [
+        /* @__PURE__ */ jsx("coneGeometry", { args: [0.12, 0.25, 8] }),
+        /* @__PURE__ */ jsx(
+          "meshStandardMaterial",
+          {
+            color: palette.stateActive,
+            emissive: palette.stateActive,
+            emissiveIntensity: 1
+          }
+        )
+      ] }),
+      /* @__PURE__ */ jsxs("mesh", { position: [-0.2, 0, 0], rotation: [0, 0, Math.PI / 2], children: [
+        /* @__PURE__ */ jsx("cylinderGeometry", { args: [0.02, 0.02, 0.25, 6] }),
+        /* @__PURE__ */ jsx(
+          "meshStandardMaterial",
+          {
+            color: palette.stateActive,
+            emissive: palette.stateActive,
+            emissiveIntensity: 0.6
+          }
+        )
+      ] })
+    ] }),
+    isTerminal && /* @__PURE__ */ jsxs("group", { position: [0.75, 0, 0], children: [
+      /* @__PURE__ */ jsxs("mesh", { scale: 0.15, children: [
+        /* @__PURE__ */ jsx("octahedronGeometry", { args: [1, 0] }),
+        /* @__PURE__ */ jsx(
+          "meshStandardMaterial",
+          {
+            color: palette.guardFail,
+            emissive: palette.guardFail,
+            emissiveIntensity: 1
+          }
+        )
+      ] }),
+      /* @__PURE__ */ jsxs("mesh", { rotation: [Math.PI / 2, 0, 0], children: [
+        /* @__PURE__ */ jsx("torusGeometry", { args: [0.2, 0.015, 8, 24] }),
+        /* @__PURE__ */ jsx(
+          "meshStandardMaterial",
+          {
+            color: palette.guardFail,
+            emissive: palette.guardFail,
+            emissiveIntensity: 0.5
+          }
+        )
+      ] })
+    ] }),
+    active && /* @__PURE__ */ jsx(
+      "pointLight",
+      {
+        color: palette.stateActive,
+        intensity: 1.5,
+        distance: 4,
+        decay: 2
+      }
+    ),
+    /* @__PURE__ */ jsx(
+      Avl3DLabel,
+      {
+        position: [0, -0.55, 0],
+        text: name,
+        color: active ? palette.stateActive : AVL_INK.text,
+        fontSize: 11
+      }
+    ),
+    hovered && /* @__PURE__ */ jsx(
+      Avl3DTooltip,
+      {
+        position: [0.9, 0.3, 0],
+        title: name,
+        accentColor: active ? AVL_3D_COLORS.stateActive : AVL_3D_COLORS.stateEdge,
+        rows: [
+          { label: t("avl3d.type"), value: isInitial ? t("avl3d.typeInitial") : isTerminal ? t("avl3d.typeTerminal") : t("avl3d.typeStandard") },
+          { label: t("avl3d.incoming"), value: String(incomingCount) },
+          { label: t("avl3d.outgoing"), value: String(outgoingCount) },
+          ...active ? [{ label: t("avl3d.status"), value: t("status.active") }] : []
+        ]
+      }
+    )
+  ] });
+};
+Avl3DStateNode.displayName = "Avl3DStateNode";
+var Avl3DTransitionArc = ({
+  from,
+  to,
+  event,
+  hasGuard = false,
+  effectTypes,
+  index,
+  isSelf = false,
+  fromState,
+  toState,
+  onClick,
+  color
+}) => {
+  const [hovered, setHovered] = useState(false);
+  const palette = useAvl3DPalette();
+  const { t } = useTranslate();
+  const { tubeArgs, labelPos, guardPos, arrowPos, arrowQuat, effectPositions } = useMemo(() => {
+    const offset = 1.5 + index * 0.8;
+    const curve = isSelf ? selfLoopCurve3D(from, 1.2) : arcCurve3D(from, to, offset);
+    const mid = curve.getPoint(0.5);
+    const guardPt = curve.getPoint(0.3);
+    const arrowPt = curve.getPoint(0.9);
+    const arrowTangent = curve.getTangent(0.9);
+    const upVec = new Vector3(0, 1, 0);
+    const tangentVec = new Vector3(arrowTangent.x, arrowTangent.y, arrowTangent.z).normalize();
+    const quat = new Quaternion().setFromUnitVectors(upVec, tangentVec);
+    const effectPositions2 = [];
+    for (let ei = 0; ei < 4; ei++) {
+      const t2 = 0.7 + ei * 0.05;
+      const ep = curve.getPoint(t2);
+      effectPositions2.push([ep.x, ep.y + 0.2, ep.z]);
+    }
+    return {
+      tubeArgs: [curve, 48, 0.02, 8, false],
+      labelPos: [mid.x, mid.y + 0.3, mid.z],
+      guardPos: [guardPt.x, guardPt.y, guardPt.z],
+      arrowPos: [arrowPt.x, arrowPt.y, arrowPt.z],
+      arrowQuat: [quat.x, quat.y, quat.z, quat.w],
+      effectPositions: effectPositions2
+    };
+  }, [from, to, index, isSelf]);
+  const emissiveIntensity = hovered ? 0.8 : 0.4;
+  if (!palette) return null;
+  const arcColor = color ?? palette.transitionArc;
+  return /* @__PURE__ */ jsxs("group", { children: [
+    /* @__PURE__ */ jsxs(
+      "mesh",
+      {
+        onClick: (e) => {
+          e.stopPropagation();
+          onClick?.();
+        },
+        onPointerOver: (e) => {
+          e.stopPropagation();
+          setHovered(true);
+          document.body.style.cursor = "pointer";
+        },
+        onPointerOut: () => {
+          setHovered(false);
+          document.body.style.cursor = "auto";
+        },
+        children: [
+          /* @__PURE__ */ jsx("tubeGeometry", { args: [tubeArgs[0], tubeArgs[1], tubeArgs[2], tubeArgs[3], tubeArgs[4]] }),
+          /* @__PURE__ */ jsx(
+            "meshStandardMaterial",
+            {
+              color: arcColor,
+              emissive: arcColor,
+              emissiveIntensity,
+              transparent: true,
+              opacity: hovered ? 0.9 : 0.7
+            }
+          )
+        ]
+      }
+    ),
+    hasGuard && /* @__PURE__ */ jsxs("mesh", { position: guardPos, scale: 0.15, children: [
+      /* @__PURE__ */ jsx("octahedronGeometry", { args: [1, 0] }),
+      /* @__PURE__ */ jsx(
+        "meshStandardMaterial",
+        {
+          color: palette.guardPass,
+          emissive: palette.guardPass,
+          emissiveIntensity: 0.8
+        }
+      )
+    ] }),
+    /* @__PURE__ */ jsxs(
+      "mesh",
+      {
+        position: arrowPos,
+        quaternion: arrowQuat,
+        scale: 0.08,
+        children: [
+          /* @__PURE__ */ jsx("coneGeometry", { args: [1, 2, 8] }),
+          /* @__PURE__ */ jsx(
+            "meshStandardMaterial",
+            {
+              color: arcColor,
+              emissive: arcColor,
+              emissiveIntensity: 0.6
+            }
+          )
+        ]
+      }
+    ),
+    /* @__PURE__ */ jsx(
+      Avl3DLabel,
+      {
+        position: labelPos,
+        text: event,
+        color: hovered ? AVL_INK.text : arcColor,
+        fontSize: hovered ? 11 : 9
+      }
+    ),
+    hovered && /* @__PURE__ */ jsx(
+      Avl3DTooltip,
+      {
+        position: [labelPos[0], labelPos[1] + 0.6, labelPos[2]],
+        title: event,
+        accentColor: arcColor,
+        rows: [
+          ...fromState && toState ? [{ label: t("avl.transition"), value: `${fromState} \u2192 ${toState}` }] : [],
+          ...hasGuard ? [{ label: t("avl.guard"), value: t("common.yes") }] : [],
+          ...effectTypes && effectTypes.length > 0 ? [{ label: t("avl.effects"), value: effectTypes.slice(0, 3).join(", ") + (effectTypes.length > 3 ? ` +${effectTypes.length - 3}` : "") }] : []
+        ]
+      }
+    ),
+    effectTypes && effectTypes.length > 0 && effectTypes.slice(0, 4).map((effectType, ei) => {
+      const pt = effectPositions[ei];
+      if (!pt) return null;
+      const eColor = palette[effectTypePaletteKey(effectType)];
+      return /* @__PURE__ */ jsx("group", { position: pt, children: /* @__PURE__ */ jsxs("mesh", { scale: 0.06, children: [
+        effectType === "render-ui" ? /* @__PURE__ */ jsx("boxGeometry", { args: [1.5, 1.5, 0.3] }) : effectType === "persist" ? /* @__PURE__ */ jsx("cylinderGeometry", { args: [0.6, 0.6, 1.5, 8] }) : effectType === "emit" ? /* @__PURE__ */ jsx("sphereGeometry", { args: [1, 8, 8] }) : effectType === "navigate" ? /* @__PURE__ */ jsx("coneGeometry", { args: [0.8, 1.5, 6] }) : effectType === "set" ? /* @__PURE__ */ jsx("tetrahedronGeometry", { args: [1, 0] }) : effectType === "call-service" ? /* @__PURE__ */ jsx("torusGeometry", { args: [0.8, 0.3, 6, 12] }) : /* @__PURE__ */ jsx("octahedronGeometry", { args: [0.8, 0] }),
+        /* @__PURE__ */ jsx(
+          "meshStandardMaterial",
+          {
+            color: eColor,
+            emissive: eColor,
+            emissiveIntensity: 0.8
+          }
+        )
+      ] }) }, ei);
+    })
+  ] });
+};
+Avl3DTransitionArc.displayName = "Avl3DTransitionArc";
+function edgeGeometry(parent, child) {
+  const p = new Vector3(parent.x, parent.y, parent.z);
+  const c = new Vector3(child.x, child.y, child.z);
+  const mid = new Vector3().addVectors(p, c).multiplyScalar(0.5);
+  const dir = new Vector3().subVectors(c, p);
+  const length = dir.length();
+  const yAxis = new Vector3(0, 1, 0);
+  const angle = yAxis.angleTo(dir.normalize());
+  const axis = new Vector3().crossVectors(yAxis, dir).normalize();
+  if (axis.length() < 1e-3) {
+    return {
+      position: [mid.x, mid.y, mid.z],
+      rotation: [0, 0, 0],
+      length
+    };
+  }
+  return {
+    position: [mid.x, mid.y, mid.z],
+    rotation: [
+      axis.x * angle,
+      axis.y * angle,
+      axis.z * angle
+    ],
+    length
+  };
+}
+var Avl3DExprTree = ({
+  expression,
+  position
+}) => {
+  const layoutResults = useMemo(() => {
+    const origin = { x: position[0], y: position[1], z: position[2] };
+    return treeLayout3D(expression, origin, 2.5, 1.5);
+  }, [expression, position]);
+  const edges = useMemo(() => {
+    const result = [];
+    function collectEdges(node, parentPos) {
+      const entry = layoutResults.find((r) => r.node === node);
+      if (!entry) return;
+      if (parentPos) {
+        result.push({
+          parent: parentPos,
+          child: entry.position,
+          key: `${parentPos.x}-${parentPos.y}-${entry.position.x}-${entry.position.y}`
+        });
+      }
+      if (node.children) {
+        for (const child of node.children) {
+          collectEdges(child, entry.position);
+        }
+      }
+    }
+    collectEdges(expression, null);
+    return result;
+  }, [expression, layoutResults]);
+  const palette = useAvl3DPalette();
+  if (!palette) return null;
+  return /* @__PURE__ */ jsxs("group", { children: [
+    edges.map((edge) => {
+      const geo = edgeGeometry(edge.parent, edge.child);
+      return /* @__PURE__ */ jsxs(
+        "mesh",
+        {
+          position: geo.position,
+          rotation: geo.rotation,
+          children: [
+            /* @__PURE__ */ jsx("cylinderGeometry", { args: [0.015, 0.015, geo.length, 6] }),
+            /* @__PURE__ */ jsx(
+              "meshStandardMaterial",
+              {
+                color: palette.transitionArc,
+                transparent: true,
+                opacity: 0.5
+              }
+            )
+          ]
+        },
+        edge.key
+      );
+    }),
+    layoutResults.map((entry, i) => {
+      const pos = [
+        entry.position.x,
+        entry.position.y,
+        entry.position.z
+      ];
+      if (entry.node.type === "operator") {
+        const opColor = palette[exprOperatorPaletteKey(entry.node.label)];
+        return /* @__PURE__ */ jsxs("group", { position: pos, children: [
+          /* @__PURE__ */ jsxs("mesh", { children: [
+            /* @__PURE__ */ jsx("boxGeometry", { args: [0.6, 0.4, 0.3] }),
+            /* @__PURE__ */ jsx(
+              "meshStandardMaterial",
+              {
+                color: opColor,
+                emissive: opColor,
+                emissiveIntensity: 0.4,
+                roughness: 0.3
+              }
+            )
+          ] }),
+          /* @__PURE__ */ jsx(
+            Avl3DLabel,
+            {
+              position: [0, -0.4, 0],
+              text: entry.node.label,
+              color: opColor,
+              fontSize: 10
+            }
+          )
+        ] }, i);
+      }
+      if (entry.node.type === "binding") {
+        return /* @__PURE__ */ jsxs("group", { position: pos, children: [
+          /* @__PURE__ */ jsxs("mesh", { scale: 0.08, children: [
+            /* @__PURE__ */ jsx("torusKnotGeometry", { args: [2, 0.6, 48, 8, 2, 3] }),
+            /* @__PURE__ */ jsx(
+              "meshStandardMaterial",
+              {
+                color: palette.exprBinding,
+                emissive: palette.exprBinding,
+                emissiveIntensity: 0.4,
+                transparent: true,
+                opacity: 0.85,
+                roughness: 0.3
+              }
+            )
+          ] }),
+          /* @__PURE__ */ jsx(
+            Avl3DLabel,
+            {
+              position: [0, -0.35, 0],
+              text: entry.node.label,
+              color: palette.exprBinding,
+              fontSize: 9
+            }
+          )
+        ] }, i);
+      }
+      return /* @__PURE__ */ jsxs("group", { position: pos, children: [
+        /* @__PURE__ */ jsxs("mesh", { rotation: [Math.PI / 6, Math.PI / 4, 0], children: [
+          /* @__PURE__ */ jsx("boxGeometry", { args: [0.2, 0.2, 0.2] }),
+          /* @__PURE__ */ jsx(
+            "meshStandardMaterial",
+            {
+              color: palette.exprLiteral,
+              emissive: palette.exprLiteral,
+              emissiveIntensity: 0.2,
+              roughness: 0.5
+            }
+          )
+        ] }),
+        /* @__PURE__ */ jsx(
+          Avl3DLabel,
+          {
+            position: [0, -0.3, 0],
+            text: entry.node.label,
+            color: palette.exprLiteral,
+            fontSize: 8
+          }
+        )
+      ] }, i);
+    })
+  ] });
+};
+Avl3DExprTree.displayName = "Avl3DExprTree";
+
+export { AVL_3D_COLORS, Avl3DCrossWire, Avl3DEntityCore, Avl3DExprTree, Avl3DLabel, Avl3DOrbitalNode, Avl3DStateNode, Avl3DTooltip, Avl3DTransitionArc, CAMERA_POSITIONS, arcCurve3D, fibonacciSpherePositions, forceDirectedPositions, getBreadcrumbs, goldenSpiralPositions, initialZoomState, orbitRingPositions, selfLoopCurve3D, treeLayout3D, zoomReducer };