@xom11/whiteboard 0.11.0 → 0.24.1

package/dist/host-TLIXN4CF.mjs

@@ -0,0 +1,2374 @@
+"use client";
+import { VIEW3D_ATTRS, DEFAULT_VIEW3D, GROUND_PLANE_RANGE, GROUND_PLANE_ATTRS, paletteFor, JxgRenderer3D, serializeBoard3D, renderGeometry3DSvgFromState, isGeometry3DCustomData, deserializeBoard3D } from './chunk-CSCF3YFZ.mjs';
+import { useChordShortcut } from './chunk-HNQLZIEP.mjs';
+import { initJxgBoard, attachJxgWheelZoom, ToastHost, STAMP_PANEL_DESKTOP, ToastProvider, useStampStore, StampLeftPanel } from './chunk-4D5CSIJO.mjs';
+import './chunk-R5FL6S7L.mjs';
+import './chunk-ICR4CVOE.mjs';
+import { useEditorState, nextLabel, listObjects } from './chunk-6V4SH4JJ.mjs';
+import './chunk-ZBJBQKJ2.mjs';
+import { useIsMobile } from './chunk-P2AOIF7S.mjs';
+import { insertStampImage } from './chunk-QGNU34T7.mjs';
+import './chunk-5UTGXHLJ.mjs';
+import * as React3 from 'react';
+import { forwardRef, useRef, useState, useCallback, useImperativeHandle } from 'react';
+import { jsx, jsxs, Fragment } from 'react/jsx-runtime';
+
+// src/stamps/geometry-3d/editor/tools/handlers/_ensurePoint.ts
+function hitToConstraint(hit) {
+  switch (hit.kind) {
+    case "onGround":
+      return { kind: "onGround", x: hit.world[0], y: hit.world[1] };
+    case "onAxis":
+      return { kind: "onAxis", axis: hit.axis, t: hit.t };
+    case "onPlane":
+      return { kind: "onPlane", planeId: hit.planeId, u: hit.u, v: hit.v };
+    case "onLine":
+      return { kind: "onLine", lineId: hit.lineId, t: hit.t };
+    case "onPolygon":
+      return { kind: "onPolygon", polygonId: hit.polygonId, u: hit.u, v: hit.v };
+    case "onSphere":
+      return { kind: "onSphere", sphereId: hit.sphereId, theta: hit.theta, phi: hit.phi };
+    default:
+      return null;
+  }
+}
+function makePointId(store, offset = 1) {
+  return `p${store.getState().counter + offset}`;
+}
+function buildPointObject(store, constraint, options = {}) {
+  const id = makePointId(store, options.idOffset ?? 1);
+  const state = store.getState();
+  const label = options.label ?? nextLabel(state, "point3d");
+  return {
+    id,
+    kind: "point3d",
+    label,
+    visible: true,
+    locked: false,
+    layer: "default",
+    schemaVersion: 1,
+    attrs: { constraint, ...options.color ? { color: options.color } : {} }
+  };
+}
+function addPoint(store, constraint, color) {
+  const obj = buildPointObject(store, constraint, {});
+  store.dispatch({ type: "ADD", payload: { obj } });
+  return obj.id;
+}
+function ensurePoint(hit, store) {
+  if (hit.kind === "existingPoint") return hit.pointId;
+  const c = hitToConstraint(hit);
+  if (!c) return null;
+  return addPoint(store, c);
+}
+
+// src/stamps/geometry-3d/editor/tools/handlers/point.ts
+function buildPoint(args, store) {
+  const hit = args[0]?.hit;
+  if (!hit) return null;
+  if (hit.kind === "existingPoint") return hit.pointId;
+  const c = hitToConstraint(hit);
+  if (!c) return null;
+  return addPoint(store, c);
+}
+var buildPointOnObject = buildPoint;
+
+// src/stamps/geometry-3d/editor/tools/handlers/segment.ts
+function makeDerivedId(store, prefix) {
+  return `${prefix}${store.getState().counter + 1}`;
+}
+function addDerived(store, kind, prefix, attrs) {
+  const id = makeDerivedId(store, prefix);
+  const label = nextLabel(store.getState(), kind);
+  const obj = {
+    id,
+    kind,
+    label,
+    visible: true,
+    locked: false,
+    layer: "default",
+    schemaVersion: 1,
+    attrs
+  };
+  store.dispatch({ type: "ADD", payload: { obj } });
+  return id;
+}
+function buildSegment(args, store) {
+  if (args.length < 2 || !args[0].hit || !args[1].hit) return null;
+  const p1 = ensurePoint(args[0].hit, store);
+  const p2 = ensurePoint(args[1].hit, store);
+  if (!p1 || !p2 || p1 === p2) return null;
+  return addDerived(store, "segment3d", "s", { p1, p2 });
+}
+function buildLine(args, store) {
+  if (args.length < 2 || !args[0].hit || !args[1].hit) return null;
+  const p1 = ensurePoint(args[0].hit, store);
+  const p2 = ensurePoint(args[1].hit, store);
+  if (!p1 || !p2 || p1 === p2) return null;
+  return addDerived(store, "line3d", "l", { p1, p2 });
+}
+function buildRay(args, store) {
+  if (args.length < 2 || !args[0].hit || !args[1].hit) return null;
+  const origin = ensurePoint(args[0].hit, store);
+  const through = ensurePoint(args[1].hit, store);
+  if (!origin || !through || origin === through) return null;
+  return addDerived(store, "ray3d", "r", { origin, through });
+}
+function buildVector(args, store) {
+  if (args.length < 2 || !args[0].hit || !args[1].hit) return null;
+  const from = ensurePoint(args[0].hit, store);
+  const to = ensurePoint(args[1].hit, store);
+  if (!from || !to || from === to) return null;
+  return addDerived(store, "vector3d", "v", { from, to });
+}
+
+// src/stamps/geometry-3d/editor/tools/handlers/polygon.ts
+function buildPolygon(args, store) {
+  const vertexArgs = args.filter((a) => a.step.type === "point");
+  const vertexIds = vertexArgs.map((a) => a.hit ? ensurePoint(a.hit, store) : null).filter((x) => !!x);
+  if (vertexIds.length < 3) return null;
+  const id = `pg${store.getState().counter + 1}`;
+  const label = nextLabel(store.getState(), "polygon3d");
+  const obj = {
+    id,
+    kind: "polygon3d",
+    label,
+    visible: true,
+    locked: false,
+    layer: "default",
+    schemaVersion: 1,
+    attrs: { vertices: vertexIds }
+  };
+  store.dispatch({ type: "ADD", payload: { obj } });
+  return id;
+}
+
+// src/stamps/geometry-3d/editor/scene/constraintMath.ts
+function sub(a, b) {
+  return [a[0] - b[0], a[1] - b[1], a[2] - b[2]];
+}
+function add(a, b) {
+  return [a[0] + b[0], a[1] + b[1], a[2] + b[2]];
+}
+function scale(a, k) {
+  return [a[0] * k, a[1] * k, a[2] * k];
+}
+function dot(a, b) {
+  return a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
+}
+function cross(a, b) {
+  return [a[1] * b[2] - a[2] * b[1], a[2] * b[0] - a[0] * b[2], a[0] * b[1] - a[1] * b[0]];
+}
+function norm(a) {
+  return Math.sqrt(dot(a, a));
+}
+function normalize(a) {
+  const n = norm(a);
+  return n === 0 ? a : scale(a, 1 / n);
+}
+function getPointWorld(id, state) {
+  const obj = state.objects[id];
+  if (!obj || obj.kind !== "point3d") {
+    throw new Error(`constraintMath: point ${id} not found`);
+  }
+  const attrs = obj.attrs;
+  return constraintToWorld(attrs.constraint, state);
+}
+function getPlaneBasis(planeObj, state) {
+  const p1 = getPointWorld(planeObj.attrs.p1, state);
+  const p2 = getPointWorld(planeObj.attrs.p2, state);
+  const p3 = getPointWorld(planeObj.attrs.p3, state);
+  const basis1 = sub(p2, p1);
+  const tmp = sub(p3, p1);
+  const normal = normalize(cross(basis1, tmp));
+  const basis2 = cross(normal, basis1);
+  return { origin: p1, basis1, basis2, normal };
+}
+function constraintToWorld(c, state) {
+  switch (c.kind) {
+    case "free":
+      return [c.x, c.y, c.z];
+    case "onGround":
+      return [c.x, c.y, 0];
+    case "onAxis": {
+      if (c.axis === "x") return [c.t, 0, 0];
+      if (c.axis === "y") return [0, c.t, 0];
+      return [0, 0, c.t];
+    }
+    case "onPlane": {
+      const plane = state.objects[c.planeId];
+      if (!plane || plane.kind !== "plane3d") throw new Error("onPlane: plane missing");
+      const { origin, basis1, basis2 } = getPlaneBasis(plane, state);
+      return add(add(origin, scale(basis1, c.u)), scale(basis2, c.v));
+    }
+    case "onLine": {
+      const line = state.objects[c.lineId];
+      if (!line) throw new Error("onLine: parent missing");
+      let p1Id;
+      let p2Id;
+      if (line.kind === "line3d" || line.kind === "segment3d") {
+        const a = line.attrs;
+        p1Id = a.p1;
+        p2Id = a.p2;
+      } else if (line.kind === "ray3d") {
+        const a = line.attrs;
+        p1Id = a.origin;
+        p2Id = a.through;
+      } else if (line.kind === "vector3d") {
+        const a = line.attrs;
+        p1Id = a.from;
+        p2Id = a.to;
+      } else {
+        throw new Error("onLine: parent kind not supported");
+      }
+      const p1 = getPointWorld(p1Id, state);
+      const p2 = getPointWorld(p2Id, state);
+      const dir = sub(p2, p1);
+      return add(p1, scale(dir, c.t));
+    }
+    case "onPolygon": {
+      const pg = state.objects[c.polygonId];
+      if (!pg || pg.kind !== "polygon3d") throw new Error("onPolygon: parent missing");
+      const v = pg.attrs.vertices;
+      if (v.length < 3) throw new Error("onPolygon: < 3 vertices");
+      const p1 = getPointWorld(v[0], state);
+      const p2 = getPointWorld(v[1], state);
+      const p3 = getPointWorld(v[2], state);
+      const basis1 = sub(p2, p1);
+      const tmp = sub(p3, p1);
+      const normal = normalize(cross(basis1, tmp));
+      const basis2 = cross(normal, basis1);
+      return add(add(p1, scale(basis1, c.u)), scale(basis2, c.v));
+    }
+    case "onSphere": {
+      const sph = state.objects[c.sphereId];
+      if (!sph || sph.kind !== "sphere3d") throw new Error("onSphere: parent missing");
+      const a = sph.attrs;
+      const center = getPointWorld(a.center, state);
+      const surface = getPointWorld(a.surfacePoint, state);
+      const radius = norm(sub(surface, center));
+      const x = center[0] + radius * Math.sin(c.phi) * Math.cos(c.theta);
+      const y = center[1] + radius * Math.sin(c.phi) * Math.sin(c.theta);
+      const z = center[2] + radius * Math.cos(c.phi);
+      return [x, y, z];
+    }
+  }
+}
+
+// src/stamps/geometry-3d/editor/scene/geometryChecks.ts
+var EPS = 1e-6;
+function getWorld(id, state) {
+  const obj = state.objects[id];
+  if (!obj || obj.kind !== "point3d") return null;
+  const attrs = obj.attrs;
+  return constraintToWorld(attrs.constraint, state);
+}
+function areCollinear3(p1Id, p2Id, p3Id, state) {
+  const p1 = getWorld(p1Id, state);
+  const p2 = getWorld(p2Id, state);
+  const p3 = getWorld(p3Id, state);
+  if (!p1 || !p2 || !p3) return true;
+  const a = [p2[0] - p1[0], p2[1] - p1[1], p2[2] - p1[2]];
+  const b = [p3[0] - p1[0], p3[1] - p1[1], p3[2] - p1[2]];
+  const c = [a[1] * b[2] - a[2] * b[1], a[2] * b[0] - a[0] * b[2], a[0] * b[1] - a[1] * b[0]];
+  return Math.hypot(c[0], c[1], c[2]) < EPS;
+}
+function apexCoplanarWithBase(baseIds, apexId, state) {
+  if (baseIds.length < 3) return false;
+  const p1 = getWorld(baseIds[0], state);
+  const p2 = getWorld(baseIds[1], state);
+  const p3 = getWorld(baseIds[2], state);
+  const apex = getWorld(apexId, state);
+  if (!p1 || !p2 || !p3 || !apex) return false;
+  const a = [p2[0] - p1[0], p2[1] - p1[1], p2[2] - p1[2]];
+  const b = [p3[0] - p1[0], p3[1] - p1[1], p3[2] - p1[2]];
+  const n = [a[1] * b[2] - a[2] * b[1], a[2] * b[0] - a[0] * b[2], a[0] * b[1] - a[1] * b[0]];
+  const d = [apex[0] - p1[0], apex[1] - p1[1], apex[2] - p1[2]];
+  const dotND = n[0] * d[0] + n[1] * d[1] + n[2] * d[2];
+  return Math.abs(dotND) < EPS;
+}
+
+// src/stamps/geometry-3d/editor/tools/handlers/plane.ts
+function buildPlane(args, store) {
+  if (args.length < 3 || !args[0].hit || !args[1].hit || !args[2].hit) return null;
+  const p1 = ensurePoint(args[0].hit, store);
+  const p2 = ensurePoint(args[1].hit, store);
+  const p3 = ensurePoint(args[2].hit, store);
+  if (!p1 || !p2 || !p3) return null;
+  if (p1 === p2 || p2 === p3 || p1 === p3) return null;
+  if (areCollinear3(p1, p2, p3, store.getState())) return null;
+  const id = `pl${store.getState().counter + 1}`;
+  const label = nextLabel(store.getState(), "plane3d");
+  const obj = {
+    id,
+    kind: "plane3d",
+    label,
+    visible: true,
+    locked: false,
+    layer: "default",
+    schemaVersion: 1,
+    attrs: { p1, p2, p3 }
+  };
+  store.dispatch({ type: "ADD", payload: { obj } });
+  return id;
+}
+
+// src/stamps/geometry-3d/editor/tools/handlers/pyramid.ts
+function buildPyramid(args, store) {
+  const pointArgs = args.filter((a) => a.step.type === "point");
+  const baseArgs = pointArgs.slice(0, -1);
+  const apexArg = pointArgs.slice(-1)[0];
+  if (baseArgs.length < 3 || !apexArg?.hit) return null;
+  const baseIds = baseArgs.map((a) => a.hit ? ensurePoint(a.hit, store) : null).filter((x) => !!x);
+  const apexId = ensurePoint(apexArg.hit, store);
+  if (!apexId || baseIds.length < 3) return null;
+  if (apexCoplanarWithBase(baseIds, apexId, store.getState())) return null;
+  const vertices = [...baseIds, apexId];
+  const apexIdx = vertices.length - 1;
+  const faces = [baseIds.map((_, i) => i)];
+  for (let i = 0; i < baseIds.length; i++) {
+    faces.push([i, (i + 1) % baseIds.length, apexIdx]);
+  }
+  const id = `ph${store.getState().counter + 1}`;
+  const label = nextLabel(store.getState(), "polyhedron3d");
+  const obj = {
+    id,
+    kind: "polyhedron3d",
+    label,
+    visible: true,
+    locked: false,
+    layer: "default",
+    schemaVersion: 1,
+    attrs: { flavor: "pyramid", vertices, faces }
+  };
+  store.dispatch({ type: "ADD", payload: { obj } });
+  return id;
+}
+
+// src/stamps/geometry-3d/editor/tools/handlers/prism.ts
+function buildPrism(args, store) {
+  const baseArgs = args.filter((a) => a.step.type === "point");
+  const numberArg = args.find((a) => a.step.type === "number");
+  if (baseArgs.length < 3 || !numberArg || typeof numberArg.value !== "number") return null;
+  const height = numberArg.value;
+  if (height <= 0) return null;
+  const baseIds = baseArgs.map((a) => a.hit ? ensurePoint(a.hit, store) : null).filter((x) => !!x);
+  if (baseIds.length < 3) return null;
+  const topIds = [];
+  for (const id2 of baseIds) {
+    const state = store.getState();
+    const p = state.objects[id2];
+    if (!p || p.kind !== "point3d") return null;
+    const attrs = p.attrs;
+    const w = constraintToWorld(attrs.constraint, state);
+    topIds.push(addPoint(store, { kind: "free", x: w[0], y: w[1], z: w[2] + height }));
+  }
+  const n = baseIds.length;
+  const vertices = [...baseIds, ...topIds];
+  const faces = [
+    baseIds.map((_, i) => i),
+    topIds.map((_, i) => n + i)
+  ];
+  for (let i = 0; i < n; i++) {
+    faces.push([i, (i + 1) % n, n + (i + 1) % n, n + i]);
+  }
+  const id = `ph${store.getState().counter + 1}`;
+  const label = nextLabel(store.getState(), "polyhedron3d");
+  const obj = {
+    id,
+    kind: "polyhedron3d",
+    label,
+    visible: true,
+    locked: false,
+    layer: "default",
+    schemaVersion: 1,
+    attrs: { flavor: "prism", vertices, faces }
+  };
+  store.dispatch({ type: "ADD", payload: { obj } });
+  return id;
+}
+
+// src/stamps/geometry-3d/editor/tools/handlers/tetrahedron.ts
+function buildTetrahedron(args, store) {
+  if (args.length < 2 || !args[0].hit || !args[1].hit) return null;
+  const p1Id = ensurePoint(args[0].hit, store);
+  const p2Id = ensurePoint(args[1].hit, store);
+  if (!p1Id || !p2Id || p1Id === p2Id) return null;
+  const state0 = store.getState();
+  const p1Obj = state0.objects[p1Id];
+  const p2Obj = state0.objects[p2Id];
+  if (!p1Obj || p1Obj.kind !== "point3d" || !p2Obj || p2Obj.kind !== "point3d") return null;
+  const p1 = constraintToWorld(p1Obj.attrs.constraint, state0);
+  const p2 = constraintToWorld(p2Obj.attrs.constraint, state0);
+  const z0 = Math.min(p1[2], p2[2]);
+  const baseA = [p1[0], p1[1], z0];
+  const baseB = [p2[0], p2[1], z0];
+  const dx = baseB[0] - baseA[0];
+  const dy = baseB[1] - baseA[1];
+  const edge = Math.hypot(dx, dy);
+  if (edge < 1e-9) return null;
+  const mid = [(baseA[0] + baseB[0]) / 2, (baseA[1] + baseB[1]) / 2, z0];
+  const perpX = -dy;
+  const perpY = dx;
+  const perpLen = Math.hypot(perpX, perpY);
+  const height = edge * Math.sqrt(3) / 2;
+  const baseC = [mid[0] + perpX / perpLen * height, mid[1] + perpY / perpLen * height, z0];
+  const centroid = [
+    (baseA[0] + baseB[0] + baseC[0]) / 3,
+    (baseA[1] + baseB[1] + baseC[1]) / 3,
+    z0
+  ];
+  const apexHeight = edge * Math.sqrt(2 / 3);
+  const apex = [centroid[0], centroid[1], z0 + apexHeight];
+  const cId = addPoint(store, { kind: "free", x: baseC[0], y: baseC[1], z: baseC[2] });
+  const apexId = addPoint(store, { kind: "free", x: apex[0], y: apex[1], z: apex[2] });
+  const vertices = [p1Id, p2Id, cId, apexId];
+  const faces = [
+    [0, 1, 2],
+    // base
+    [0, 1, 3],
+    // face p1-p2-apex
+    [1, 2, 3],
+    // face p2-c-apex
+    [2, 0, 3]
+    // face c-p1-apex
+  ];
+  const id = `ph${store.getState().counter + 1}`;
+  const label = nextLabel(store.getState(), "polyhedron3d");
+  const obj = {
+    id,
+    kind: "polyhedron3d",
+    label,
+    visible: true,
+    locked: false,
+    layer: "default",
+    schemaVersion: 1,
+    attrs: { flavor: "tetrahedron", vertices, faces }
+  };
+  store.dispatch({ type: "ADD", payload: { obj } });
+  return id;
+}
+
+// src/stamps/geometry-3d/editor/tools/handlers/cube.ts
+function buildCube(args, store) {
+  if (args.length < 2 || !args[0].hit || !args[1].hit) return null;
+  const p1Id = ensurePoint(args[0].hit, store);
+  const p2Id = ensurePoint(args[1].hit, store);
+  if (!p1Id || !p2Id || p1Id === p2Id) return null;
+  const state0 = store.getState();
+  const p1Obj = state0.objects[p1Id];
+  const p2Obj = state0.objects[p2Id];
+  if (!p1Obj || p1Obj.kind !== "point3d" || !p2Obj || p2Obj.kind !== "point3d") return null;
+  const p1 = constraintToWorld(p1Obj.attrs.constraint, state0);
+  const p2 = constraintToWorld(p2Obj.attrs.constraint, state0);
+  if (Math.abs(p1[2]) > 1e-6 || Math.abs(p2[2]) > 1e-6) return null;
+  const dx = p2[0] - p1[0];
+  const dy = p2[1] - p1[1];
+  const edge = Math.hypot(dx, dy);
+  if (edge < 1e-9) return null;
+  const perpX = -dy;
+  const perpY = dx;
+  const p3 = [p2[0] + perpX, p2[1] + perpY, 0];
+  const p4 = [p1[0] + perpX, p1[1] + perpY, 0];
+  const t1 = [p1[0], p1[1], edge];
+  const t2 = [p2[0], p2[1], edge];
+  const t3 = [p3[0], p3[1], edge];
+  const t4 = [p4[0], p4[1], edge];
+  const p3Id = addPoint(store, { kind: "onGround", x: p3[0], y: p3[1] });
+  const p4Id = addPoint(store, { kind: "onGround", x: p4[0], y: p4[1] });
+  const t1Id = addPoint(store, { kind: "free", x: t1[0], y: t1[1], z: t1[2] });
+  const t2Id = addPoint(store, { kind: "free", x: t2[0], y: t2[1], z: t2[2] });
+  const t3Id = addPoint(store, { kind: "free", x: t3[0], y: t3[1], z: t3[2] });
+  const t4Id = addPoint(store, { kind: "free", x: t4[0], y: t4[1], z: t4[2] });
+  const vertices = [p1Id, p2Id, p3Id, p4Id, t1Id, t2Id, t3Id, t4Id];
+  const faces = [
+    [0, 1, 2, 3],
+    // bottom
+    [4, 5, 6, 7],
+    // top
+    [0, 1, 5, 4],
+    // front
+    [1, 2, 6, 5],
+    // right
+    [2, 3, 7, 6],
+    // back
+    [3, 0, 4, 7]
+    // left
+  ];
+  const id = `ph${store.getState().counter + 1}`;
+  const label = nextLabel(store.getState(), "polyhedron3d");
+  const obj = {
+    id,
+    kind: "polyhedron3d",
+    label,
+    visible: true,
+    locked: false,
+    layer: "default",
+    schemaVersion: 1,
+    attrs: { flavor: "cube", vertices, faces }
+  };
+  store.dispatch({ type: "ADD", payload: { obj } });
+  return id;
+}
+
+// src/stamps/geometry-3d/editor/tools/handlers/sphere.ts
+function buildSphere(args, store) {
+  if (args.length < 2 || !args[0].hit || !args[1].hit) return null;
+  const center = ensurePoint(args[0].hit, store);
+  const surface = ensurePoint(args[1].hit, store);
+  if (!center || !surface || center === surface) return null;
+  const id = `sp${store.getState().counter + 1}`;
+  const label = nextLabel(store.getState(), "sphere3d");
+  const obj = {
+    id,
+    kind: "sphere3d",
+    label,
+    visible: true,
+    locked: false,
+    layer: "default",
+    schemaVersion: 1,
+    attrs: { center, surfacePoint: surface }
+  };
+  store.dispatch({ type: "ADD", payload: { obj } });
+  return id;
+}
+
+// src/stamps/geometry-3d/editor/tools/handlers/cylinder.ts
+function buildCylinder(args, store) {
+  const points = args.filter((a) => a.step.type === "point");
+  const numberArg = args.find((a) => a.step.type === "number");
+  if (points.length < 2 || !points[0].hit || !points[1].hit || !numberArg || typeof numberArg.value !== "number") return null;
+  const radius = numberArg.value;
+  if (radius <= 0) return null;
+  const baseCenter = ensurePoint(points[0].hit, store);
+  const topCenter = ensurePoint(points[1].hit, store);
+  if (!baseCenter || !topCenter || baseCenter === topCenter) return null;
+  const id = `cy${store.getState().counter + 1}`;
+  const label = nextLabel(store.getState(), "cylinder3d");
+  const obj = {
+    id,
+    kind: "cylinder3d",
+    label,
+    visible: true,
+    locked: false,
+    layer: "default",
+    schemaVersion: 1,
+    attrs: { baseCenter, topCenter, radius }
+  };
+  store.dispatch({ type: "ADD", payload: { obj } });
+  return id;
+}
+
+// src/stamps/geometry-3d/editor/tools/handlers/cone.ts
+function buildCone(args, store) {
+  const points = args.filter((a) => a.step.type === "point");
+  const numberArg = args.find((a) => a.step.type === "number");
+  if (points.length < 2 || !points[0].hit || !points[1].hit || !numberArg || typeof numberArg.value !== "number") return null;
+  const radius = numberArg.value;
+  if (radius <= 0) return null;
+  const baseCenter = ensurePoint(points[0].hit, store);
+  const apex = ensurePoint(points[1].hit, store);
+  if (!baseCenter || !apex || baseCenter === apex) return null;
+  const id = `co${store.getState().counter + 1}`;
+  const label = nextLabel(store.getState(), "cone3d");
+  const obj = {
+    id,
+    kind: "cone3d",
+    label,
+    visible: true,
+    locked: false,
+    layer: "default",
+    schemaVersion: 1,
+    attrs: { baseCenter, apex, radius }
+  };
+  store.dispatch({ type: "ADD", payload: { obj } });
+  return id;
+}
+
+// src/stamps/geometry-3d/editor/tools/spec.ts
+var stubBuild = () => null;
+var ALL_SURFACES = ["ground", "axis", "plane", "line", "polygon", "sphere"];
+var OBJECT_ONLY = ["plane", "line", "polygon", "sphere"];
+var NO_SURFACE = ["ground", "axis", "plane"];
+var TOOLS = [
+  {
+    key: "move",
+    label: "Di chuy\u1EC3n",
+    hintIdle: "K\xE9o \u0111i\u1EC3m ho\u1EB7c xoay khung",
+    steps: [],
+    build: stubBuild
+  },
+  {
+    key: "point",
+    label: "\u0110i\u1EC3m",
+    hintIdle: "Click tr\xEAn m\u1EB7t ph\u1EB3ng Oxy ho\u1EB7c tr\xEAn tr\u1EE5c \u0111\u1EC3 \u0111\u1EB7t \u0111i\u1EC3m",
+    steps: [
+      {
+        type: "point",
+        allowExisting: false,
+        // GeoGebra-style: a new point must lie on the XY ground plane or on
+        // one of the coordinate axes (Oz lets you place points off the plane).
+        allowNewOn: ["ground", "axis"],
+        hint: "Click tr\xEAn m\u1EB7t ph\u1EB3ng Oxy ho\u1EB7c tr\u1EE5c Ox/Oy/Oz"
+      }
+    ],
+    build: buildPoint,
+    repeatAfterBuild: true
+  },
+  {
+    key: "pointOnObject",
+    label: "\u0110i\u1EC3m tr\xEAn \u0111\u1ED1i t\u01B0\u1EE3ng",
+    hintIdle: "Ch\u1ECDn m\u1ED9t \u0111\u1ED1i t\u01B0\u1EE3ng \u0111\u1EC3 \u0111\u1EB7t \u0111i\u1EC3m",
+    steps: [{ type: "point", allowExisting: false, allowNewOn: OBJECT_ONLY, hint: "Click l\xEAn m\u1EB7t / \u0111\u01B0\u1EDDng \u0111\u1EC3 \u0111\u1EB7t \u0111i\u1EC3m" }],
+    build: buildPointOnObject
+  },
+  {
+    key: "segment",
+    label: "\u0110o\u1EA1n th\u1EB3ng",
+    hintIdle: "Ch\u1ECDn 2 \u0111i\u1EC3m \u0111\u1EC3 v\u1EBD \u0111o\u1EA1n th\u1EB3ng",
+    steps: [
+      { type: "point", allowExisting: true, allowNewOn: ALL_SURFACES, hint: "Ch\u1ECDn \u0111i\u1EC3m th\u1EE9 nh\u1EA5t" },
+      { type: "point", allowExisting: true, allowNewOn: ALL_SURFACES, hint: "Ch\u1ECDn \u0111i\u1EC3m th\u1EE9 hai" }
+    ],
+    build: buildSegment
+  },
+  {
+    key: "line",
+    label: "\u0110\u01B0\u1EDDng th\u1EB3ng",
+    hintIdle: "Ch\u1ECDn 2 \u0111i\u1EC3m \u0111\u1EC3 v\u1EBD \u0111\u01B0\u1EDDng th\u1EB3ng",
+    steps: [
+      { type: "point", allowExisting: true, allowNewOn: ALL_SURFACES, hint: "Ch\u1ECDn \u0111i\u1EC3m th\u1EE9 nh\u1EA5t" },
+      { type: "point", allowExisting: true, allowNewOn: ALL_SURFACES, hint: "Ch\u1ECDn \u0111i\u1EC3m th\u1EE9 hai" }
+    ],
+    build: buildLine
+  },
+  {
+    key: "ray",
+    label: "Tia",
+    hintIdle: "Ch\u1ECDn \u0111i\u1EC3m g\u1ED1c r\u1ED3i \u0111i\u1EC3m tr\xEAn tia",
+    steps: [
+      { type: "point", allowExisting: true, allowNewOn: ALL_SURFACES, hint: "Ch\u1ECDn \u0111i\u1EC3m g\u1ED1c" },
+      { type: "point", allowExisting: true, allowNewOn: ALL_SURFACES, hint: "Ch\u1ECDn \u0111i\u1EC3m tr\xEAn tia" }
+    ],
+    build: buildRay
+  },
+  {
+    key: "vector",
+    label: "Vector",
+    hintIdle: "Ch\u1ECDn 2 \u0111i\u1EC3m \u0111\u1EC3 v\u1EBD vector",
+    steps: [
+      { type: "point", allowExisting: true, allowNewOn: ALL_SURFACES, hint: "Ch\u1ECDn \u0111i\u1EC3m \u0111\u1EA7u" },
+      { type: "point", allowExisting: true, allowNewOn: ALL_SURFACES, hint: "Ch\u1ECDn \u0111i\u1EC3m cu\u1ED1i" }
+    ],
+    build: buildVector
+  },
+  {
+    key: "polygon",
+    label: "\u0110a gi\xE1c",
+    hintIdle: "Ch\u1ECDn c\xE1c \u0111\u1EC9nh; click \u0111i\u1EC3m \u0111\u1EA7u \u0111\u1EC3 \u0111\xF3ng",
+    steps: [
+      { type: "point", allowExisting: true, allowNewOn: ALL_SURFACES, hint: "Ch\u1ECDn \u0111\u1EC9nh th\u1EE9 1" },
+      { type: "point", allowExisting: true, allowNewOn: ALL_SURFACES, hint: "Ch\u1ECDn \u0111\u1EC9nh th\u1EE9 2" },
+      { type: "point", allowExisting: true, allowNewOn: ALL_SURFACES, hint: "Ch\u1ECDn \u0111\u1EC9nh th\u1EE9 3" },
+      { type: "closingPoint", hint: "Click \u0111i\u1EC3m \u0111\u1EA7u \u0111\u1EC3 \u0111\xF3ng (ho\u1EB7c ch\u1ECDn th\xEAm \u0111\u1EC9nh)" }
+    ],
+    build: buildPolygon
+  },
+  {
+    key: "plane",
+    label: "M\u1EB7t ph\u1EB3ng (3 \u0111i\u1EC3m)",
+    hintIdle: "Ch\u1ECDn 3 \u0111i\u1EC3m \u0111\u1EC3 x\xE1c \u0111\u1ECBnh m\u1EB7t ph\u1EB3ng",
+    steps: [
+      { type: "point", allowExisting: true, allowNewOn: ALL_SURFACES, hint: "Ch\u1ECDn \u0111i\u1EC3m th\u1EE9 1 c\u1EE7a m\u1EB7t ph\u1EB3ng" },
+      { type: "point", allowExisting: true, allowNewOn: ALL_SURFACES, hint: "Ch\u1ECDn \u0111i\u1EC3m th\u1EE9 2" },
+      { type: "point", allowExisting: true, allowNewOn: ALL_SURFACES, hint: "Ch\u1ECDn \u0111i\u1EC3m th\u1EE9 3" }
+    ],
+    build: buildPlane
+  },
+  {
+    key: "pyramid",
+    label: "H\xECnh ch\xF3p",
+    hintIdle: "Ch\u1ECDn \u0111\xE1y \u0111a gi\xE1c r\u1ED3i ch\u1ECDn \u0111\u1EC9nh ch\xF3p",
+    steps: [
+      { type: "point", allowExisting: true, allowNewOn: NO_SURFACE, hint: "Ch\u1ECDn \u0111\u1EC9nh \u0111\xE1y 1" },
+      { type: "point", allowExisting: true, allowNewOn: NO_SURFACE, hint: "Ch\u1ECDn \u0111\u1EC9nh \u0111\xE1y 2" },
+      { type: "point", allowExisting: true, allowNewOn: NO_SURFACE, hint: "Ch\u1ECDn \u0111\u1EC9nh \u0111\xE1y 3" },
+      { type: "closingPoint", hint: "Click \u0111\u1EC9nh \u0111\xE1y \u0111\u1EA7u ti\xEAn \u0111\u1EC3 \u0111\xF3ng (ho\u1EB7c ch\u1ECDn th\xEAm \u0111\u1EC9nh)" },
+      { type: "point", allowExisting: true, allowNewOn: ALL_SURFACES, hint: "Ch\u1ECDn \u0111\u1EC9nh ch\xF3p" }
+    ],
+    build: buildPyramid
+  },
+  {
+    key: "prism",
+    label: "L\u0103ng tr\u1EE5",
+    hintIdle: "Ch\u1ECDn \u0111\xE1y \u0111a gi\xE1c r\u1ED3i nh\u1EADp chi\u1EC1u cao",
+    steps: [
+      { type: "point", allowExisting: true, allowNewOn: NO_SURFACE, hint: "Ch\u1ECDn \u0111\u1EC9nh \u0111\xE1y 1" },
+      { type: "point", allowExisting: true, allowNewOn: NO_SURFACE, hint: "Ch\u1ECDn \u0111\u1EC9nh \u0111\xE1y 2" },
+      { type: "point", allowExisting: true, allowNewOn: NO_SURFACE, hint: "Ch\u1ECDn \u0111\u1EC9nh \u0111\xE1y 3" },
+      { type: "closingPoint", hint: "Click \u0111\u1EC9nh \u0111\u1EA7u \u0111\u1EC3 \u0111\xF3ng \u0111\xE1y" },
+      { type: "number", prompt: "Chi\u1EC1u cao (theo tr\u1EE5c z)", min: 1e-4 }
+    ],
+    build: buildPrism
+  },
+  {
+    key: "tetrahedron",
+    label: "T\u1EE9 di\u1EC7n \u0111\u1EC1u",
+    hintIdle: "Ch\u1ECDn 2 \u0111i\u1EC3m x\xE1c \u0111\u1ECBnh c\u1EA1nh c\u1EE7a t\u1EE9 di\u1EC7n",
+    steps: [
+      { type: "point", allowExisting: true, allowNewOn: NO_SURFACE, hint: "Ch\u1ECDn \u0111i\u1EC3m 1" },
+      { type: "point", allowExisting: true, allowNewOn: NO_SURFACE, hint: "Ch\u1ECDn \u0111i\u1EC3m 2" }
+    ],
+    build: buildTetrahedron
+  },
+  {
+    key: "cube",
+    label: "L\u1EADp ph\u01B0\u01A1ng",
+    hintIdle: "Ch\u1ECDn 2 \u0111i\u1EC3m tr\xEAn n\u1EC1n x\xE1c \u0111\u1ECBnh c\u1EA1nh",
+    steps: [
+      { type: "point", allowExisting: true, allowNewOn: ["ground"], hint: "Ch\u1ECDn \u0111i\u1EC3m 1 (tr\xEAn n\u1EC1n)" },
+      { type: "point", allowExisting: true, allowNewOn: ["ground"], hint: "Ch\u1ECDn \u0111i\u1EC3m 2 (tr\xEAn n\u1EC1n)" }
+    ],
+    build: buildCube
+  },
+  {
+    key: "sphere",
+    label: "M\u1EB7t c\u1EA7u",
+    hintIdle: "Ch\u1ECDn t\xE2m r\u1ED3i \u0111i\u1EC3m tr\xEAn m\u1EB7t c\u1EA7u",
+    steps: [
+      { type: "point", allowExisting: true, allowNewOn: NO_SURFACE, hint: "Ch\u1ECDn t\xE2m m\u1EB7t c\u1EA7u" },
+      { type: "point", allowExisting: true, allowNewOn: ALL_SURFACES, hint: "Ch\u1ECDn \u0111i\u1EC3m tr\xEAn m\u1EB7t c\u1EA7u" }
+    ],
+    build: buildSphere
+  },
+  {
+    key: "cylinder",
+    label: "H\xECnh tr\u1EE5",
+    hintIdle: "Ch\u1ECDn t\xE2m \u0111\xE1y, t\xE2m tr\xEAn, r\u1ED3i nh\u1EADp b\xE1n k\xEDnh",
+    steps: [
+      { type: "point", allowExisting: true, allowNewOn: NO_SURFACE, hint: "Ch\u1ECDn t\xE2m \u0111\xE1y" },
+      { type: "point", allowExisting: true, allowNewOn: NO_SURFACE, hint: "Ch\u1ECDn t\xE2m tr\xEAn" },
+      { type: "number", prompt: "B\xE1n k\xEDnh", min: 1e-4 }
+    ],
+    build: buildCylinder
+  },
+  {
+    key: "cone",
+    label: "H\xECnh n\xF3n",
+    hintIdle: "Ch\u1ECDn t\xE2m \u0111\xE1y, \u0111\u1EC9nh, r\u1ED3i nh\u1EADp b\xE1n k\xEDnh",
+    steps: [
+      { type: "point", allowExisting: true, allowNewOn: NO_SURFACE, hint: "Ch\u1ECDn t\xE2m \u0111\xE1y" },
+      { type: "point", allowExisting: true, allowNewOn: NO_SURFACE, hint: "Ch\u1ECDn \u0111\u1EC9nh" },
+      { type: "number", prompt: "B\xE1n k\xEDnh", min: 1e-4 }
+    ],
+    build: buildCone
+  }
+];
+
+// src/stamps/geometry-3d/editor/tools/controller.ts
+function stepHint(step) {
+  return step.type === "number" ? step.prompt : step.hint;
+}
+var ToolController = class {
+  constructor(store) {
+    this.store = store;
+    this.state = { tool: null, stepIndex: 0, collected: [], hint: "" };
+    this.listeners = /* @__PURE__ */ new Set();
+    this.selectTool("move");
+  }
+  getState() {
+    return this.state;
+  }
+  on(cb) {
+    this.listeners.add(cb);
+    return () => {
+      this.listeners.delete(cb);
+    };
+  }
+  selectTool(key) {
+    const tool = TOOLS.find((t) => t.key === key) ?? TOOLS.find((t) => t.key === "move");
+    const firstStep = tool.steps[0];
+    this.state = {
+      tool,
+      stepIndex: 0,
+      collected: [],
+      hint: firstStep ? stepHint(firstStep) : tool.hintIdle
+    };
+    this.notify();
+  }
+  cancel() {
+    this.selectTool("move");
+  }
+  consumeHit(hit) {
+    const tool = this.state.tool;
+    if (!tool) return false;
+    const step = tool.steps[this.state.stepIndex];
+    if (!step) return false;
+    if (step.type === "closingPoint") {
+      if (hit.kind === "empty") return false;
+      if (hit.kind === "existingPoint") {
+        this.state.collected.push({ step, hit });
+        this.state.stepIndex++;
+        this.advance();
+        return true;
+      }
+      const prevStep = tool.steps[this.state.stepIndex - 1];
+      if (!prevStep || prevStep.type !== "point") return false;
+      if (!this.hitMatchesStep(hit, prevStep)) return false;
+      this.state.collected.push({ step: prevStep, hit });
+      this.notify();
+      return true;
+    }
+    if (!this.hitMatchesStep(hit, step)) return false;
+    this.state.collected.push({ step, hit });
+    this.state.stepIndex++;
+    this.advance();
+    return true;
+  }
+  consumeNumber(value) {
+    const tool = this.state.tool;
+    if (!tool) return false;
+    const step = tool.steps[this.state.stepIndex];
+    if (!step || step.type !== "number") return false;
+    if (step.min != null && value < step.min) return false;
+    if (step.max != null && value > step.max) return false;
+    this.state.collected.push({ step, value });
+    this.state.stepIndex++;
+    this.advance();
+    return true;
+  }
+  hitMatchesStep(hit, step) {
+    if (step.type !== "point" && step.type !== "closingPoint") return false;
+    if (hit.kind === "empty") return false;
+    if (step.type === "closingPoint") return hit.kind === "existingPoint";
+    if (hit.kind === "existingPoint") return step.allowExisting;
+    const surfaceMap = {
+      onGround: "ground",
+      onAxis: "axis",
+      onPlane: "plane",
+      onLine: "line",
+      onPolygon: "polygon",
+      onSphere: "sphere"
+    };
+    const k = surfaceMap[hit.kind];
+    return k != null && step.type === "point" && step.allowNewOn.includes(k);
+  }
+  advance() {
+    const tool = this.state.tool;
+    if (this.state.stepIndex >= tool.steps.length) {
+      tool.build(this.state.collected, this.store);
+      if (tool.repeatAfterBuild) {
+        this.state.stepIndex = 0;
+        this.state.collected = [];
+        this.state.hint = stepHint(tool.steps[0]);
+        this.notify();
+      } else {
+        this.selectTool("move");
+      }
+      return;
+    }
+    this.state.hint = stepHint(tool.steps[this.state.stepIndex]);
+    this.notify();
+  }
+  notify() {
+    for (const cb of this.listeners) cb(this.state);
+  }
+};
+
+// src/stamps/geometry-3d/editor/hitTest/rayCast.ts
+function screenToRay(screen, view) {
+  const near = unproject(screen, view, 20);
+  const far = unproject(screen, view, -20);
+  const dir = [far[0] - near[0], far[1] - near[1], far[2] - near[2]];
+  const n = Math.sqrt(dir[0] ** 2 + dir[1] ** 2 + dir[2] ** 2);
+  const norm3 = n === 0 ? [0, 0, -1] : [dir[0] / n, dir[1] / n, dir[2] / n];
+  return { origin: near, dir: norm3 };
+}
+function unproject(screen, view, depth) {
+  if (typeof view.unprojectScreen === "function") {
+    const v = view.unprojectScreen(screen.x, screen.y, depth);
+    return [v[0], v[1], v[2]];
+  }
+  if (typeof view.project3DTo2D === "function") {
+    const p0 = view.project3DTo2D(0, 0, 0);
+    const px = view.project3DTo2D(1, 0, 0);
+    const py = view.project3DTo2D(0, 1, 0);
+    const pz = view.project3DTo2D(0, 0, 1);
+    const ox = p0[1], oy = p0[2];
+    const a = px[1] - ox, b = py[1] - ox, c = pz[1] - ox;
+    const d = px[2] - oy, e = py[2] - oy, f = pz[2] - oy;
+    const rhsX = screen.x - ox - c * depth;
+    const rhsY = screen.y - oy - f * depth;
+    const det = a * e - b * d;
+    if (Math.abs(det) < 1e-9) return [0, 0, depth];
+    const x = (e * rhsX - b * rhsY) / det;
+    const y = (-d * rhsX + a * rhsY) / det;
+    return [x, y, depth];
+  }
+  throw new Error("rayCast: view has neither unprojectScreen nor project3DTo2D");
+}
+
+// src/stamps/geometry-3d/editor/hitTest/intersect.ts
+var EPS2 = 1e-9;
+function dot2(a, b) {
+  return a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
+}
+function sub2(a, b) {
+  return [a[0] - b[0], a[1] - b[1], a[2] - b[2]];
+}
+function add2(a, b) {
+  return [a[0] + b[0], a[1] + b[1], a[2] + b[2]];
+}
+function scale2(a, k) {
+  return [a[0] * k, a[1] * k, a[2] * k];
+}
+function norm2(a) {
+  return dot2(a, a);
+}
+function rayPlane(ray, plane) {
+  const denom = dot2(ray.dir, plane.normal);
+  if (Math.abs(denom) < EPS2) return null;
+  const t = dot2(sub2(plane.point, ray.origin), plane.normal) / denom;
+  if (t < 0) return null;
+  return { point: add2(ray.origin, scale2(ray.dir, t)), t };
+}
+function rayGround(ray) {
+  return rayPlane(ray, { point: [0, 0, 0], normal: [0, 0, 1] });
+}
+function raySphere(ray, sphere) {
+  const oc = sub2(ray.origin, sphere.center);
+  const b = dot2(oc, ray.dir);
+  const c = dot2(oc, oc) - sphere.radius * sphere.radius;
+  const disc = b * b - c;
+  if (disc < 0) return null;
+  const sqrtD = Math.sqrt(disc);
+  const t1 = -b - sqrtD;
+  const t2 = -b + sqrtD;
+  const t = t1 >= 0 ? t1 : t2;
+  if (t < 0) return null;
+  return { point: add2(ray.origin, scale2(ray.dir, t)), t };
+}
+function rayLineSegment(ray, seg, maxDistance) {
+  const u = ray.dir;
+  const v = sub2(seg.b, seg.a);
+  const w0 = sub2(ray.origin, seg.a);
+  const a = dot2(u, u);
+  const bb = dot2(u, v);
+  const cc = dot2(v, v);
+  const d = dot2(u, w0);
+  const e = dot2(v, w0);
+  const denom = a * cc - bb * bb;
+  if (Math.abs(denom) < EPS2) return null;
+  const sc = (bb * e - cc * d) / denom;
+  const tc = (a * e - bb * d) / denom;
+  if (sc < 0 || tc < 0 || tc > 1) return null;
+  const pRay = add2(ray.origin, scale2(u, sc));
+  const pSeg = add2(seg.a, scale2(v, tc));
+  const dist2 = norm2(sub2(pRay, pSeg));
+  if (dist2 > maxDistance * maxDistance) return null;
+  return { point: pSeg, t: sc, tOnSegment: tc };
+}
+
+// src/stamps/geometry-3d/editor/hitTest/snapping.ts
+function findSnapPoint(screen, view, state, pixelRadius = 8) {
+  const board = view?.board;
+  const ux = typeof board?.unitX === "number" && board.unitX > 0 ? board.unitX : 1;
+  const uy = typeof board?.unitY === "number" && board.unitY > 0 ? board.unitY : ux;
+  const rxUser = pixelRadius / ux;
+  const ryUser = pixelRadius / uy;
+  let best = null;
+  for (const obj of listObjects(state)) {
+    if (obj.kind !== "point3d") continue;
+    if (!obj.visible) continue;
+    const attrs = obj.attrs;
+    const world = constraintToWorld(attrs.constraint, state);
+    const proj = view.project3DTo2D?.(world[0], world[1], world[2]);
+    if (!proj) continue;
+    const dxN = (proj[1] - screen.x) / rxUser;
+    const dyN = (proj[2] - screen.y) / ryUser;
+    const d2 = dxN * dxN + dyN * dyN;
+    if (d2 <= 1 && (best === null || d2 < best.d2)) {
+      best = { id: obj.id, d2 };
+    }
+  }
+  return best?.id ?? null;
+}
+
+// src/stamps/geometry-3d/editor/hitTest/hitTest.ts
+var AXIS_PIXEL_THRESHOLD = 12;
+function hitTest(screen, view, state) {
+  const board = view?.board;
+  const ux = typeof board?.unitX === "number" && board.unitX > 0 ? board.unitX : 1;
+  const axisThresholdUser = AXIS_PIXEL_THRESHOLD / ux;
+  const snap = findSnapPoint(screen, view, state);
+  if (snap) return { kind: "existingPoint", pointId: snap };
+  const ray = screenToRay(screen, view);
+  let bestSphere = null;
+  for (const obj of listObjects(state)) {
+    if (obj.kind !== "sphere3d" || !obj.visible) continue;
+    const attrs = obj.attrs;
+    const centerPoint = state.objects[attrs.center];
+    const surfacePoint = state.objects[attrs.surfacePoint];
+    if (!centerPoint || centerPoint.kind !== "point3d") continue;
+    if (!surfacePoint || surfacePoint.kind !== "point3d") continue;
+    const center = constraintToWorld(centerPoint.attrs.constraint, state);
+    const surface = constraintToWorld(surfacePoint.attrs.constraint, state);
+    const radius = Math.hypot(
+      surface[0] - center[0],
+      surface[1] - center[1],
+      surface[2] - center[2]
+    );
+    const sh = raySphere(ray, { center, radius });
+    if (sh && (bestSphere === null || sh.t < bestSphere.t)) {
+      bestSphere = { id: obj.id, t: sh.t, world: sh.point };
+    }
+  }
+  if (view.project3DTo2D) {
+    const axes = [
+      { axis: "x", a: [-10, 0, 0], b: [10, 0, 0] },
+      { axis: "y", a: [0, -10, 0], b: [0, 10, 0] },
+      { axis: "z", a: [0, 0, -10], b: [0, 0, 10] }
+    ];
+    for (const ax of axes) {
+      const pa = view.project3DTo2D(ax.a[0], ax.a[1], ax.a[2]);
+      const pb = view.project3DTo2D(ax.b[0], ax.b[1], ax.b[2]);
+      const d = distScreenPointToSegment(screen, [pa[1], pa[2]], [pb[1], pb[2]]);
+      if (d <= axisThresholdUser) {
+        const hit = rayLineSegment(ray, { a: ax.a, b: ax.b }, 1e3);
+        if (hit) {
+          const t = ax.axis === "x" ? hit.point[0] : ax.axis === "y" ? hit.point[1] : hit.point[2];
+          return { kind: "onAxis", axis: ax.axis, t, world: hit.point };
+        }
+      }
+    }
+  }
+  let bestPlane = null;
+  for (const obj of listObjects(state)) {
+    if (obj.kind !== "plane3d" || !obj.visible) continue;
+    const basis = planeBasis(obj.attrs, state);
+    if (!basis) continue;
+    const ph = rayPlane(ray, { point: basis.origin, normal: basis.normal });
+    if (ph && (bestPlane === null || ph.t < bestPlane.t)) {
+      bestPlane = { id: obj.id, t: ph.t, world: ph.point, basis };
+    }
+  }
+  if (bestPlane && (!bestSphere || bestPlane.t < bestSphere.t)) {
+    const rel = [
+      bestPlane.world[0] - bestPlane.basis.origin[0],
+      bestPlane.world[1] - bestPlane.basis.origin[1],
+      bestPlane.world[2] - bestPlane.basis.origin[2]
+    ];
+    const b1n = dot3(bestPlane.basis.basis1, bestPlane.basis.basis1);
+    const b2n = dot3(bestPlane.basis.basis2, bestPlane.basis.basis2);
+    const u = b1n === 0 ? 0 : dot3(rel, bestPlane.basis.basis1) / b1n;
+    const v = b2n === 0 ? 0 : dot3(rel, bestPlane.basis.basis2) / b2n;
+    return { kind: "onPlane", planeId: bestPlane.id, u, v, world: bestPlane.world };
+  }
+  if (bestSphere) {
+    const sph = state.objects[bestSphere.id];
+    if (sph && sph.kind === "sphere3d") {
+      const centerPt = state.objects[sph.attrs.center];
+      if (centerPt && centerPt.kind === "point3d") {
+        const center = constraintToWorld(centerPt.attrs.constraint, state);
+        const relX = bestSphere.world[0] - center[0];
+        const relY = bestSphere.world[1] - center[1];
+        const relZ = bestSphere.world[2] - center[2];
+        const r = Math.hypot(relX, relY, relZ);
+        const phi = r === 0 ? 0 : Math.acos(relZ / r);
+        const theta = Math.atan2(relY, relX);
+        return { kind: "onSphere", sphereId: bestSphere.id, theta, phi, world: bestSphere.world };
+      }
+    }
+  }
+  const g = rayGround(ray);
+  if (g) return { kind: "onGround", world: g.point };
+  return { kind: "empty" };
+}
+function distScreenPointToSegment(p, a, b) {
+  const vx = b[0] - a[0];
+  const vy = b[1] - a[1];
+  const wx = p.x - a[0];
+  const wy = p.y - a[1];
+  const c1 = vx * wx + vy * wy;
+  if (c1 <= 0) return Math.hypot(wx, wy);
+  const c2 = vx * vx + vy * vy;
+  if (c2 <= c1) return Math.hypot(p.x - b[0], p.y - b[1]);
+  const t = c1 / c2;
+  const px = a[0] + t * vx;
+  const py = a[1] + t * vy;
+  return Math.hypot(p.x - px, p.y - py);
+}
+function planeBasis(plane, state) {
+  const p1Obj = state.objects[plane.p1];
+  const p2Obj = state.objects[plane.p2];
+  const p3Obj = state.objects[plane.p3];
+  if (!p1Obj || p1Obj.kind !== "point3d") return null;
+  if (!p2Obj || p2Obj.kind !== "point3d") return null;
+  if (!p3Obj || p3Obj.kind !== "point3d") return null;
+  const p1 = constraintToWorld(p1Obj.attrs.constraint, state);
+  const p2 = constraintToWorld(p2Obj.attrs.constraint, state);
+  const p3 = constraintToWorld(p3Obj.attrs.constraint, state);
+  const basis1 = [p2[0] - p1[0], p2[1] - p1[1], p2[2] - p1[2]];
+  const tmp = [p3[0] - p1[0], p3[1] - p1[1], p3[2] - p1[2]];
+  const cx = basis1[1] * tmp[2] - basis1[2] * tmp[1];
+  const cy = basis1[2] * tmp[0] - basis1[0] * tmp[2];
+  const cz = basis1[0] * tmp[1] - basis1[1] * tmp[0];
+  const cLen = Math.hypot(cx, cy, cz);
+  if (cLen === 0) return null;
+  const normal = [cx / cLen, cy / cLen, cz / cLen];
+  const basis2 = [
+    normal[1] * basis1[2] - normal[2] * basis1[1],
+    normal[2] * basis1[0] - normal[0] * basis1[2],
+    normal[0] * basis1[1] - normal[1] * basis1[0]
+  ];
+  return { origin: p1, basis1, basis2, normal };
+}
+function dot3(a, b) {
+  return a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
+}
+var MiniBoard3D = React3.forwardRef(
+  function MiniBoard3D2(props, ref) {
+    const containerRef = React3.useRef(null);
+    const boardRef = React3.useRef(null);
+    const viewRef = React3.useRef(null);
+    const {
+      isDark,
+      onView3DReady,
+      onPointerClick,
+      onPointerMove,
+      onPointerLeave,
+      shouldStartPointDrag,
+      onPointerDrag,
+      onPointerDragEnd,
+      isHoveringObject
+    } = props;
+    const onView3DReadyRef = React3.useRef(onView3DReady);
+    const onPointerClickRef = React3.useRef(onPointerClick);
+    const onPointerMoveRef = React3.useRef(onPointerMove);
+    const onPointerLeaveRef = React3.useRef(onPointerLeave);
+    const shouldStartPointDragRef = React3.useRef(shouldStartPointDrag);
+    const onPointerDragRef = React3.useRef(onPointerDrag);
+    const onPointerDragEndRef = React3.useRef(onPointerDragEnd);
+    const isHoveringObjectRef = React3.useRef(isHoveringObject);
+    onView3DReadyRef.current = onView3DReady;
+    onPointerClickRef.current = onPointerClick;
+    onPointerMoveRef.current = onPointerMove;
+    onPointerLeaveRef.current = onPointerLeave;
+    shouldStartPointDragRef.current = shouldStartPointDrag;
+    onPointerDragRef.current = onPointerDrag;
+    onPointerDragEndRef.current = onPointerDragEnd;
+    isHoveringObjectRef.current = isHoveringObject;
+    React3.useImperativeHandle(
+      ref,
+      () => ({
+        getBoard: () => boardRef.current,
+        getView3D: () => viewRef.current,
+        getSvgElement: () => containerRef.current?.querySelector("svg") ?? null
+      }),
+      []
+    );
+    React3.useEffect(() => {
+      const div = containerRef.current;
+      if (!div) return;
+      let cancelled = false;
+      let board = null;
+      let svgEl = null;
+      let handlePointerDown = null;
+      let handlePointerMove = null;
+      let handlePointerUp = null;
+      let handlePointerLeave = null;
+      let wheelCleanup = null;
+      let freeBoard = null;
+      void (async () => {
+        let initResult;
+        try {
+          initResult = await initJxgBoard(div, {
+            label: "MiniBoard.3d",
+            defaults: { disableElementHighlight: true },
+            boardOptions: {
+              boundingbox: [-6, 6, 6, -6],
+              keepaspectratio: true,
+              axis: false,
+              showCopyright: false,
+              showNavigation: false,
+              renderer: "svg",
+              // Wheel zoom được tự xử lý bằng Ctrl/Cmd + wheel ở dưới (Excalidraw-style).
+              zoom: { wheel: false }
+            }
+          });
+        } catch {
+          return;
+        }
+        if (cancelled || !containerRef.current) {
+          initResult.cleanup();
+          return;
+        }
+        board = initResult.board;
+        freeBoard = initResult.cleanup;
+        if (cancelled || !board) return;
+        boardRef.current = board;
+        wheelCleanup = attachJxgWheelZoom(div, board, "MiniBoard.3d");
+        let view = null;
+        try {
+          const baseAttrs = VIEW3D_ATTRS(isDark);
+          view = board.create(
+            "view3d",
+            [
+              [-5, -5],
+              [10, 10],
+              [
+                [DEFAULT_VIEW3D.bbox3D[0], DEFAULT_VIEW3D.bbox3D[3]],
+                [DEFAULT_VIEW3D.bbox3D[1], DEFAULT_VIEW3D.bbox3D[4]],
+                [DEFAULT_VIEW3D.bbox3D[2], DEFAULT_VIEW3D.bbox3D[5]]
+              ]
+            ],
+            {
+              ...baseAttrs,
+              // JSXGraph view3d đọc giá trị khởi tạo từ az.slider.start (không
+              // phải az.value). Pass nhầm `value` → JSXGraph dùng default
+              // 1.0/0.3, khiến DEFAULT_VIEW3D bị bỏ qua.
+              az: { ...baseAttrs.az, slider: { ...baseAttrs.az.slider, start: DEFAULT_VIEW3D.azimuth } },
+              el: { ...baseAttrs.el, slider: { ...baseAttrs.el.slider, start: DEFAULT_VIEW3D.elevation } }
+            }
+          );
+        } catch {
+        }
+        viewRef.current = view;
+        if (view) {
+          try {
+            view.create(
+              "plane3d",
+              [
+                [0, 0, 0],
+                [1, 0, 0],
+                [0, 1, 0],
+                GROUND_PLANE_RANGE,
+                GROUND_PLANE_RANGE
+              ],
+              GROUND_PLANE_ATTRS(isDark)
+            );
+          } catch {
+          }
+          onView3DReadyRef.current?.(view, board);
+        }
+        svgEl = containerRef.current?.querySelector("svg") ?? null;
+        if (svgEl) {
+          const p2 = paletteFor(isDark);
+          svgEl.style.background = p2.view3dBg;
+          const pixelToUser = (e) => {
+            const rect = svgEl.getBoundingClientRect();
+            const px = e.clientX - rect.left;
+            const py = e.clientY - rect.top;
+            const b = board;
+            if (!b || !b.origin || !b.origin.scrCoords) {
+              return { x: px, y: py };
+            }
+            const ox = b.origin.scrCoords[1];
+            const oy = b.origin.scrCoords[2];
+            const ux = b.unitX || 1;
+            const uy = b.unitY || 1;
+            return { x: (px - ox) / ux, y: (oy - py) / uy };
+          };
+          const DRAG_THRESHOLD = 4;
+          const AZ_PER_PX = 0.01;
+          const EL_PER_PX = 0.01;
+          const EL_LIMIT = Math.PI / 2 - 0.05;
+          let dragStart = null;
+          let dragging = false;
+          let pointDragMode = false;
+          let startAz = 0;
+          let startEl = 0;
+          const readAng = (s) => {
+            if (!s) return 0;
+            if (typeof s.Value === "function") {
+              try {
+                return s.Value();
+              } catch {
+              }
+            }
+            return typeof s.value === "number" ? s.value : 0;
+          };
+          const setAng = (s, v) => {
+            if (!s) return;
+            if (typeof s.setValue === "function") {
+              try {
+                s.setValue(v);
+                return;
+              } catch {
+              }
+            }
+            s.value = v;
+          };
+          handlePointerDown = (e) => {
+            if (!svgEl) return;
+            dragStart = { x: e.clientX, y: e.clientY };
+            dragging = false;
+            pointDragMode = false;
+            const screen = pixelToUser(e);
+            try {
+              pointDragMode = shouldStartPointDragRef.current?.(screen) ?? false;
+            } catch {
+              pointDragMode = false;
+            }
+            if (!pointDragMode) {
+              const v = viewRef.current;
+              startAz = readAng(v?.az_slide ?? v?.az);
+              startEl = readAng(v?.el_slide ?? v?.el);
+            }
+            try {
+              svgEl.setPointerCapture?.(e.pointerId);
+            } catch {
+            }
+          };
+          handlePointerMove = (e) => {
+            if (!svgEl) return;
+            if (dragStart) {
+              const dx = e.clientX - dragStart.x;
+              const dy = e.clientY - dragStart.y;
+              if (!dragging && Math.hypot(dx, dy) > DRAG_THRESHOLD) dragging = true;
+              if (dragging) {
+                if (pointDragMode) {
+                  onPointerDragRef.current?.(pixelToUser(e));
+                  return;
+                }
+                const v = viewRef.current;
+                const newAz = startAz + dx * AZ_PER_PX;
+                let newEl = startEl - dy * EL_PER_PX;
+                if (newEl > EL_LIMIT) newEl = EL_LIMIT;
+                if (newEl < -EL_LIMIT) newEl = -EL_LIMIT;
+                setAng(v?.az_slide ?? v?.az, newAz);
+                setAng(v?.el_slide ?? v?.el, newEl);
+                try {
+                  v?.board?.update?.();
+                } catch {
+                }
+                return;
+              }
+            }
+            const screen = pixelToUser(e);
+            onPointerMoveRef.current?.(screen);
+            const hovering = isHoveringObjectRef.current?.(screen) ?? false;
+            svgEl.style.cursor = hovering ? "pointer" : "";
+          };
+          handlePointerUp = (e) => {
+            if (!svgEl) return;
+            const wasDrag = dragging;
+            const hadDown = dragStart !== null;
+            const wasPointDrag = pointDragMode;
+            dragStart = null;
+            dragging = false;
+            pointDragMode = false;
+            try {
+              svgEl.releasePointerCapture?.(e.pointerId);
+            } catch {
+            }
+            if (hadDown && wasPointDrag) {
+              onPointerDragEndRef.current?.(pixelToUser(e));
+              return;
+            }
+            if (hadDown && !wasDrag) {
+              onPointerClickRef.current?.(pixelToUser(e));
+            }
+          };
+          handlePointerLeave = () => {
+            if (pointDragMode) {
+              try {
+                onPointerDragEndRef.current?.({ x: 0, y: 0 });
+              } catch {
+              }
+            }
+            dragStart = null;
+            dragging = false;
+            pointDragMode = false;
+            onPointerLeaveRef.current?.();
+          };
+          svgEl.addEventListener("pointerdown", handlePointerDown);
+          svgEl.addEventListener("pointermove", handlePointerMove);
+          svgEl.addEventListener("pointerup", handlePointerUp);
+          svgEl.addEventListener("pointercancel", handlePointerUp);
+          svgEl.addEventListener("pointerleave", handlePointerLeave);
+        }
+      })();
+      return () => {
+        cancelled = true;
+        if (wheelCleanup) {
+          wheelCleanup();
+          wheelCleanup = null;
+        }
+        if (svgEl) {
+          if (handlePointerDown) svgEl.removeEventListener("pointerdown", handlePointerDown);
+          if (handlePointerMove) svgEl.removeEventListener("pointermove", handlePointerMove);
+          if (handlePointerUp) {
+            svgEl.removeEventListener("pointerup", handlePointerUp);
+            svgEl.removeEventListener("pointercancel", handlePointerUp);
+          }
+          if (handlePointerLeave) svgEl.removeEventListener("pointerleave", handlePointerLeave);
+        }
+        if (freeBoard) {
+          freeBoard();
+          freeBoard = null;
+        }
+        boardRef.current = null;
+        viewRef.current = null;
+      };
+    }, [isDark]);
+    const p = paletteFor(isDark);
+    return /* @__PURE__ */ jsx(
+      "div",
+      {
+        "data-testid": "mini-board-3d",
+        ref: containerRef,
+        style: {
+          width: "100%",
+          height: "100%",
+          minHeight: 400,
+          background: p.view3dBg,
+          position: "relative",
+          // Clip JSXGraph mesh3d paths projecting outside the container.
+          overflow: "hidden"
+        }
+      }
+    );
+  }
+);
+
+// src/stamps/geometry-3d/editor/preview3d.ts
+var PREVIEW_STYLE = {
+  strokeColor: "#3b82f6",
+  strokeWidth: 1.5,
+  strokeOpacity: 0.7,
+  dash: 2,
+  fixed: true,
+  highlight: false,
+  withLabel: false
+};
+var Preview3DManager = class {
+  constructor(view, store) {
+    this.phantom = null;
+    this.pickPts = [];
+    this.shapes = [];
+    this.disposed = false;
+    this.view = view;
+    this.store = store;
+  }
+  clear() {
+    const v = this.view;
+    for (const s of this.shapes) {
+      try {
+        v.removeObject?.(s);
+      } catch {
+      }
+    }
+    this.shapes = [];
+    for (const p of this.pickPts) {
+      try {
+        v.removeObject?.(p);
+      } catch {
+      }
+    }
+    this.pickPts = [];
+    if (this.phantom) {
+      try {
+        v.removeObject?.(this.phantom);
+      } catch {
+      }
+      this.phantom = null;
+    }
+  }
+  dispose() {
+    if (this.disposed) return;
+    this.clear();
+    this.disposed = true;
+  }
+  /**
+   * Rebuild the preview from scratch using the controller's current `tool` +
+   * `collected` args + the live `hoverHit` from the most recent pointer move.
+   *
+   * Returns early (and clears) when there's nothing to preview:
+   *  - no tool selected
+   *  - no points collected yet
+   *  - hover is empty / off-surface
+   *  - any collected arg lacks a hit (number steps)
+   */
+  update(tool, collected, hoverHit) {
+    if (this.disposed) return;
+    this.clear();
+    if (!tool || tool === "move") return;
+    if (collected.length === 0) return;
+    if (hoverHit.kind === "empty") return;
+    const phantomCoords = this.hitToCoords(hoverHit);
+    if (!phantomCoords) return;
+    const pickCoords = [];
+    for (const c of collected) {
+      if (!c.hit) return;
+      const coords = this.hitToCoords(c.hit);
+      if (!coords) return;
+      pickCoords.push(coords);
+    }
+    try {
+      this.phantom = this.view.create("point3d", phantomCoords, {
+        visible: false,
+        fixed: true,
+        withLabel: false,
+        name: ""
+      });
+    } catch {
+      return;
+    }
+    for (const coords of pickCoords) {
+      try {
+        const p = this.view.create("point3d", coords, {
+          visible: false,
+          fixed: true,
+          withLabel: false,
+          name: ""
+        });
+        this.pickPts.push(p);
+      } catch {
+        return;
+      }
+    }
+    this.buildShape(tool);
+  }
+  buildShape(tool) {
+    const phantom = this.phantom;
+    const picks = this.pickPts;
+    if (!phantom || picks.length === 0) return;
+    const last = picks[picks.length - 1];
+    try {
+      switch (tool) {
+        case "segment":
+          this.shapes.push(this.makeLine3d(picks[0], phantom, false, false));
+          return;
+        case "line":
+          this.shapes.push(this.makeLine3d(picks[0], phantom, true, true));
+          return;
+        case "ray":
+          this.shapes.push(this.makeLine3d(picks[0], phantom, false, true));
+          return;
+        case "vector":
+          this.shapes.push(this.view.create("line3d", [picks[0], phantom], {
+            ...PREVIEW_STYLE,
+            straightFirst: false,
+            straightLast: false,
+            lastArrow: { type: 1 }
+          }));
+          return;
+        case "polygon":
+        case "pyramid":
+        case "prism": {
+          for (let i = 0; i < picks.length - 1; i += 1) {
+            this.shapes.push(this.makeLine3d(picks[i], picks[i + 1], false, false));
+          }
+          this.shapes.push(this.makeLine3d(last, phantom, false, false));
+          if (picks.length >= 2) {
+            this.shapes.push(this.makeLine3d(picks[0], phantom, false, false));
+          }
+          return;
+        }
+        case "plane": {
+          if (picks.length === 1) {
+            this.shapes.push(this.makeLine3d(picks[0], phantom, false, false));
+          } else if (picks.length === 2) {
+            this.shapes.push(this.makeLine3d(picks[0], picks[1], false, false));
+            this.shapes.push(this.makeLine3d(picks[1], phantom, false, false));
+            this.shapes.push(this.makeLine3d(picks[0], phantom, false, false));
+          }
+          return;
+        }
+        case "sphere": {
+          this.shapes.push(this.view.create("sphere3d", [picks[0], phantom], {
+            ...PREVIEW_STYLE,
+            fillColor: "none",
+            fillOpacity: 0
+          }));
+          return;
+        }
+        case "tetrahedron":
+        case "cube":
+        case "cylinder":
+        case "cone":
+          this.shapes.push(this.makeLine3d(picks[0], phantom, false, false));
+          return;
+        default:
+          return;
+      }
+    } catch {
+    }
+  }
+  makeLine3d(a, b, straightFirst, straightLast) {
+    return this.view.create("line3d", [a, b], {
+      ...PREVIEW_STYLE,
+      straightFirst,
+      straightLast
+    });
+  }
+  hitToCoords(hit) {
+    if (hit.kind === "existingPoint") {
+      const obj = this.store.getState().objects[hit.pointId];
+      if (!obj || obj.kind !== "point3d") return null;
+      return constraintToWorld(obj.attrs.constraint, this.store.getState());
+    }
+    if ("world" in hit) return hit.world;
+    return null;
+  }
+};
+function StatusHint(props) {
+  const { hint, hoverLabel } = props;
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      "data-testid": "status-hint",
+      className: "border-t border-zinc-200 bg-zinc-50 px-3 py-1.5 text-xs text-zinc-700 dark:border-zinc-700 dark:bg-zinc-900 dark:text-zinc-300",
+      children: [
+        /* @__PURE__ */ jsxs("span", { children: [
+          "\u{1F4D0} ",
+          hint || "Ch\u1ECDn c\xF4ng c\u1EE5 trong b\u1EA3ng b\xEAn tr\xE1i"
+        ] }),
+        hoverLabel ? /* @__PURE__ */ jsxs("span", { className: "ml-3 text-zinc-500", children: [
+          "\u2014 \u0111ang tr\xEAn: ",
+          hoverLabel
+        ] }) : null
+      ]
+    }
+  );
+}
+function usePointDrag(opts) {
+  const { store, boardRef, selectedToolRef } = opts;
+  const draggedPointRef = React3.useRef(null);
+  const dragStartRef = React3.useRef(null);
+  const dragSnapshotRef = React3.useRef(null);
+  const dragMutatedRef = React3.useRef(false);
+  const shouldStartPointDrag = React3.useCallback(
+    (screen) => {
+      const view = boardRef.current?.getView3D();
+      if (!view) return false;
+      const tool = selectedToolRef.current;
+      if (tool !== "point" && tool !== "move") return false;
+      let hit;
+      try {
+        hit = hitTest(screen, view, store.getState());
+      } catch {
+        return false;
+      }
+      if (hit.kind === "existingPoint") {
+        const pt = store.getState().objects[hit.pointId];
+        if (!pt || pt.kind !== "point3d") return false;
+        dragSnapshotRef.current = store.getState();
+        dragMutatedRef.current = false;
+        draggedPointRef.current = hit.pointId;
+        dragStartRef.current = {
+          screen,
+          world: constraintToWorld(pt.attrs.constraint, store.getState())
+        };
+        return true;
+      }
+      if (tool === "point" && (hit.kind === "onGround" || hit.kind === "onAxis")) {
+        dragSnapshotRef.current = store.getState();
+        dragMutatedRef.current = false;
+        const constraint = hitToConstraint(hit);
+        if (!constraint) {
+          dragSnapshotRef.current = null;
+          return false;
+        }
+        let id = null;
+        store.withoutHistory(() => {
+          const stateBefore = store.getState();
+          const newId = `p${stateBefore.counter + 1}`;
+          const label = nextLabel(stateBefore, "point3d");
+          store.dispatch({
+            type: "ADD",
+            payload: {
+              obj: {
+                id: newId,
+                kind: "point3d",
+                label,
+                visible: true,
+                locked: false,
+                layer: "default",
+                schemaVersion: 1,
+                attrs: { constraint }
+              }
+            }
+          });
+          id = newId;
+        });
+        if (!id) {
+          dragSnapshotRef.current = null;
+          return false;
+        }
+        draggedPointRef.current = id;
+        dragStartRef.current = {
+          screen,
+          world: [hit.world[0], hit.world[1], hit.world[2]]
+        };
+        return true;
+      }
+      if (tool === "point") {
+        dragSnapshotRef.current = null;
+        draggedPointRef.current = null;
+        dragStartRef.current = null;
+        return true;
+      }
+      return false;
+    },
+    [store, boardRef, selectedToolRef]
+  );
+  const onPointerDrag = React3.useCallback(
+    (screen) => {
+      const pointId = draggedPointRef.current;
+      const start = dragStartRef.current;
+      if (!pointId || !start) return;
+      const view = boardRef.current?.getView3D();
+      if (!view) return;
+      const tool = selectedToolRef.current;
+      let nextWorld;
+      if (tool === "point") {
+        const dz = screen.y - start.screen.y;
+        nextWorld = [start.world[0], start.world[1], start.world[2] + dz];
+      } else if (tool === "move") {
+        try {
+          const ray = screenToRay(screen, view);
+          const hit = rayPlane(ray, { point: [0, 0, start.world[2]], normal: [0, 0, 1] });
+          if (!hit) return;
+          nextWorld = [hit.point[0], hit.point[1], start.world[2]];
+        } catch {
+          return;
+        }
+      } else {
+        return;
+      }
+      const obj = store.getState().objects[pointId];
+      if (!obj || obj.kind !== "point3d") return;
+      const free = { kind: "free", x: nextWorld[0], y: nextWorld[1], z: nextWorld[2] };
+      store.withoutHistory(() => {
+        store.dispatch({ type: "UPDATE_ATTRS", payload: { id: pointId, patch: { constraint: free } } });
+      });
+      dragMutatedRef.current = true;
+    },
+    [store, boardRef, selectedToolRef]
+  );
+  const onPointerDragEnd = React3.useCallback(() => {
+    const snap = dragSnapshotRef.current;
+    dragSnapshotRef.current = null;
+    draggedPointRef.current = null;
+    dragStartRef.current = null;
+    dragMutatedRef.current = false;
+    if (snap) {
+      const current = store.getState();
+      store.withoutHistory(() => {
+        store.dispatch({ type: "LOAD", payload: { state: snap } });
+      });
+      store.dispatch({ type: "LOAD", payload: { state: current } });
+    }
+  }, [store]);
+  const isDragging = React3.useCallback(() => draggedPointRef.current !== null, []);
+  return { shouldStartPointDrag, onPointerDrag, onPointerDragEnd, isDragging };
+}
+
+// src/stamps/geometry-3d/editor/editorHelpers.ts
+function hitToHoverLabel(hit, state) {
+  if (hit.kind === "empty") return null;
+  if (hit.kind === "existingPoint") return state.objects[hit.pointId]?.label ?? null;
+  if (hit.kind === "onGround") return "m\u1EB7t n\u1EC1n";
+  if (hit.kind === "onAxis") return `tr\u1EE5c ${hit.axis.toUpperCase()}`;
+  if (hit.kind === "onPlane") return `m\u1EB7t ph\u1EB3ng ${hit.planeId}`;
+  if (hit.kind === "onSphere") return `m\u1EB7t c\u1EA7u ${hit.sphereId}`;
+  return null;
+}
+function getView3DInfo(view) {
+  const v = view;
+  const azSlider = v?.az_slide ?? v?.az;
+  const elSlider = v?.el_slide ?? v?.el;
+  const azimuth = typeof azSlider?.Value === "function" ? azSlider.Value() : 0;
+  const elevation = typeof elSlider?.Value === "function" ? elSlider.Value() : 0;
+  return {
+    azimuth,
+    elevation,
+    bbox3D: [...DEFAULT_VIEW3D.bbox3D]
+  };
+}
+var EditorPanelInner = React3.forwardRef(
+  function EditorPanel(props, ref) {
+    const {
+      isDark: isDarkProp,
+      onInsert,
+      onClose,
+      store,
+      selectedTool,
+      onSelectedToolChange,
+      showAxis,
+      showGrid,
+      onHistoryChange,
+      isMobile = false,
+      onOpenDrawer,
+      withLeftPanel = false
+    } = props;
+    const isDark = isDarkProp ?? false;
+    const controllerRef = React3.useRef(null);
+    if (!controllerRef.current) controllerRef.current = new ToolController(store);
+    const [hint, setHint] = React3.useState("Ch\u1ECDn c\xF4ng c\u1EE5 trong b\u1EA3ng b\xEAn tr\xE1i");
+    const [hoverLabel, setHoverLabel] = React3.useState(null);
+    const [ready, setReady] = React3.useState(false);
+    const [hasContent, setHasContent] = React3.useState(false);
+    const boardRef = React3.useRef(null);
+    const rendererRef = React3.useRef(null);
+    const previewRef = React3.useRef(null);
+    const lastHoverHitRef = React3.useRef({ kind: "empty" });
+    const onSelectedToolChangeRef = React3.useRef(onSelectedToolChange);
+    onSelectedToolChangeRef.current = onSelectedToolChange;
+    const selectedToolRef = React3.useRef(selectedTool);
+    selectedToolRef.current = selectedTool;
+    const onInsertRef = React3.useRef(onInsert);
+    onInsertRef.current = onInsert;
+    useEditorState({ store, onHistoryChange });
+    const { shouldStartPointDrag, onPointerDrag, onPointerDragEnd, isDragging } = usePointDrag({
+      store,
+      boardRef,
+      selectedToolRef
+    });
+    React3.useEffect(() => {
+      const ctrl = controllerRef.current;
+      return ctrl.on((state) => {
+        setHint(state.hint);
+        onSelectedToolChangeRef.current(state.tool?.key ?? "move");
+      });
+    }, []);
+    React3.useEffect(() => {
+      controllerRef.current?.selectTool(selectedTool);
+    }, [selectedTool]);
+    React3.useEffect(() => {
+      return () => {
+        rendererRef.current?.dispose();
+        rendererRef.current = null;
+        previewRef.current?.dispose();
+        previewRef.current = null;
+      };
+    }, []);
+    React3.useEffect(() => {
+      const sync = () => setHasContent(Object.keys(store.getState().objects).length > 0);
+      sync();
+      return store.subscribe(sync);
+    }, [store]);
+    React3.useEffect(() => {
+      const controller = controllerRef.current;
+      if (!controller) return;
+      return controller.on((state) => {
+        if (!previewRef.current) return;
+        if (state.collected.length === 0) previewRef.current.clear();
+        else previewRef.current.update(state.tool?.key ?? null, state.collected, lastHoverHitRef.current);
+      });
+    }, []);
+    React3.useEffect(() => {
+      const view = boardRef.current?.getView3D();
+      const v = view;
+      if (!v || typeof v.setAttribute !== "function") return;
+      try {
+        v.setAttribute({
+          xAxis: { visible: showAxis },
+          yAxis: { visible: showAxis },
+          zAxis: { visible: showAxis },
+          xPlaneRear: { visible: false, mesh3d: { visible: false } },
+          yPlaneRear: { visible: false, mesh3d: { visible: false } },
+          zPlaneRear: { visible: showGrid, mesh3d: { visible: false } }
+        });
+        v.board?.update?.();
+      } catch {
+      }
+    }, [showAxis, showGrid]);
+    const handleView3DReady = React3.useCallback((view) => {
+      rendererRef.current = new JxgRenderer3D(store, view);
+      previewRef.current = new Preview3DManager(view, store);
+      const meta = store.getState().meta;
+      const savedView = meta.domain === "3d" ? meta.view : null;
+      if (savedView) {
+        try {
+          const v = view;
+          v?.az_slide?.setValue?.(savedView.azimuth);
+          v?.el_slide?.setValue?.(savedView.elevation);
+          v?.board?.update?.();
+        } catch {
+        }
+      }
+      setReady(true);
+    }, [store]);
+    const handleClick = React3.useCallback((screen) => {
+      const view = boardRef.current?.getView3D();
+      if (!view) return;
+      try {
+        const hit = hitTest(screen, view, store.getState());
+        controllerRef.current.consumeHit(hit);
+      } catch {
+      }
+    }, [store]);
+    const handleMove = React3.useCallback((screen) => {
+      const view = boardRef.current?.getView3D();
+      if (!view) return;
+      if (isDragging()) return;
+      let hit;
+      try {
+        hit = hitTest(screen, view, store.getState());
+      } catch {
+        setHoverLabel(null);
+        return;
+      }
+      lastHoverHitRef.current = hit;
+      const ctrl = controllerRef.current;
+      if (previewRef.current && ctrl) {
+        const cs = ctrl.getState();
+        previewRef.current.update(cs.tool?.key ?? null, cs.collected, hit);
+      }
+      setHoverLabel(hitToHoverLabel(hit, store.getState()));
+    }, [store, isDragging]);
+    const isHoveringObject = React3.useCallback((screen) => {
+      const view = boardRef.current?.getView3D();
+      if (!view) return false;
+      try {
+        return hitTest(screen, view, store.getState()).kind !== "empty";
+      } catch {
+        return false;
+      }
+    }, [store]);
+    const tryInsert = React3.useCallback(() => {
+      const state = store.getState();
+      if (Object.keys(state.objects).length === 0) return false;
+      const view = getView3DInfo(boardRef.current?.getView3D());
+      const jsonState = serializeBoard3D(state, view);
+      void (async () => {
+        try {
+          const { svgString } = await renderGeometry3DSvgFromState(jsonState);
+          onInsertRef.current?.(jsonState, svgString);
+        } catch (err) {
+          console.error("Geometry3D insert failed:", err);
+        }
+      })();
+      return true;
+    }, [store]);
+    React3.useImperativeHandle(
+      ref,
+      () => ({
+        hasContent: () => Object.keys(store.getState().objects).length > 0,
+        tryInsert,
+        setTool: (k) => controllerRef.current.selectTool(k),
+        undo: () => store.undo(),
+        redo: () => store.redo(),
+        highlight: (id) => rendererRef.current?.highlight(id)
+      }),
+      [store, tryInsert]
+    );
+    const dialogStyle = isMobile ? { position: "fixed", inset: 0, zIndex: 40 } : {
+      position: "absolute",
+      top: "50%",
+      left: withLeftPanel ? "calc(50% + 120px)" : "50%",
+      transform: "translate(-50%, -50%)",
+      zIndex: 40
+    };
+    return /* @__PURE__ */ jsxs(
+      "div",
+      {
+        role: "dialog",
+        "aria-label": "D\u1EF1ng h\xECnh h\u1ECDc 3D",
+        "data-testid": "geom3d-host",
+        "data-stamp-area": "true",
+        style: dialogStyle,
+        className: [
+          isDark ? "theme--dark " : "",
+          "relative flex flex-col overflow-hidden bg-white",
+          isMobile ? "h-full w-full" : `${STAMP_PANEL_DESKTOP} rounded-lg border border-slate-300 shadow-2xl ring-1 ring-black/5`
+        ].join(" "),
+        children: [
+          /* @__PURE__ */ jsxs("header", { className: "flex items-center gap-2 border-b border-slate-200 bg-gradient-to-r from-emerald-600 to-teal-600 px-3 py-2 text-white", children: [
+            isMobile && /* @__PURE__ */ jsx(
+              "button",
+              {
+                type: "button",
+                onClick: onOpenDrawer,
+                "aria-label": "M\u1EDF ng\u0103n c\xF4ng c\u1EE5",
+                className: "-ml-1 inline-flex h-10 w-10 items-center justify-center rounded transition hover:bg-white/15",
+                children: /* @__PURE__ */ jsxs("svg", { width: "20", height: "20", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", children: [
+                  /* @__PURE__ */ jsx("line", { x1: "4", y1: "6", x2: "20", y2: "6" }),
+                  /* @__PURE__ */ jsx("line", { x1: "4", y1: "12", x2: "20", y2: "12" }),
+                  /* @__PURE__ */ jsx("line", { x1: "4", y1: "18", x2: "20", y2: "18" })
+                ] })
+              }
+            ),
+            /* @__PURE__ */ jsxs("h3", { className: "flex flex-1 items-center gap-2 text-sm font-semibold", children: [
+              /* @__PURE__ */ jsx("svg", { width: "16", height: "16", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", children: /* @__PURE__ */ jsx("path", { d: "M4 9 L4 20 L14 20 L14 9 Z M4 9 L10 4 L20 4 L14 9 Z M14 9 L20 4 L20 15 L14 20 Z" }) }),
+              "D\u1EF1ng h\xECnh h\u1ECDc kh\xF4ng gian"
+            ] }),
+            isMobile && /* @__PURE__ */ jsx(
+              "button",
+              {
+                type: "button",
+                onClick: tryInsert,
+                disabled: !ready || !hasContent,
+                title: !hasContent ? "V\u1EBD \xEDt nh\u1EA5t m\u1ED9t \u0111\u1ED1i t\u01B0\u1EE3ng tr\u01B0\u1EDBc khi ch\xE8n" : void 0,
+                "data-testid": "geom3d-insert-btn-mobile",
+                className: "rounded bg-white/15 px-3 py-1.5 text-xs font-semibold transition hover:bg-white/25 disabled:opacity-50",
+                children: "Ch\xE8n"
+              }
+            ),
+            /* @__PURE__ */ jsx(
+              "button",
+              {
+                onClick: onClose,
+                "aria-label": "\u0110\xF3ng",
+                className: "inline-flex h-9 w-9 items-center justify-center rounded transition hover:bg-white/15",
+                children: /* @__PURE__ */ jsxs("svg", { width: "18", height: "18", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", children: [
+                  /* @__PURE__ */ jsx("line", { x1: "6", y1: "6", x2: "18", y2: "18" }),
+                  /* @__PURE__ */ jsx("line", { x1: "18", y1: "6", x2: "6", y2: "18" })
+                ] })
+              }
+            )
+          ] }),
+          /* @__PURE__ */ jsx("div", { className: "min-h-0 flex-1", children: /* @__PURE__ */ jsx(
+            MiniBoard3D,
+            {
+              ref: boardRef,
+              isDark,
+              onView3DReady: handleView3DReady,
+              onPointerClick: handleClick,
+              onPointerMove: handleMove,
+              onPointerLeave: () => {
+                setHoverLabel(null);
+                lastHoverHitRef.current = { kind: "empty" };
+                previewRef.current?.clear();
+              },
+              shouldStartPointDrag,
+              onPointerDrag,
+              onPointerDragEnd,
+              isHoveringObject
+            }
+          ) }),
+          /* @__PURE__ */ jsx(StatusHint, { hint, hoverLabel }),
+          !isMobile && /* @__PURE__ */ jsxs("footer", { className: "flex items-center justify-between border-t border-slate-200 bg-slate-50 px-3 py-2", children: [
+            /* @__PURE__ */ jsx("span", { className: "text-xs text-slate-500", children: "Ch\u1ECDn c\xF4ng c\u1EE5 b\xEAn tr\xE1i, click tr\xEAn b\u1EA3ng \u0111\u1EC3 d\u1EF1ng h\xECnh." }),
+            /* @__PURE__ */ jsxs("div", { className: "flex gap-2", children: [
+              /* @__PURE__ */ jsx(
+                "button",
+                {
+                  onClick: onClose,
+                  className: "rounded border border-slate-300 bg-white px-3 py-1 text-xs font-medium text-slate-700 transition hover:bg-slate-100",
+                  children: "Hu\u1EF7"
+                }
+              ),
+              /* @__PURE__ */ jsx(
+                "button",
+                {
+                  onClick: tryInsert,
+                  disabled: !ready || !hasContent,
+                  title: !hasContent ? "V\u1EBD \xEDt nh\u1EA5t m\u1ED9t \u0111\u1ED1i t\u01B0\u1EE3ng tr\u01B0\u1EDBc khi ch\xE8n" : void 0,
+                  "data-testid": "geom3d-insert-btn",
+                  className: "rounded bg-emerald-600 px-3 py-1 text-xs font-medium text-white transition hover:bg-emerald-700 disabled:opacity-50",
+                  children: "Ch\xE8n"
+                }
+              )
+            ] })
+          ] }),
+          /* @__PURE__ */ jsx(ToastHost, {})
+        ]
+      }
+    );
+  }
+);
+var EditorPanel2 = React3.forwardRef(
+  function EditorPanel3(props, ref) {
+    return /* @__PURE__ */ jsx(ToastProvider, { children: /* @__PURE__ */ jsx(EditorPanelInner, { ...props, ref }) });
+  }
+);
+var wrap = (children) => /* @__PURE__ */ jsx(
+  "svg",
+  {
+    width: "22",
+    height: "22",
+    viewBox: "0 0 24 24",
+    fill: "none",
+    stroke: "currentColor",
+    strokeWidth: "1.6",
+    strokeLinecap: "round",
+    strokeLinejoin: "round",
+    "aria-hidden": "true",
+    children
+  }
+);
+var dot4 = (cx, cy, r = 1.4) => /* @__PURE__ */ jsx("circle", { cx, cy, r, fill: "currentColor", stroke: "none" });
+var ToolIcons = {
+  move: wrap(
+    /* @__PURE__ */ jsx(Fragment, { children: /* @__PURE__ */ jsx("path", { d: "M5 4 L5 14 L8 11 L10 16 L13 15 L11 10 L15 10 Z" }) })
+  ),
+  point: wrap(
+    /* @__PURE__ */ jsx(Fragment, { children: /* @__PURE__ */ jsx("circle", { cx: "12", cy: "12", r: "2.4", fill: "currentColor", stroke: "none" }) })
+  ),
+  pointOnObject: wrap(
+    /* @__PURE__ */ jsxs(Fragment, { children: [
+      /* @__PURE__ */ jsx("path", { d: "M3 16 L21 12" }),
+      /* @__PURE__ */ jsx("circle", { cx: "12", cy: "13.5", r: "2.4", fill: "currentColor", stroke: "none" })
+    ] })
+  ),
+  segment: wrap(
+    /* @__PURE__ */ jsxs(Fragment, { children: [
+      /* @__PURE__ */ jsx("line", { x1: "4", y1: "18", x2: "20", y2: "6" }),
+      dot4(4, 18, 1.6),
+      dot4(20, 6, 1.6)
+    ] })
+  ),
+  line: wrap(
+    /* @__PURE__ */ jsxs(Fragment, { children: [
+      /* @__PURE__ */ jsx("line", { x1: "3", y1: "18", x2: "21", y2: "6" }),
+      dot4(8, 14.5, 1.4),
+      dot4(16, 9.5, 1.4)
+    ] })
+  ),
+  ray: wrap(
+    /* @__PURE__ */ jsxs(Fragment, { children: [
+      /* @__PURE__ */ jsx("line", { x1: "5", y1: "18", x2: "19", y2: "7" }),
+      /* @__PURE__ */ jsx("path", { d: "M19 7 L15 6 M19 7 L18 11" }),
+      dot4(5, 18, 1.6)
+    ] })
+  ),
+  vector: wrap(
+    /* @__PURE__ */ jsxs(Fragment, { children: [
+      /* @__PURE__ */ jsx("line", { x1: "5", y1: "18", x2: "18", y2: "7" }),
+      /* @__PURE__ */ jsx("path", { d: "M18 7 L13 7 M18 7 L18 12" }),
+      dot4(5, 18, 1.6)
+    ] })
+  ),
+  polygon: wrap(
+    /* @__PURE__ */ jsx(Fragment, { children: /* @__PURE__ */ jsx("polygon", { points: "12,4 20,10 17,19 7,19 4,10" }) })
+  ),
+  plane: wrap(
+    /* @__PURE__ */ jsx(Fragment, { children: /* @__PURE__ */ jsx("polygon", { points: "3,9 14,5 21,11 10,15" }) })
+  ),
+  pyramid: wrap(
+    /* @__PURE__ */ jsxs(Fragment, { children: [
+      /* @__PURE__ */ jsx("path", { d: "M4 19 L20 19 L12 4 Z" }),
+      /* @__PURE__ */ jsx("path", { d: "M4 19 L12 16 L20 19" }),
+      /* @__PURE__ */ jsx("path", { d: "M12 4 L12 16", strokeDasharray: "2 2" })
+    ] })
+  ),
+  prism: wrap(
+    /* @__PURE__ */ jsxs(Fragment, { children: [
+      /* @__PURE__ */ jsx("path", { d: "M4 8 L4 19 L14 19 L14 8 Z" }),
+      /* @__PURE__ */ jsx("path", { d: "M4 8 L10 4 L20 4 L14 8" }),
+      /* @__PURE__ */ jsx("path", { d: "M14 8 L14 19 L20 15 L20 4" }),
+      /* @__PURE__ */ jsx("path", { d: "M4 8 L14 8" })
+    ] })
+  ),
+  tetrahedron: wrap(
+    /* @__PURE__ */ jsxs(Fragment, { children: [
+      /* @__PURE__ */ jsx("path", { d: "M4 19 L20 19 L12 5 Z" }),
+      /* @__PURE__ */ jsx("path", { d: "M4 19 L15 12 L20 19" }),
+      /* @__PURE__ */ jsx("path", { d: "M15 12 L12 5" })
+    ] })
+  ),
+  cube: wrap(
+    /* @__PURE__ */ jsxs(Fragment, { children: [
+      /* @__PURE__ */ jsx("path", { d: "M4 8 L4 19 L14 19 L14 8 Z" }),
+      /* @__PURE__ */ jsx("path", { d: "M4 8 L10 4 L20 4 L14 8" }),
+      /* @__PURE__ */ jsx("path", { d: "M14 8 L14 19 L20 15 L20 4" })
+    ] })
+  ),
+  sphere: wrap(
+    /* @__PURE__ */ jsxs(Fragment, { children: [
+      /* @__PURE__ */ jsx("circle", { cx: "12", cy: "12", r: "8" }),
+      /* @__PURE__ */ jsx("ellipse", { cx: "12", cy: "12", rx: "8", ry: "3" }),
+      dot4(12, 12, 1.2)
+    ] })
+  ),
+  cylinder: wrap(
+    /* @__PURE__ */ jsxs(Fragment, { children: [
+      /* @__PURE__ */ jsx("ellipse", { cx: "12", cy: "6", rx: "6", ry: "2" }),
+      /* @__PURE__ */ jsx("path", { d: "M6 6 L6 18" }),
+      /* @__PURE__ */ jsx("path", { d: "M18 6 L18 18" }),
+      /* @__PURE__ */ jsx("ellipse", { cx: "12", cy: "18", rx: "6", ry: "2" })
+    ] })
+  ),
+  cone: wrap(
+    /* @__PURE__ */ jsxs(Fragment, { children: [
+      /* @__PURE__ */ jsx("line", { x1: "5", y1: "18", x2: "12", y2: "4" }),
+      /* @__PURE__ */ jsx("line", { x1: "19", y1: "18", x2: "12", y2: "4" }),
+      /* @__PURE__ */ jsx("ellipse", { cx: "12", cy: "18", rx: "7", ry: "2" })
+    ] })
+  )
+};
+
+// src/stamps/geometry-3d/editor/toolPanel/groups.ts
+var GROUP_ORDER = [
+  "basic",
+  "point",
+  "line",
+  "plane",
+  "polyhedron",
+  "curve"
+];
+var GROUP_LABELS = {
+  basic: "C\u01A1 b\u1EA3n",
+  point: "\u0110i\u1EC3m",
+  line: "\u0110\u01B0\u1EDDng th\u1EB3ng",
+  plane: "M\u1EB7t ph\u1EB3ng",
+  polyhedron: "Kh\u1ED1i \u0111a di\u1EC7n",
+  curve: "Kh\u1ED1i cong"
+};
+var TOOLS_BY_GROUP = {
+  basic: ["move"],
+  point: ["point", "pointOnObject"],
+  line: ["segment", "line", "ray", "vector", "polygon"],
+  plane: ["plane"],
+  polyhedron: ["pyramid", "prism", "tetrahedron", "cube"],
+  curve: ["sphere", "cylinder", "cone"]
+};
+var SPEC_BY_KEY = TOOLS.reduce(
+  (acc, t) => {
+    acc[t.key] = t;
+    return acc;
+  },
+  {}
+);
+var TOOLS_FLAT = GROUP_ORDER.flatMap(
+  (group) => TOOLS_BY_GROUP[group].map((key) => {
+    const spec = SPEC_BY_KEY[key];
+    return {
+      key,
+      label: spec?.label ?? key,
+      hint: spec?.hintIdle ?? "",
+      icon: ToolIcons[key],
+      group
+    };
+  })
+);
+var A_CODE = "A".charCodeAt(0);
+function letterForGroup(g) {
+  const idx = GROUP_ORDER.indexOf(g);
+  return idx >= 0 ? String.fromCharCode(A_CODE + idx) : "";
+}
+var Geom3DIconHeader = /* @__PURE__ */ jsxs("svg", { width: "18", height: "18", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "1.6", strokeLinecap: "round", strokeLinejoin: "round", "aria-hidden": "true", children: [
+  /* @__PURE__ */ jsx("path", { d: "M4 9 L4 20 L14 20 L14 9 Z" }),
+  /* @__PURE__ */ jsx("path", { d: "M4 9 L10 4 L20 4 L14 9 Z" }),
+  /* @__PURE__ */ jsx("path", { d: "M14 9 L20 4 L20 15 L14 20 Z" })
+] });
+function parseInitialState(data) {
+  if (!isGeometry3DCustomData(data)) return null;
+  return deserializeBoard3D(data.jsonState);
+}
+var Geometry3DStampHost = forwardRef(
+  function Geometry3DStampHost2({ api, editingElement, onClose, isDark }, ref) {
+    const editorRef = useRef(null);
+    const sceneStore = useStampStore("3d", editingElement, parseInitialState);
+    const { isMobile } = useIsMobile();
+    const [drawerOpen, setDrawerOpen] = useState(false);
+    const [selectedTool, setSelectedTool] = useState("move");
+    const [showAxis, setShowAxis] = useState(true);
+    const [showGrid, setShowGrid] = useState(true);
+    const [canUndo, setCanUndo] = useState(false);
+    const [canRedo, setCanRedo] = useState(false);
+    const [selectedObjectId, setSelectedObjectId] = useState(void 0);
+    const handleHistoryChange = useCallback((u, r) => {
+      setCanUndo(u);
+      setCanRedo(r);
+    }, []);
+    const handleObjectSelect = useCallback((id) => {
+      setSelectedObjectId(id ?? void 0);
+      editorRef.current?.highlight(id);
+    }, []);
+    const handleUndo = useCallback(() => editorRef.current?.undo(), []);
+    const handleRedo = useCallback(() => editorRef.current?.redo(), []);
+    const { chordGroup } = useChordShortcut({
+      groupOrder: GROUP_ORDER,
+      tools: TOOLS_FLAT,
+      onSelect: (key) => {
+        setSelectedTool(key);
+        editorRef.current?.setTool(key);
+      },
+      enabled: !isMobile
+    });
+    const handleSelectTool = useCallback((k) => {
+      setSelectedTool(k);
+      editorRef.current?.setTool(k);
+    }, []);
+    const handleEditorInsert = useCallback(
+      async (jsonState, svgString) => {
+        if (!api) return;
+        await insertStampImage(api, {
+          svgString,
+          makeCustomData: () => ({
+            kind: "geometry3d",
+            version: 2,
+            jsonState
+          }),
+          editingElementId: editingElement?.id ?? null
+        });
+        onClose();
+      },
+      [api, editingElement, onClose]
+    );
+    useImperativeHandle(
+      ref,
+      () => ({
+        tryInsert: () => editorRef.current?.tryInsert() ?? false,
+        hasContent: () => editorRef.current?.hasContent() ?? false
+      }),
+      []
+    );
+    return /* @__PURE__ */ jsxs(Fragment, { children: [
+      /* @__PURE__ */ jsx(
+        StampLeftPanel,
+        {
+          title: "H\xECnh h\u1ECDc 3D",
+          icon: Geom3DIconHeader,
+          onClose,
+          isDark,
+          testId: "stamp-left-panel",
+          tools: TOOLS_FLAT,
+          groupOrder: GROUP_ORDER,
+          groupLabels: GROUP_LABELS,
+          activeTool: selectedTool,
+          onToolChange: handleSelectTool,
+          view: {
+            sectionLabel: "G\xF3c nh\xECn",
+            showAxis,
+            showGrid,
+            onShowAxisChange: setShowAxis,
+            onShowGridChange: setShowGrid
+          },
+          history: {
+            onUndo: handleUndo,
+            canUndo,
+            onRedo: handleRedo,
+            canRedo
+          },
+          chord: { activeGroup: chordGroup, letterForGroup },
+          objects: {
+            store: sceneStore,
+            selectedObjectId,
+            onObjectSelect: handleObjectSelect
+          },
+          isMobile,
+          drawerOpen,
+          onDrawerClose: () => setDrawerOpen(false)
+        }
+      ),
+      /* @__PURE__ */ jsx(
+        EditorPanel2,
+        {
+          ref: editorRef,
+          isDark,
+          onInsert: handleEditorInsert,
+          onClose,
+          store: sceneStore,
+          selectedTool,
+          onSelectedToolChange: setSelectedTool,
+          showAxis,
+          showGrid,
+          onHistoryChange: handleHistoryChange,
+          isMobile,
+          onOpenDrawer: () => setDrawerOpen(true),
+          withLeftPanel: !isMobile
+        }
+      )
+    ] });
+  }
+);
+
+export { Geometry3DStampHost };
+//# sourceMappingURL=host-TLIXN4CF.mjs.map
+//# sourceMappingURL=host-TLIXN4CF.mjs.map