@project-skymap/library 0.0.0

package/dist/index.cjs

@@ -0,0 +1,1003 @@
+'use strict';
+
+var THREE4 = require('three');
+var OrbitControls = require('three/examples/jsm/controls/OrbitControls');
+var react = require('react');
+var jsxRuntime = require('react/jsx-runtime');
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var THREE4__namespace = /*#__PURE__*/_interopNamespace(THREE4);
+
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+function layoutSpiral(count, radius) {
+  const points = [];
+  const goldenAngle = Math.PI * (3 - Math.sqrt(5));
+  for (let i = 0; i < count; i++) {
+    const r = radius * Math.sqrt((i + 1) / count);
+    const theta = i * goldenAngle;
+    const x = r * Math.cos(theta);
+    const z = r * Math.sin(theta);
+    const y = (Math.random() - 0.5) * (radius * 0.1);
+    points.push({ x, y, z });
+  }
+  return points;
+}
+function layoutCross(count, radius) {
+  const points = [];
+  const verticalCount = Math.ceil(count * 0.7);
+  const horizontalCount = count - verticalCount;
+  const height = radius * 2.5;
+  const width = radius * 1.5;
+  for (let i = 0; i < verticalCount; i++) {
+    const t = i / (verticalCount - 1 || 1);
+    const y = height / 2 - t * height;
+    points.push({ x: 0, y, z: 0 });
+  }
+  const crossY = height / 2 - height * 0.3;
+  for (let i = 0; i < horizontalCount; i++) {
+    const t = i / (horizontalCount - 1 || 1);
+    const x = -width / 2 + t * width;
+    points.push({ x, y: crossY, z: 0 });
+  }
+  return points;
+}
+function layoutTablet(count, radius) {
+  const points = [];
+  const cols = 2;
+  const rows = Math.ceil(count / cols);
+  const w = radius * 1.5;
+  const h = radius * 2;
+  for (let i = 0; i < count; i++) {
+    const col = i % cols;
+    const row = Math.floor(i / cols);
+    const x = (col === 0 ? -1 : 1) * (w * 0.25);
+    const y = h / 2 - row / (rows - 1 || 1) * h;
+    points.push({ x, y, z: 0 });
+  }
+  return points;
+}
+function layoutCrown(count, radius) {
+  const points = [];
+  for (let i = 0; i < count; i++) {
+    const t = i / (count - 1 || 1);
+    const angle = -Math.PI * 0.8 + t * Math.PI * 1.6;
+    let r = radius;
+    if (i % 3 === 1) r *= 1.4;
+    const x = r * Math.sin(angle);
+    const y = r * Math.cos(angle) * 0.5;
+    points.push({ x, y, z: 0 });
+  }
+  return points;
+}
+function layoutHarp(count, radius) {
+  const points = [];
+  for (let i = 0; i < count; i++) {
+    const t = i / (count - 1 || 1);
+    const x = -radius + t * (radius * 2);
+    const y = -radius + Math.pow(t, 2) * (radius * 2);
+    points.push({ x, y, z: 0 });
+  }
+  return points;
+}
+function layoutFlame(count, radius) {
+  const points = [];
+  for (let i = 0; i < count; i++) {
+    const tNorm = i / count;
+    const r = radius * (1 - tNorm) * 0.8;
+    const angle = tNorm * Math.PI * 4;
+    const y = (tNorm - 0.5) * radius * 3;
+    const x = r * Math.cos(angle);
+    points.push({ x, y, z: 0 });
+  }
+  return points;
+}
+function getConstellationLayout(bookKey, chapterCount, radius) {
+  const generator = LAYOUT_REGISTRY[bookKey] || layoutSpiral;
+  return generator(chapterCount, radius);
+}
+var LAYOUT_REGISTRY;
+var init_constellations = __esm({
+  "src/engine/constellations.ts"() {
+    LAYOUT_REGISTRY = {
+      // Law -> Tablet
+      "GEN": layoutTablet,
+      "EXO": layoutTablet,
+      "LEV": layoutTablet,
+      "NUM": layoutTablet,
+      "DEU": layoutTablet,
+      // Kings/History -> Crown
+      "1SA": layoutCrown,
+      "2SA": layoutCrown,
+      "1KI": layoutCrown,
+      "2KI": layoutCrown,
+      "1CH": layoutCrown,
+      "2CH": layoutCrown,
+      // Poetry -> Harp/Spiral
+      "PSA": layoutHarp,
+      "SNG": layoutHarp,
+      // Gospels -> Cross
+      "MAT": layoutCross,
+      "MRK": layoutCross,
+      "LUK": layoutCross,
+      "JHN": layoutCross,
+      // Acts -> Flame
+      "ACT": layoutFlame
+    };
+  }
+});
+function lookAt(point, target, up) {
+  const zAxis = target.clone().normalize();
+  const xAxis = new THREE4__namespace.Vector3().crossVectors(up, zAxis).normalize();
+  const yAxis = new THREE4__namespace.Vector3().crossVectors(zAxis, xAxis).normalize();
+  const m = new THREE4__namespace.Matrix4().makeBasis(xAxis, yAxis, zAxis);
+  const v = new THREE4__namespace.Vector3(point.x, point.y, point.z);
+  v.applyMatrix4(m);
+  v.add(target);
+  return { x: v.x, y: v.y, z: v.z };
+}
+function computeLayoutPositions(model, layout) {
+  const mode = layout?.mode ?? "spherical";
+  const radius = layout?.radius ?? 2e3;
+  const ringSpacing = layout?.chapterRingSpacing ?? 15;
+  const childrenMap = /* @__PURE__ */ new Map();
+  const roots = [];
+  const books = [];
+  for (const n of model.nodes) {
+    if (n.level === 2) books.push(n);
+    if (n.parent) {
+      const children = childrenMap.get(n.parent) ?? [];
+      children.push(n);
+      childrenMap.set(n.parent, children);
+    } else {
+      roots.push(n);
+    }
+  }
+  const updatedNodes = model.nodes.map((n) => ({ ...n, meta: { ...n.meta ?? {} } }));
+  const updatedNodeMap = new Map(updatedNodes.map((n) => [n.id, n]));
+  const leafCounts = /* @__PURE__ */ new Map();
+  function getLeafCount(node) {
+    const children = childrenMap.get(node.id) ?? [];
+    if (children.length === 0) {
+      leafCounts.set(node.id, 1);
+      return 1;
+    }
+    let count = 0;
+    for (const c of children) count += getLeafCount(c);
+    leafCounts.set(node.id, count);
+    return count;
+  }
+  roots.forEach(getLeafCount);
+  if (mode === "spherical") {
+    const numBooks = books.length;
+    const phi = Math.PI * (3 - Math.sqrt(5));
+    for (let i = 0; i < numBooks; i++) {
+      const book = books[i];
+      const uBook = updatedNodeMap.get(book.id);
+      const bookKey = uBook.meta.bookKey;
+      const y = 1 - i / (numBooks - 1) * 0.95;
+      const radiusAtY = Math.sqrt(1 - y * y);
+      const theta = phi * i;
+      const x = Math.cos(theta) * radiusAtY;
+      const z = Math.sin(theta) * radiusAtY;
+      const bookPos = new THREE4__namespace.Vector3(x, y, z).multiplyScalar(radius);
+      uBook.meta.x = bookPos.x;
+      uBook.meta.y = bookPos.y;
+      uBook.meta.z = bookPos.z;
+      const chapters = childrenMap.get(book.id) ?? [];
+      if (chapters.length > 0) {
+        const territoryRadius = radius * 2 / Math.sqrt(numBooks * 2) * 0.7;
+        const localPoints = getConstellationLayout(bookKey, chapters.length, territoryRadius);
+        const up = new THREE4__namespace.Vector3(0, 1, 0);
+        chapters.forEach((chap, idx) => {
+          const uChap = updatedNodeMap.get(chap.id);
+          const lp = localPoints[idx];
+          const wp = lookAt(lp, bookPos, up);
+          uChap.meta.x = wp.x;
+          uChap.meta.y = wp.y;
+          uChap.meta.z = wp.z;
+        });
+      }
+    }
+    const divisions = model.nodes.filter((n) => n.level === 1);
+    divisions.forEach((d) => {
+      const children = childrenMap.get(d.id) ?? [];
+      if (children.length === 0) return;
+      const centroid = new THREE4__namespace.Vector3();
+      children.forEach((c) => {
+        const u = updatedNodeMap.get(c.id);
+        centroid.add(new THREE4__namespace.Vector3(u.meta.x, u.meta.y, u.meta.z));
+      });
+      centroid.divideScalar(children.length);
+      if (centroid.length() > 0.1) {
+        centroid.setLength(radius * 0.85);
+        const uNode = updatedNodeMap.get(d.id);
+        uNode.meta.x = centroid.x;
+        uNode.meta.y = centroid.y;
+        uNode.meta.z = centroid.z;
+      }
+    });
+    const testaments = model.nodes.filter((n) => n.level === 0);
+    testaments.forEach((t) => {
+      const children = childrenMap.get(t.id) ?? [];
+      if (children.length === 0) return;
+      const centroid = new THREE4__namespace.Vector3();
+      children.forEach((c) => {
+        const u = updatedNodeMap.get(c.id);
+        centroid.add(new THREE4__namespace.Vector3(u.meta.x, u.meta.y, u.meta.z));
+      });
+      centroid.divideScalar(children.length);
+      if (centroid.length() > 0.1) {
+        centroid.setLength(radius * 0.75);
+        const uNode = updatedNodeMap.get(t.id);
+        uNode.meta.x = centroid.x;
+        uNode.meta.y = centroid.y;
+        uNode.meta.z = centroid.z;
+      }
+    });
+    return { ...model, nodes: updatedNodes };
+  }
+  function layoutRadial(nodes, startAngle, totalAngle, level) {
+    if (nodes.length === 0) return;
+    nodes.sort((a, b) => a.id.localeCompare(b.id));
+    const totalLeaves = nodes.reduce((sum, n) => sum + (leafCounts.get(n.id) ?? 1), 0);
+    let currentAngle = startAngle;
+    const currentRadius = level === 0 ? 0 : radius + (level - 1) * ringSpacing;
+    for (const node of nodes) {
+      const weight = leafCounts.get(node.id) ?? 1;
+      const nodeAngleSpan = weight / totalLeaves * totalAngle;
+      const midAngle = currentAngle + nodeAngleSpan / 2;
+      const updatedNode = updatedNodeMap.get(node.id);
+      const r = level === 0 ? 0 : currentRadius;
+      updatedNode.meta.x = Math.cos(midAngle) * r;
+      updatedNode.meta.y = Math.sin(midAngle) * r;
+      updatedNode.meta.z = 0;
+      updatedNode.meta.angle = midAngle;
+      const children = childrenMap.get(node.id) ?? [];
+      if (children.length > 0) {
+        layoutRadial(children, currentAngle, nodeAngleSpan, level + 1);
+      }
+      currentAngle += nodeAngleSpan;
+    }
+  }
+  layoutRadial(roots, 0, Math.PI * 2, 0);
+  return { ...model, nodes: updatedNodes };
+}
+var init_layout = __esm({
+  "src/engine/layout.ts"() {
+    init_constellations();
+  }
+});
+function matches(node, when) {
+  for (const [k, v] of Object.entries(when)) {
+    const val = node[k] !== void 0 ? node[k] : node.meta?.[k];
+    if (val !== v) return false;
+  }
+  return true;
+}
+function applyVisuals({
+  model,
+  cfg,
+  meshById
+}) {
+  const colorRules = cfg.visuals?.colorBy ?? [];
+  const sizeRules = cfg.visuals?.sizeBy ?? [];
+  const weights = model.nodes.map((n) => n.weight).filter((x) => typeof x === "number");
+  const minW = weights.length ? Math.min(...weights) : 0;
+  const maxW = weights.length ? Math.max(...weights) : 1;
+  const range = Math.max(0, maxW - minW);
+  for (const node of model.nodes) {
+    const mesh = meshById.get(node.id);
+    if (!mesh) continue;
+    let color;
+    for (const rule of colorRules) {
+      if (matches(node, rule.when)) {
+        color = rule.value;
+        break;
+      }
+    }
+    if (color && mesh.material?.color) {
+      mesh.material.color = new THREE4__namespace.Color(color);
+    }
+    for (const rule of sizeRules) {
+      if (!matches(node, rule.when)) continue;
+      const w = node[rule.field];
+      if (typeof w !== "number") continue;
+      const t = range === 0 ? 0.5 : (w - minW) / range;
+      const clamped = Math.min(1, Math.max(0, t));
+      const s = rule.scale[0] + t * (rule.scale[1] - rule.scale[0]);
+      mesh.scale.setScalar(clamped === t ? s : rule.scale[0] + clamped * (rule.scale[1] - rule.scale[0]));
+      break;
+    }
+  }
+}
+var init_materials = __esm({
+  "src/engine/materials.ts"() {
+  }
+});
+
+// src/engine/createEngine.ts
+var createEngine_exports = {};
+__export(createEngine_exports, {
+  createEngine: () => createEngine
+});
+function createEngine({
+  container,
+  onSelect,
+  onHover
+}) {
+  const renderer = new THREE4__namespace.WebGLRenderer({ antialias: true });
+  renderer.setPixelRatio(Math.min(window.devicePixelRatio || 1, 2));
+  renderer.setClearColor(0, 1);
+  container.appendChild(renderer.domElement);
+  renderer.domElement.style.touchAction = "none";
+  const scene = new THREE4__namespace.Scene();
+  const camera = new THREE4__namespace.PerspectiveCamera(90, 1, 0.1, 5e3);
+  camera.position.set(0, 0, 0.01);
+  camera.up.set(0, 1, 0);
+  const controls = new OrbitControls.OrbitControls(camera, renderer.domElement);
+  controls.target.set(0, 0, 0);
+  controls.enableRotate = true;
+  controls.enablePan = false;
+  controls.enableZoom = false;
+  controls.enableDamping = true;
+  controls.dampingFactor = 0.07;
+  controls.screenSpacePanning = false;
+  const EPS = THREE4__namespace.MathUtils.degToRad(0.05);
+  controls.minAzimuthAngle = -Infinity;
+  controls.maxAzimuthAngle = Infinity;
+  controls.minPolarAngle = Math.PI / 2 + EPS;
+  controls.maxPolarAngle = Math.PI - EPS;
+  controls.update();
+  const env = {
+    skyRadius: 2800,
+    groundRadius: 995,
+    defaultFov: 90,
+    minFov: 1,
+    maxFov: 110,
+    fovWheelSensitivity: 0.04,
+    focusZoomFov: 18,
+    focusDurationMs: 650
+  };
+  const groundGroup = new THREE4__namespace.Group();
+  scene.add(groundGroup);
+  function buildGroundHemisphere(radius) {
+    groundGroup.clear();
+    const hemi = new THREE4__namespace.SphereGeometry(radius, 64, 32, 0, Math.PI * 2, Math.PI / 2, Math.PI);
+    hemi.scale(-1, 1, 1);
+    const count = hemi.attributes.position.count;
+    const colors = new Float32Array(count * 3);
+    const pos = hemi.attributes.position;
+    const c = new THREE4__namespace.Color();
+    for (let i = 0; i < count; i++) {
+      const y = pos.getY(i);
+      const t = THREE4__namespace.MathUtils.clamp(1 - Math.abs(y) / radius, 0, 1);
+      c.setRGB(
+        THREE4__namespace.MathUtils.lerp(6 / 255, 21 / 255, t),
+        THREE4__namespace.MathUtils.lerp(16 / 255, 35 / 255, t),
+        THREE4__namespace.MathUtils.lerp(23 / 255, 53 / 255, t)
+      );
+      colors.set([c.r, c.g, c.b], i * 3);
+    }
+    hemi.setAttribute("color", new THREE4__namespace.BufferAttribute(colors, 3));
+    const groundMat = new THREE4__namespace.MeshBasicMaterial({
+      vertexColors: true,
+      side: THREE4__namespace.FrontSide,
+      depthWrite: true,
+      // important: occlude stars under horizon
+      depthTest: true
+    });
+    const hemiMesh = new THREE4__namespace.Mesh(hemi, groundMat);
+    groundGroup.add(hemiMesh);
+    {
+      const inner = radius * 0.985;
+      const outer = radius * 1.005;
+      const ringGeo = new THREE4__namespace.RingGeometry(inner, outer, 128);
+      ringGeo.rotateX(-Math.PI / 2);
+      const ringMat = new THREE4__namespace.ShaderMaterial({
+        transparent: true,
+        depthWrite: false,
+        uniforms: {
+          uInner: { value: inner },
+          uOuter: { value: outer },
+          uColor: { value: new THREE4__namespace.Color(8037119) }
+        },
+        vertexShader: `
+          varying vec2 vXY;
+          void main() {
+            vXY = position.xz;
+            gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
+          }
+        `,
+        fragmentShader: `
+          uniform float uInner;
+          uniform float uOuter;
+          uniform vec3 uColor;
+          varying vec2 vXY;
+
+          void main() {
+            float r = length(vXY);
+            float t = clamp((r - uInner) / (uOuter - uInner), 0.0, 1.0);
+            // peak glow near inner edge, fade outwards
+            float a = pow(1.0 - t, 2.2) * 0.35;
+            gl_FragColor = vec4(uColor, a);
+          }
+        `
+      });
+      const ring = new THREE4__namespace.Mesh(ringGeo, ringMat);
+      ring.position.y = 0;
+      groundGroup.add(ring);
+    }
+  }
+  buildGroundHemisphere(env.groundRadius);
+  const backdropGroup = new THREE4__namespace.Group();
+  scene.add(backdropGroup);
+  function buildBackdropStars(radius, count) {
+    backdropGroup.clear();
+    const starGeo = new THREE4__namespace.BufferGeometry();
+    const starPos = new Float32Array(count * 3);
+    for (let i = 0; i < count; i++) {
+      const r = radius + Math.random() * (radius * 0.5);
+      const theta = Math.random() * Math.PI * 2;
+      const phi = Math.acos(2 * Math.random() - 1);
+      starPos[i * 3] = r * Math.sin(phi) * Math.cos(theta);
+      starPos[i * 3 + 1] = r * Math.sin(phi) * Math.sin(theta);
+      starPos[i * 3 + 2] = r * Math.cos(phi);
+    }
+    starGeo.setAttribute("position", new THREE4__namespace.BufferAttribute(starPos, 3));
+    const starMat = new THREE4__namespace.PointsMaterial({
+      color: 10135218,
+      size: 0.5,
+      transparent: true,
+      opacity: 0.55,
+      depthWrite: false
+    });
+    const stars = new THREE4__namespace.Points(starGeo, starMat);
+    backdropGroup.add(stars);
+  }
+  buildBackdropStars(env.skyRadius, 6500);
+  const raycaster = new THREE4__namespace.Raycaster();
+  const pointer = new THREE4__namespace.Vector2();
+  const root = new THREE4__namespace.Group();
+  scene.add(root);
+  let raf = 0;
+  let running = false;
+  let handlers = { onSelect, onHover };
+  let hoveredId = null;
+  let isDragging = false;
+  const nodeById = /* @__PURE__ */ new Map();
+  const meshById = /* @__PURE__ */ new Map();
+  const lineByBookId = /* @__PURE__ */ new Map();
+  const dynamicObjects = [];
+  function resize() {
+    const w = container.clientWidth || 1;
+    const h = container.clientHeight || 1;
+    renderer.setSize(w, h, false);
+    camera.aspect = w / h;
+    camera.updateProjectionMatrix();
+  }
+  function disposeObject(obj) {
+    obj.traverse((o) => {
+      if (o.geometry) o.geometry.dispose?.();
+      if (o.material) {
+        const mats = Array.isArray(o.material) ? o.material : [o.material];
+        mats.forEach((m) => {
+          if (m.map) m.map.dispose?.();
+          m.dispose?.();
+        });
+      }
+    });
+  }
+  function createTextSprite(text, color = "#ffffff") {
+    const canvas = document.createElement("canvas");
+    const ctx = canvas.getContext("2d");
+    if (!ctx) return null;
+    const fontSize = 48;
+    const font = `bold ${fontSize}px sans-serif`;
+    ctx.font = font;
+    const metrics = ctx.measureText(text);
+    const w = Math.ceil(metrics.width);
+    const h = Math.ceil(fontSize * 1.2);
+    canvas.width = w;
+    canvas.height = h;
+    ctx.font = font;
+    ctx.fillStyle = color;
+    ctx.textAlign = "center";
+    ctx.textBaseline = "middle";
+    ctx.fillText(text, w / 2, h / 2);
+    const tex = new THREE4__namespace.CanvasTexture(canvas);
+    tex.minFilter = THREE4__namespace.LinearFilter;
+    const mat = new THREE4__namespace.SpriteMaterial({
+      map: tex,
+      transparent: true,
+      depthWrite: false,
+      depthTest: true
+    });
+    const sprite = new THREE4__namespace.Sprite(mat);
+    const targetHeight = 2;
+    const aspect = w / h;
+    sprite.scale.set(targetHeight * aspect, targetHeight, 1);
+    return sprite;
+  }
+  function createStarTexture() {
+    const canvas = document.createElement("canvas");
+    canvas.width = 64;
+    canvas.height = 64;
+    const ctx = canvas.getContext("2d");
+    const gradient = ctx.createRadialGradient(32, 32, 0, 32, 32, 32);
+    gradient.addColorStop(0, "rgba(255, 255, 255, 1)");
+    gradient.addColorStop(0.2, "rgba(255, 255, 255, 0.8)");
+    gradient.addColorStop(0.5, "rgba(255, 255, 255, 0.2)");
+    gradient.addColorStop(1, "rgba(255, 255, 255, 0)");
+    ctx.fillStyle = gradient;
+    ctx.fillRect(0, 0, 64, 64);
+    const tex = new THREE4__namespace.CanvasTexture(canvas);
+    return tex;
+  }
+  const starTexture = createStarTexture();
+  function clearRoot() {
+    for (const child of [...root.children]) {
+      root.remove(child);
+      disposeObject(child);
+    }
+    nodeById.clear();
+    meshById.clear();
+    lineByBookId.clear();
+    dynamicObjects.length = 0;
+  }
+  function buildFromModel(model, cfg) {
+    clearRoot();
+    if (cfg.background) scene.background = new THREE4__namespace.Color(cfg.background);
+    camera.fov = cfg.camera?.fov ?? env.defaultFov;
+    camera.updateProjectionMatrix();
+    const layoutCfg = {
+      ...cfg.layout,
+      radius: cfg.layout?.radius ?? 2e3
+    };
+    const laidOut = computeLayoutPositions(model, layoutCfg);
+    for (const n of laidOut.nodes) {
+      nodeById.set(n.id, n);
+      const x = n.meta?.x ?? 0;
+      const y = n.meta?.y ?? 0;
+      const z = n.meta?.z ?? 0;
+      if (n.level === 3) {
+        const mat = new THREE4__namespace.SpriteMaterial({
+          map: starTexture,
+          color: 16777215,
+          transparent: true,
+          blending: THREE4__namespace.AdditiveBlending,
+          depthWrite: false
+        });
+        const sprite = new THREE4__namespace.Sprite(mat);
+        sprite.position.set(x, y, z);
+        sprite.userData = { id: n.id, level: n.level };
+        const baseScale = 2;
+        sprite.scale.setScalar(baseScale);
+        dynamicObjects.push({ obj: sprite, initialScale: sprite.scale.clone(), type: "star" });
+        if (n.label) {
+          const labelSprite = createTextSprite(n.label);
+          if (labelSprite) {
+            labelSprite.position.set(0, 1.2, 0);
+            labelSprite.visible = false;
+            sprite.add(labelSprite);
+          }
+        }
+        root.add(sprite);
+        meshById.set(n.id, sprite);
+      } else if (n.level === 1 || n.level === 2) {
+        if (n.label) {
+          const isBook = n.level === 2;
+          const color = isBook ? "#ffffff" : "#38bdf8";
+          const baseScale = isBook ? 3 : 7;
+          const labelSprite = createTextSprite(n.label, color);
+          if (labelSprite) {
+            labelSprite.position.set(x, y, z);
+            labelSprite.scale.multiplyScalar(baseScale);
+            root.add(labelSprite);
+            if (isBook) {
+              dynamicObjects.push({ obj: labelSprite, initialScale: labelSprite.scale.clone(), type: "label" });
+            }
+          }
+        }
+      }
+    }
+    applyVisuals({ model: laidOut, cfg, meshById });
+    const lineMat = new THREE4__namespace.LineBasicMaterial({
+      color: 4478310,
+      transparent: true,
+      opacity: 0.3,
+      depthWrite: false,
+      blending: THREE4__namespace.AdditiveBlending
+    });
+    const bookMap = /* @__PURE__ */ new Map();
+    for (const n of laidOut.nodes) {
+      if (n.level === 3 && n.parent) {
+        const list = bookMap.get(n.parent) ?? [];
+        list.push(n);
+        bookMap.set(n.parent, list);
+      }
+    }
+    for (const [bookId, chapters] of bookMap.entries()) {
+      chapters.sort((a, b) => {
+        const cA = a.meta?.chapter || 0;
+        const cB = b.meta?.chapter || 0;
+        return cA - cB;
+      });
+      if (chapters.length < 2) continue;
+      const points = [];
+      for (const c of chapters) {
+        const x = c.meta?.x ?? 0;
+        const y = c.meta?.y ?? 0;
+        const z = c.meta?.z ?? 0;
+        points.push(new THREE4__namespace.Vector3(x, y, z));
+      }
+      const geo = new THREE4__namespace.BufferGeometry().setFromPoints(points);
+      const line = new THREE4__namespace.Line(geo, lineMat);
+      root.add(line);
+      lineByBookId.set(bookId, line);
+    }
+    resize();
+  }
+  function setConfig(cfg) {
+    let model = cfg.model;
+    if (!model && cfg.data && cfg.adapter) model = cfg.adapter(cfg.data);
+    if (!model) {
+      clearRoot();
+      return;
+    }
+    buildFromModel(model, cfg);
+  }
+  function setHandlers(next) {
+    handlers = next;
+  }
+  function pick(ev) {
+    const rect = renderer.domElement.getBoundingClientRect();
+    pointer.x = (ev.clientX - rect.left) / rect.width * 2 - 1;
+    pointer.y = -((ev.clientY - rect.top) / rect.height * 2 - 1);
+    raycaster.setFromCamera(pointer, camera);
+    const hits = raycaster.intersectObjects(root.children, true);
+    const hit = hits.find((h) => h.object.type === "Mesh" || h.object.type === "Sprite");
+    const id = hit?.object?.userData?.id;
+    return id ? nodeById.get(id) : void 0;
+  }
+  function onPointerMove(ev) {
+    const node = pick(ev);
+    const nextId = node?.id ?? null;
+    if (nextId !== hoveredId) {
+      if (hoveredId) {
+        const prevMesh = meshById.get(hoveredId);
+        const prevNode = nodeById.get(hoveredId);
+        if (prevMesh && prevNode && prevNode.level === 3) {
+          const label = prevMesh.children.find((c) => c instanceof THREE4__namespace.Sprite);
+          if (label) label.visible = false;
+        }
+      }
+      hoveredId = nextId;
+      if (nextId) {
+        const mesh = meshById.get(nextId);
+        const n = nodeById.get(nextId);
+        if (mesh && n && n.level === 3) {
+          const label = mesh.children.find((c) => c instanceof THREE4__namespace.Sprite);
+          if (label) {
+            label.visible = true;
+            label.position.set(0, 0.8, 0);
+          }
+          if (n.parent) {
+            const line = lineByBookId.get(n.parent);
+            if (line) line.material.opacity = 0.8;
+          }
+        }
+      }
+      handlers.onHover?.(node);
+    }
+  }
+  function onPointerDown() {
+    isDragging = false;
+  }
+  function onChange() {
+    isDragging = true;
+  }
+  const onWheelFov = (ev) => {
+    ev.preventDefault();
+    const speed = (ev.ctrlKey ? 0.15 : 1) * env.fovWheelSensitivity;
+    const next = THREE4__namespace.MathUtils.clamp(
+      camera.fov + ev.deltaY * speed,
+      env.minFov,
+      env.maxFov
+    );
+    if (next !== camera.fov) {
+      camera.fov = next;
+      camera.updateProjectionMatrix();
+    }
+  };
+  const onDblClick = (ev) => {
+    const node = pick(ev);
+    if (node) {
+      const mesh = meshById.get(node.id);
+      if (mesh) {
+        animateFocusTo(mesh);
+        return;
+      }
+    }
+    camera.fov = env.defaultFov;
+    camera.updateProjectionMatrix();
+  };
+  let focusAnimRaf = 0;
+  function cancelFocusAnim() {
+    if (focusAnimRaf) cancelAnimationFrame(focusAnimRaf);
+    focusAnimRaf = 0;
+  }
+  function getControlsAnglesSafe() {
+    const getAz = controls.getAzimuthalAngle?.bind(controls);
+    const getPol = controls.getPolarAngle?.bind(controls);
+    return {
+      azimuth: typeof getAz === "function" ? getAz() : 0,
+      polar: typeof getPol === "function" ? getPol() : Math.PI / 4
+    };
+  }
+  function setControlsAnglesSafe(azimuth, polar) {
+    const setAz = controls.setAzimuthalAngle?.bind(controls);
+    const setPol = controls.setPolarAngle?.bind(controls);
+    if (typeof setAz === "function" && typeof setPol === "function") {
+      setAz(azimuth);
+      setPol(polar);
+      controls.update();
+      return;
+    }
+    const dir = new THREE4__namespace.Vector3();
+    dir.setFromSphericalCoords(1, polar, azimuth);
+    const lookAt2 = dir.clone().multiplyScalar(10);
+    camera.lookAt(lookAt2);
+  }
+  function aimAtWorldPoint(worldPoint) {
+    const dir = worldPoint.clone().normalize().negate();
+    const spherical = new THREE4__namespace.Spherical().setFromVector3(dir);
+    let targetPolar = spherical.phi;
+    let targetAz = spherical.theta;
+    targetPolar = THREE4__namespace.MathUtils.clamp(targetPolar, controls.minPolarAngle, controls.maxPolarAngle);
+    return { targetAz, targetPolar };
+  }
+  function easeInOutCubic(t) {
+    return t < 0.5 ? 4 * t * t * t : 1 - Math.pow(-2 * t + 2, 3) / 2;
+  }
+  function animateFocusTo(mesh) {
+    cancelFocusAnim();
+    const { azimuth: startAz, polar: startPolar } = getControlsAnglesSafe();
+    const startFov = camera.fov;
+    const { targetAz, targetPolar } = aimAtWorldPoint(mesh.getWorldPosition(new THREE4__namespace.Vector3()));
+    const endFov = THREE4__namespace.MathUtils.clamp(env.focusZoomFov, env.minFov, env.maxFov);
+    const start2 = performance.now();
+    const dur = Math.max(120, env.focusDurationMs);
+    const tick = (now) => {
+      const t = THREE4__namespace.MathUtils.clamp((now - start2) / dur, 0, 1);
+      const k = easeInOutCubic(t);
+      let dAz = targetAz - startAz;
+      dAz = (dAz + Math.PI) % (Math.PI * 2) - Math.PI;
+      const curAz = startAz + dAz * k;
+      const curPolar = THREE4__namespace.MathUtils.lerp(startPolar, targetPolar, k);
+      setControlsAnglesSafe(curAz, curPolar);
+      camera.fov = THREE4__namespace.MathUtils.lerp(startFov, endFov, k);
+      camera.updateProjectionMatrix();
+      if (t < 1) {
+        focusAnimRaf = requestAnimationFrame(tick);
+      } else {
+        focusAnimRaf = 0;
+      }
+    };
+    focusAnimRaf = requestAnimationFrame(tick);
+  }
+  function onPointerUp(ev) {
+    if (isDragging) return;
+    const node = pick(ev);
+    if (!node) return;
+    handlers.onSelect?.(node);
+  }
+  function start() {
+    if (running) return;
+    running = true;
+    resize();
+    window.addEventListener("resize", resize);
+    renderer.domElement.addEventListener("pointermove", onPointerMove);
+    renderer.domElement.addEventListener("pointerdown", onPointerDown);
+    renderer.domElement.addEventListener("pointerup", onPointerUp);
+    renderer.domElement.addEventListener("wheel", onWheelFov, { passive: false });
+    renderer.domElement.addEventListener("dblclick", onDblClick);
+    controls.addEventListener("change", onChange);
+    const tick = () => {
+      raf = requestAnimationFrame(tick);
+      controls.rotateSpeed = camera.fov / (env.defaultFov);
+      const fov = camera.fov;
+      const minZoomFov = 15;
+      const scaleFactor = Math.max(1, 1 + (fov - minZoomFov) * 0.05);
+      const cameraDir = new THREE4__namespace.Vector3();
+      camera.getWorldDirection(cameraDir);
+      const objPos = new THREE4__namespace.Vector3();
+      const objDir = new THREE4__namespace.Vector3();
+      for (let i = 0; i < dynamicObjects.length; i++) {
+        const item = dynamicObjects[i];
+        item.obj.scale.copy(item.initialScale).multiplyScalar(scaleFactor);
+        if (item.type === "label") {
+          const sprite = item.obj;
+          sprite.getWorldPosition(objPos);
+          objDir.subVectors(objPos, camera.position).normalize();
+          const dot = cameraDir.dot(objDir);
+          const fullVisibleDot = 0.96;
+          const invisibleDot = 0.88;
+          let opacity = 0;
+          if (dot >= fullVisibleDot) {
+            opacity = 1;
+          } else if (dot > invisibleDot) {
+            opacity = (dot - invisibleDot) / (fullVisibleDot - invisibleDot);
+          }
+          sprite.material.opacity = opacity;
+          sprite.visible = opacity > 0.01;
+          const bookId = nodeById.get(item.obj.userData.id)?.id;
+          if (bookId) {
+            const line = lineByBookId.get(bookId);
+            if (line) {
+              line.material.opacity = 0.05 + opacity * 0.45;
+            }
+          }
+        }
+      }
+      controls.update();
+      renderer.render(scene, camera);
+    };
+    tick();
+  }
+  function stop() {
+    running = false;
+    cancelAnimationFrame(raf);
+    cancelFocusAnim();
+    window.removeEventListener("resize", resize);
+    renderer.domElement.removeEventListener("pointermove", onPointerMove);
+    renderer.domElement.removeEventListener("pointerdown", onPointerDown);
+    renderer.domElement.removeEventListener("pointerup", onPointerUp);
+    renderer.domElement.removeEventListener("wheel", onWheelFov);
+    renderer.domElement.removeEventListener("dblclick", onDblClick);
+    controls.removeEventListener("change", onChange);
+  }
+  function dispose() {
+    stop();
+    clearRoot();
+    for (const child of [...groundGroup.children]) {
+      groundGroup.remove(child);
+      disposeObject(child);
+    }
+    for (const child of [...backdropGroup.children]) {
+      backdropGroup.remove(child);
+      disposeObject(child);
+    }
+    controls.dispose();
+    renderer.dispose();
+    renderer.domElement.remove();
+  }
+  return { setConfig, start, stop, dispose, setHandlers };
+}
+var init_createEngine = __esm({
+  "src/engine/createEngine.ts"() {
+    init_layout();
+    init_materials();
+  }
+});
+function StarMap({ config, className, onSelect, onHover }) {
+  const containerRef = react.useRef(null);
+  const engineRef = react.useRef(null);
+  react.useEffect(() => {
+    let disposed = false;
+    async function init() {
+      if (!containerRef.current) return;
+      const { createEngine: createEngine2 } = await Promise.resolve().then(() => (init_createEngine(), createEngine_exports));
+      if (disposed) return;
+      engineRef.current = createEngine2({
+        container: containerRef.current,
+        onSelect,
+        onHover
+      });
+      engineRef.current.setConfig(config);
+      engineRef.current.start();
+    }
+    init();
+    return () => {
+      disposed = true;
+      engineRef.current?.dispose?.();
+      engineRef.current = null;
+    };
+  }, []);
+  react.useEffect(() => {
+    engineRef.current?.setConfig?.(config);
+  }, [config]);
+  react.useEffect(() => {
+    engineRef.current?.setHandlers?.({ onSelect, onHover });
+  }, [onSelect, onHover]);
+  return /* @__PURE__ */ jsxRuntime.jsx("div", { ref: containerRef, className, style: { width: "100%", height: "100%" } });
+}
+
+// src/adapters/bible.ts
+function bibleToSceneModel(data) {
+  const nodes = [];
+  const links = [];
+  const id = {
+    testament: (t) => `T:${t}`,
+    division: (t, d) => `D:${t}:${d}`,
+    book: (key) => `B:${key}`,
+    chapter: (key, ch) => `C:${key}:${ch}`
+  };
+  for (const t of data.testaments) {
+    const tid = id.testament(t.name);
+    nodes.push({ id: tid, label: t.name, level: 0, meta: { testament: t.name } });
+    for (const d of t.divisions) {
+      const did = id.division(t.name, d.name);
+      nodes.push({
+        id: did,
+        label: d.name,
+        level: 1,
+        parent: tid,
+        meta: { testament: t.name, division: d.name }
+      });
+      links.push({ source: did, target: tid });
+      for (const b of d.books) {
+        const bid = id.book(b.key);
+        nodes.push({
+          id: bid,
+          label: b.name,
+          level: 2,
+          parent: did,
+          meta: { testament: t.name, division: d.name, bookKey: b.key, book: b.name }
+        });
+        links.push({ source: bid, target: did });
+        const verses = b.verses ?? [];
+        for (let i = 0; i < verses.length; i++) {
+          const chapterNum = i + 1;
+          const cid = id.chapter(b.key, chapterNum);
+          nodes.push({
+            id: cid,
+            label: `${b.name} ${chapterNum}`,
+            level: 3,
+            parent: bid,
+            weight: verses[i],
+            icon: b.icons?.[i] ?? b.icons?.[0],
+            meta: {
+              testament: t.name,
+              division: d.name,
+              bookKey: b.key,
+              book: b.name,
+              chapter: chapterNum
+            }
+          });
+          links.push({ source: cid, target: bid });
+        }
+      }
+    }
+  }
+  return { nodes, links };
+}
+
+exports.StarMap = StarMap;
+exports.bibleToSceneModel = bibleToSceneModel;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map