@xom11/whiteboard 0.31.0 → 0.32.0

package/dist/graph-2d.js

@@ -37,16 +37,16 @@ var __export = (target, all) => {
 };
 
 // src/core/scene/registry.ts
-function registerKind(def22) {
-  if (registry.has(def22.type)) {
-    console.warn(`[scene] kind "${def22.type}" \u0111\xE3 \u0111\u01B0\u1EE3c \u0111\u0103ng k\xFD \u2014 ghi \u0111\xE8 \u0111\u1ECBnh ngh\u0129a c\u0169`);
+function registerKind(def24) {
+  if (registry.has(def24.type)) {
+    console.warn(`[scene] kind "${def24.type}" \u0111\xE3 \u0111\u01B0\u1EE3c \u0111\u0103ng k\xFD \u2014 ghi \u0111\xE8 \u0111\u1ECBnh ngh\u0129a c\u0169`);
   }
-  registry.set(def22.type, def22);
+  registry.set(def24.type, def24);
 }
 function getKind(type) {
-  const def22 = registry.get(type);
-  if (!def22) throw new Error(`[scene] unknown kind: ${type}`);
-  return def22;
+  const def24 = registry.get(type);
+  if (!def24) throw new Error(`[scene] unknown kind: ${type}`);
+  return def24;
 }
 var registry;
 var init_registry = __esm({
@@ -132,8 +132,8 @@ function reduce(draft, action) {
       return;
     }
     case "TRANSACTION": {
-      for (const sub of action.payload.actions) {
-        reduce(draft, sub);
+      for (const sub2 of action.payload.actions) {
+        reduce(draft, sub2);
       }
       return;
     }
@@ -479,8 +479,8 @@ var init_JxgRenderer = __esm({
       }
       create(obj) {
         try {
-          const def22 = getKind(obj.kind);
-          const el = def22.render(obj, this.ctx());
+          const def24 = getKind(obj.kind);
+          const el = def24.render(obj, this.ctx());
           this.elements.set(obj.id, el);
           this.attachFreePointDragSync(obj, el);
           this.attachGliderDragSync(obj, el);
@@ -684,11 +684,11 @@ var init_JxgRenderer = __esm({
             continue;
           }
           if (Object.is(old, cur)) continue;
-          const def22 = getKind(cur.kind);
+          const def24 = getKind(cur.kind);
           const existing = this.elements.get(id);
-          if (def22.update && existing) {
+          if (def24.update && existing) {
             try {
-              def22.update(cur, old, this.ctx(), existing);
+              def24.update(cur, old, this.ctx(), existing);
               continue;
             } catch (err) {
               console.warn(`[scene/render/2d] update fail, recreate:`, err);
@@ -1157,8 +1157,36 @@ function constraintRefs(c) {
       return [c.polygonId];
     case "onSphere":
       return [c.sphereId];
-    default:
+    case "midpoint":
+      return [c.p1, c.p2];
+    case "centroid":
+      return [...c.vertices];
+    case "intersectionLines":
+      return [c.a1, c.b1, c.a2, c.b2];
+    case "intersectionLinePlane":
+      return [c.a, c.b, c.plane];
+    case "perpFootLine":
+      return [c.from, c.a, c.b];
+    case "perpFootPlane":
+      return [c.from, c.plane];
+    case "circumsphereCenter":
+      return [...c.vertices];
+    case "pyramidInsphereCenter":
+      return [c.apex, ...c.vertices];
+    case "faceCircumcenter":
+      return [...c.vertices];
+    case "pointAboveFace":
+      return [c.base, c.apex, ...c.vertices];
+    // Kind KHÔNG có ref scene-object (toạ độ literal): liệt kê TƯỜNG MINH để
+    // exhaustive never-guard bên dưới buộc khai báo khi thêm constraint kind mới
+    // (mô phỏng constraintRefs2D — quên case = cascade-delete/deps sai âm thầm).
+    case "free":
+    case "onGround":
+    case "onAxis":
       return [];
+    default: {
+      return [];
+    }
   }
 }
 var init_d_constraint = __esm({
@@ -1166,12 +1194,359 @@ var init_d_constraint = __esm({
   }
 });
 
+// src/core/scene/kinds/constraint3d-math.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 a = planeObj.attrs;
+  let p1, p2, p3;
+  if (a.construction) {
+    const r = planeConstructionWorld(a.construction, state);
+    p1 = r.p1;
+    p2 = r.p2;
+    p3 = r.p3;
+  } else {
+    p1 = getPointWorld(a.p1, state);
+    p2 = getPointWorld(a.p2, state);
+    p3 = getPointWorld(a.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 orthoBasisFromNormal(n) {
+  const seed = Math.abs(n[0]) < 0.9 ? [1, 0, 0] : [0, 1, 0];
+  const basis1 = normalize(cross(n, seed));
+  const basis2 = cross(n, basis1);
+  return { basis1, basis2 };
+}
+function planeConstructionWorld(c, state) {
+  if (_recDepth >= MAX_REC_DEPTH) throw new Error("planeConstructionWorld: \u0111\u1EC7 quy qu\xE1 s\xE2u \u2014 chu tr\xECnh tham chi\u1EBFu m\u1EB7t?");
+  _recDepth++;
+  try {
+    return planeConstructionWorldInner(c, state);
+  } finally {
+    _recDepth--;
+  }
+}
+function planeConstructionWorldInner(c, state) {
+  switch (c.kind) {
+    case "planeParallelThrough": {
+      const P = getPointWorld(c.point, state);
+      const ref = state.objects[c.refPlane];
+      if (!ref || ref.kind !== "plane3d") throw new Error("planeParallelThrough: m\u1EB7t tham chi\u1EBFu thi\u1EBFu");
+      const { basis1, basis2 } = getPlaneBasis(ref, state);
+      if (norm(basis1) < 1e-12 || norm(basis2) < 1e-12) {
+        return { p1: P, p2: add(P, [1, 0, 0]), p3: add(P, [0, 1, 0]) };
+      }
+      return { p1: P, p2: add(P, basis1), p3: add(P, basis2) };
+    }
+    case "planePerpToLine": {
+      const P = getPointWorld(c.point, state);
+      const dir = sub(getPointWorld(c.lineB, state), getPointWorld(c.lineA, state));
+      const dn = norm(dir);
+      if (dn < 1e-12) return { p1: P, p2: add(P, [1, 0, 0]), p3: add(P, [0, 1, 0]) };
+      const { basis1, basis2 } = orthoBasisFromNormal(scale(dir, 1 / dn));
+      return { p1: P, p2: add(P, basis1), p3: add(P, basis2) };
+    }
+    default: {
+      throw new Error("planeConstructionWorld: kind kh\xF4ng h\u1ED7 tr\u1EE3");
+    }
+  }
+}
+function lineDefiningPointIds(line) {
+  if (line.kind === "line3d" || line.kind === "segment3d") {
+    const a = line.attrs;
+    return a.p1 && a.p2 ? [a.p1, a.p2] : null;
+  }
+  if (line.kind === "ray3d") {
+    const a = line.attrs;
+    return [a.origin, a.through];
+  }
+  if (line.kind === "vector3d") {
+    const a = line.attrs;
+    return [a.from, a.to];
+  }
+  return null;
+}
+function lineEndpointsWorld(lineId, state, ctx) {
+  const line = state.objects[lineId];
+  if (!line) throw new Error(`${ctx}: \u0111\u01B0\u1EDDng ${lineId} kh\xF4ng t\u1ED3n t\u1EA1i`);
+  const ids = lineDefiningPointIds(line);
+  if (!ids) throw new Error(`${ctx}: kind ${line.kind} kh\xF4ng ph\u1EA3i \u0111\u01B0\u1EDDng`);
+  return { a: getPointWorld(ids[0], state), b: getPointWorld(ids[1], state) };
+}
+function lineLineClosestMidpoint(A, B, C, D) {
+  const u = sub(B, A), v = sub(D, C), w0 = sub(A, C);
+  const a = dot(u, u), b = dot(u, v), cc = dot(v, v), d = dot(u, w0), e = dot(v, w0);
+  const denom = a * cc - b * b;
+  if (Math.abs(denom) < 1e-12) return scale(add(A, C), 0.5);
+  const sc = (b * e - cc * d) / denom;
+  const tc = (a * e - b * d) / denom;
+  return scale(add(add(A, scale(u, sc)), add(C, scale(v, tc))), 0.5);
+}
+function planeOriginNormal(planeId, state, ctx) {
+  const plane = state.objects[planeId];
+  if (!plane || plane.kind !== "plane3d") throw new Error(`${ctx}: m\u1EB7t ph\u1EB3ng ${planeId} thi\u1EBFu`);
+  const { origin, normal } = getPlaneBasis(plane, state);
+  return { origin, normal };
+}
+function lineConstructionWorld(c, state) {
+  switch (c.kind) {
+    case "planePlaneIntersection": {
+      const P1 = planeOriginNormal(c.plane1, state, "planePlaneIntersection");
+      const P2 = planeOriginNormal(c.plane2, state, "planePlaneIntersection");
+      const d = cross(P1.normal, P2.normal);
+      const dd = dot(d, d);
+      if (dd < 1e-12) {
+        return { a: P1.origin, b: add(P1.origin, P2.normal) };
+      }
+      const c1 = dot(P1.normal, P1.origin);
+      const c2 = dot(P2.normal, P2.origin);
+      const p0 = scale(add(scale(cross(P2.normal, d), c1), scale(cross(d, P1.normal), c2)), 1 / dd);
+      return { a: p0, b: add(p0, d) };
+    }
+    case "lineParallelThrough": {
+      const P = getPointWorld(c.point, state);
+      const dir = sub(getPointWorld(c.dirB, state), getPointWorld(c.dirA, state));
+      if (norm(dir) < 1e-12) return { a: P, b: add(P, [1, 0, 0]) };
+      return { a: P, b: add(P, dir) };
+    }
+    case "linePerpToPlane": {
+      const P = getPointWorld(c.point, state);
+      const { normal } = planeOriginNormal(c.plane, state, "linePerpToPlane");
+      return { a: P, b: add(P, normal) };
+    }
+    default: {
+      throw new Error("lineConstructionWorld: kind kh\xF4ng h\u1ED7 tr\u1EE3");
+    }
+  }
+}
+function solve3(M, b) {
+  const det3 = (m) => m[0][0] * (m[1][1] * m[2][2] - m[1][2] * m[2][1]) - m[0][1] * (m[1][0] * m[2][2] - m[1][2] * m[2][0]) + m[0][2] * (m[1][0] * m[2][1] - m[1][1] * m[2][0]);
+  const det = det3(M);
+  if (Math.abs(det) < 1e-9) return null;
+  const colDet = (j) => {
+    const A = M.map((r) => r.slice());
+    for (let i = 0; i < 3; i++) A[i][j] = b[i];
+    return det3(A);
+  };
+  return [colDet(0) / det, colDet(1) / det, colDet(2) / det];
+}
+function constraintToWorld(c, state) {
+  if (_recDepth >= MAX_REC_DEPTH) throw new Error("constraintToWorld: \u0111\u1EC7 quy qu\xE1 s\xE2u \u2014 chu tr\xECnh tham chi\u1EBFu?");
+  _recDepth++;
+  try {
+    return constraintToWorldInner(c, state);
+  } finally {
+    _recDepth--;
+  }
+}
+function constraintToWorldInner(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 { a, b } = lineEndpointsWorld(c.lineId, state, "onLine");
+      return add(a, scale(sub(b, a), 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];
+    }
+    // ───── Điểm phái sinh (v1) ─────
+    case "midpoint": {
+      const p1 = getPointWorld(c.p1, state);
+      const p2 = getPointWorld(c.p2, state);
+      return scale(add(p1, p2), 0.5);
+    }
+    case "centroid": {
+      const n = c.vertices.length;
+      if (n === 0) return [0, 0, 0];
+      let acc = [0, 0, 0];
+      for (const id of c.vertices) acc = add(acc, getPointWorld(id, state));
+      return scale(acc, 1 / n);
+    }
+    case "circumsphereCenter": {
+      const P = c.vertices.map((id) => getPointWorld(id, state));
+      if (P.length < 4) return P.length ? P[0] : [0, 0, 0];
+      const p0 = P[0];
+      const M = [[0, 0, 0], [0, 0, 0], [0, 0, 0]];
+      const rhs = [0, 0, 0];
+      for (let i = 1; i < P.length; i++) {
+        const r = [2 * (P[i][0] - p0[0]), 2 * (P[i][1] - p0[1]), 2 * (P[i][2] - p0[2])];
+        const bi = dot(P[i], P[i]) - dot(p0, p0);
+        for (let a = 0; a < 3; a++) {
+          for (let bcol = 0; bcol < 3; bcol++) M[a][bcol] += r[a] * r[bcol];
+          rhs[a] += r[a] * bi;
+        }
+      }
+      const sol = solve3(M, rhs);
+      if (sol) return sol;
+      let acc = [0, 0, 0];
+      for (const p of P) acc = add(acc, p);
+      return scale(acc, 1 / P.length);
+    }
+    case "pyramidInsphereCenter": {
+      const S = getPointWorld(c.apex, state);
+      const base = c.vertices.map((id) => getPointWorld(id, state));
+      const n = base.length;
+      if (n < 3) return S;
+      let G = [0, 0, 0];
+      for (const p of base) G = add(G, p);
+      G = scale(G, 1 / n);
+      let nb = normalize(cross(sub(base[1], base[0]), sub(base[2], base[0])));
+      if (dot(nb, sub(S, G)) < 0) nb = scale(nb, -1);
+      let m = normalize(cross(sub(base[0], S), sub(base[1], S)));
+      if (dot(m, sub(G, base[0])) < 0) m = scale(m, -1);
+      const denom = 1 - dot(m, nb);
+      const s = Math.abs(denom) < 1e-9 ? NaN : dot(m, sub(G, base[0])) / denom;
+      if (!Number.isFinite(s) || s <= 0) {
+        return scale(add(S, scale(G, n)), 1 / (n + 1));
+      }
+      return add(G, scale(nb, s));
+    }
+    case "faceCircumcenter": {
+      const P = c.vertices.map((id) => getPointWorld(id, state));
+      if (P.length < 3) return P.length ? P[0] : [0, 0, 0];
+      const [p0, p1, p2] = P;
+      const e1 = sub(p1, p0), e2 = sub(p2, p0);
+      const nrm = cross(e1, e2);
+      const M = [
+        [2 * e1[0], 2 * e1[1], 2 * e1[2]],
+        [2 * e2[0], 2 * e2[1], 2 * e2[2]],
+        [nrm[0], nrm[1], nrm[2]]
+      ];
+      const rhs = [dot(p1, p1) - dot(p0, p0), dot(p2, p2) - dot(p0, p0), dot(nrm, p0)];
+      const sol = solve3(M, rhs);
+      if (sol) return sol;
+      return scale(add(add(p0, p1), p2), 1 / 3);
+    }
+    case "pointAboveFace": {
+      const G = getPointWorld(c.base, state);
+      const P = c.vertices.map((id) => getPointWorld(id, state));
+      if (P.length < 3) return G;
+      let n = normalize(cross(sub(P[1], P[0]), sub(P[2], P[0])));
+      const S = getPointWorld(c.apex, state);
+      if (dot(n, sub(S, P[0])) < 0) n = scale(n, -1);
+      const h = dot(sub(S, P[0]), n);
+      if (!Number.isFinite(h) || h <= 1e-9) return G;
+      return add(G, scale(n, h));
+    }
+    case "intersectionLines": {
+      const A = getPointWorld(c.a1, state), B = getPointWorld(c.b1, state);
+      const C = getPointWorld(c.a2, state), D = getPointWorld(c.b2, state);
+      return lineLineClosestMidpoint(A, B, C, D);
+    }
+    case "intersectionLinePlane": {
+      const A = getPointWorld(c.a, state), B = getPointWorld(c.b, state);
+      const plane = state.objects[c.plane];
+      if (!plane || plane.kind !== "plane3d") throw new Error("intersectionLinePlane: m\u1EB7t ph\u1EB3ng thi\u1EBFu");
+      const { origin, normal } = getPlaneBasis(plane, state);
+      const dir = sub(B, A);
+      const dn = dot(dir, normal);
+      if (Math.abs(dn) < 1e-12) return A;
+      const t = dot(sub(origin, A), normal) / dn;
+      return add(A, scale(dir, t));
+    }
+    case "perpFootLine": {
+      const P = getPointWorld(c.from, state);
+      const A = getPointWorld(c.a, state), B = getPointWorld(c.b, state);
+      const u = sub(B, A);
+      const uu = dot(u, u);
+      const t = uu === 0 ? 0 : dot(sub(P, A), u) / uu;
+      return add(A, scale(u, t));
+    }
+    case "perpFootPlane": {
+      const P = getPointWorld(c.from, state);
+      const plane = state.objects[c.plane];
+      if (!plane || plane.kind !== "plane3d") throw new Error("perpFootPlane: m\u1EB7t ph\u1EB3ng thi\u1EBFu");
+      const { origin, normal } = getPlaneBasis(plane, state);
+      const dist2 = dot(sub(P, origin), normal);
+      return sub(P, scale(normal, dist2));
+    }
+  }
+}
+var MAX_REC_DEPTH, _recDepth;
+var init_constraint3d_math = __esm({
+  "src/core/scene/kinds/constraint3d-math.ts"() {
+    MAX_REC_DEPTH = 512;
+    _recDepth = 0;
+  }
+});
+
 // src/core/scene/kinds/point3d.ts
 var def;
 var init_point3d = __esm({
   "src/core/scene/kinds/point3d.ts"() {
     init_registry();
     init_d_constraint();
+    init_constraint3d_math();
     def = {
       type: "point3d",
       schemaVersion: 1,
@@ -1209,6 +1584,15 @@ var init_point3d = __esm({
         if (c.kind === "onLine") return `${obj.label} tr\xEAn \u0111\u01B0\u1EDDng ${c.lineId}`;
         if (c.kind === "onPolygon") return `${obj.label} tr\xEAn \u0111a gi\xE1c ${c.polygonId}`;
         if (c.kind === "onSphere") return `${obj.label} tr\xEAn m\u1EB7t c\u1EA7u ${c.sphereId}`;
+        if (c.kind === "midpoint") return `${obj.label} = trung \u0111i\u1EC3m ${c.p1}${c.p2}`;
+        if (c.kind === "centroid") return `${obj.label} = tr\u1ECDng t\xE2m ${c.vertices.join("")}`;
+        if (c.kind === "intersectionLines") return `${obj.label} = giao 2 \u0111\u01B0\u1EDDng (${c.a1}${c.b1}, ${c.a2}${c.b2})`;
+        if (c.kind === "intersectionLinePlane") return `${obj.label} = giao ${c.a}${c.b} \u2229 ${c.plane}`;
+        if (c.kind === "perpFootLine") return `${obj.label} = ch\xE2n \u22A5 t\u1EEB ${c.from} xu\u1ED1ng ${c.a}${c.b}`;
+        if (c.kind === "perpFootPlane") return `${obj.label} = ch\xE2n \u22A5 t\u1EEB ${c.from} xu\u1ED1ng ${c.plane}`;
+        if (c.kind === "pyramidInsphereCenter") return `${obj.label} = t\xE2m c\u1EA7u n\u1ED9i ti\u1EBFp ch\xF3p ${c.apex}.${c.vertices.join("")}`;
+        if (c.kind === "faceCircumcenter") return `${obj.label} = t\xE2m ngo\u1EA1i ti\u1EBFp ${c.vertices.join("")}`;
+        if (c.kind === "pointAboveFace") return `${obj.label} = \u0111\u1EC9nh tr\u1EE5c tr\u1EE5 \u22A5 m\u1EB7t ${c.vertices.join("")}`;
         return obj.label;
       },
       render: (obj, ctx) => {
@@ -1258,6 +1642,15 @@ var init_point3d = __esm({
             () => sph.F(c.theta, c.phi)[2]
           ], opts);
         }
+        const getState = ctx.getState;
+        if (getState) {
+          const cw = () => constraintToWorld(c, getState());
+          return view.create("point3d", [
+            () => cw()[0],
+            () => cw()[1],
+            () => cw()[2]
+          ], { ...opts, needsRegularUpdate: true });
+        }
         return view.create("point3d", [0, 0, 0], opts);
       }
     };
@@ -1319,32 +1712,77 @@ var init_segment3d = __esm({
 });
 
 // src/core/scene/kinds/line3d.ts
+function line3dConstructionRefs(c) {
+  switch (c.kind) {
+    case "planePlaneIntersection":
+      return [c.plane1, c.plane2];
+    case "lineParallelThrough":
+      return [c.point, c.dirA, c.dirB];
+    case "linePerpToPlane":
+      return [c.point, c.plane];
+    default: {
+      return [];
+    }
+  }
+}
+var def3;
 var init_line3d = __esm({
   "src/core/scene/kinds/line3d.ts"() {
     init_registry();
     init_labelOf();
-    registerKind({
+    init_constraint3d_math();
+    def3 = {
       type: "line3d",
       schemaVersion: 1,
       migrate: {},
       validate: (a) => {
-        if (!a?.p1 || !a?.p2) throw new Error("line3d: p1/p2 required");
+        if (a?.construction) return;
+        if (!a?.p1 || !a?.p2) throw new Error("line3d: p1/p2 required (ho\u1EB7c construction)");
+      },
+      dependsOn: (a) => a.construction ? line3dConstructionRefs(a.construction) : [a.p1, a.p2],
+      describe: (obj, state) => {
+        const c = obj.attrs.construction;
+        if (!c) return `\u0110\u01B0\u1EDDng ${obj.label} qua ${labelOf(obj.attrs.p1, state)}, ${labelOf(obj.attrs.p2, state)}`;
+        switch (c.kind) {
+          case "planePlaneIntersection":
+            return `Giao tuy\u1EBFn ${obj.label} = ${labelOf(c.plane1, state)} \u2229 ${labelOf(c.plane2, state)}`;
+          case "lineParallelThrough":
+            return `${obj.label} \u2225 ${labelOf(c.dirA, state)}${labelOf(c.dirB, state)} qua ${labelOf(c.point, state)}`;
+          case "linePerpToPlane":
+            return `${obj.label} \u22A5 ${labelOf(c.plane, state)} qua ${labelOf(c.point, state)}`;
+          default:
+            return obj.label;
+        }
       },
-      dependsOn: (a) => [a.p1, a.p2],
-      describe: (obj, state) => `\u0110\u01B0\u1EDDng ${obj.label} qua ${labelOf(obj.attrs.p1, state)}, ${labelOf(obj.attrs.p2, state)}`,
       render: (obj, ctx) => {
         const view = ctx.jxg;
+        const baseOpts = {
+          strokeColor: obj.attrs.color ?? "#0f172a",
+          strokeWidth: 2,
+          visible: obj.visible
+        };
+        const c = obj.attrs.construction;
+        if (c) {
+          const getState = ctx.getState;
+          if (!getState) throw new Error("line3d construction: c\u1EA7n ctx.getState");
+          const lc = () => lineConstructionWorld(c, getState());
+          return view.create("line3d", [() => lc().a, () => lc().b], {
+            ...baseOpts,
+            straightFirst: true,
+            straightLast: true,
+            needsRegularUpdate: true
+          });
+        }
         const pA = ctx.resolveRef(obj.attrs.p1);
         const pB = ctx.resolveRef(obj.attrs.p2);
         return view.create("line3d", [pA, pB], {
+          ...baseOpts,
           straightFirst: true,
-          straightLast: true,
-          strokeColor: obj.attrs.color ?? "#0f172a",
-          strokeWidth: 2,
-          visible: obj.visible
+          straightLast: true
         });
       }
-    });
+    };
+    registerKind(def3);
   }
 });
 
@@ -1410,33 +1848,77 @@ var init_vector3d = __esm({
 });
 
 // src/core/scene/kinds/plane3d.ts
+function plane3dConstructionRefs(c) {
+  switch (c.kind) {
+    case "planeParallelThrough":
+      return [c.point, c.refPlane];
+    case "planePerpToLine":
+      return [c.point, c.lineA, c.lineB];
+    default: {
+      return [];
+    }
+  }
+}
+var def4;
 var init_plane3d = __esm({
   "src/core/scene/kinds/plane3d.ts"() {
     init_registry();
     init_labelOf();
-    registerKind({
+    init_constraint3d_math();
+    def4 = {
       type: "plane3d",
       schemaVersion: 1,
       migrate: {},
       validate: (a) => {
-        if (!a?.p1 || !a?.p2 || !a?.p3) throw new Error("plane3d: c\u1EA7n 3 \u0111i\u1EC3m");
+        if (a?.construction) return;
+        if (!a?.p1 || !a?.p2 || !a?.p3) throw new Error("plane3d: c\u1EA7n 3 \u0111i\u1EC3m (ho\u1EB7c construction)");
+      },
+      dependsOn: (a) => a.construction ? plane3dConstructionRefs(a.construction) : [a.p1, a.p2, a.p3],
+      describe: (obj, state) => {
+        const c = obj.attrs.construction;
+        if (!c) {
+          return `M\u1EB7t ${obj.label} qua ${labelOf(obj.attrs.p1, state)}, ${labelOf(obj.attrs.p2, state)}, ${labelOf(obj.attrs.p3, state)}`;
+        }
+        switch (c.kind) {
+          case "planeParallelThrough":
+            return `${obj.label} \u2225 ${labelOf(c.refPlane, state)} qua ${labelOf(c.point, state)}`;
+          case "planePerpToLine":
+            return `${obj.label} \u22A5 ${labelOf(c.lineA, state)}${labelOf(c.lineB, state)} qua ${labelOf(c.point, state)}`;
+          default:
+            return obj.label;
+        }
       },
-      dependsOn: (a) => [a.p1, a.p2, a.p3],
-      describe: (obj, state) => `M\u1EB7t ${obj.label} qua ${labelOf(obj.attrs.p1, state)}, ${labelOf(obj.attrs.p2, state)}, ${labelOf(obj.attrs.p3, state)}`,
       render: (obj, ctx) => {
         const view = ctx.jxg;
-        return view.create("plane3d", [
-          ctx.resolveRef(obj.attrs.p1),
-          ctx.resolveRef(obj.attrs.p2),
-          ctx.resolveRef(obj.attrs.p3)
-        ], {
+        const opts = {
           fillOpacity: 0.15,
           fillColor: obj.attrs.color ?? "#60a5fa",
           strokeColor: obj.attrs.color ?? "#60a5fa",
           visible: obj.visible
-        });
+        };
+        const c = obj.attrs.construction;
+        if (c) {
+          const getState = ctx.getState;
+          if (!getState) throw new Error("plane3d construction: c\u1EA7n ctx.getState");
+          const pc = () => planeConstructionWorld(c, getState());
+          const diff = (which) => {
+            const r = pc();
+            const q = r[which];
+            return [q[0] - r.p1[0], q[1] - r.p1[1], q[2] - r.p1[2]];
+          };
+          return view.create("plane3d", [() => pc().p1, () => diff("p2"), () => diff("p3")], {
+            ...opts,
+            needsRegularUpdate: true
+          });
+        }
+        return view.create("plane3d", [
+          ctx.resolveRef(obj.attrs.p1),
+          ctx.resolveRef(obj.attrs.p2),
+          ctx.resolveRef(obj.attrs.p3)
+        ], opts);
       }
-    });
+    };
+    registerKind(def4);
   }
 });
 
@@ -1535,11 +2017,37 @@ var init_polyhedron3d = __esm({
   }
 });
 
+// src/core/scene/kinds/_ringBasis.ts
+function perpBasis(axis) {
+  const n = Math.hypot(axis[0], axis[1], axis[2]);
+  if (n < 1e-12) return [[1, 0, 0], [0, 1, 0]];
+  const a = [axis[0] / n, axis[1] / n, axis[2] / n];
+  const seed = Math.abs(a[2]) < 0.9 ? [0, 0, 1] : [1, 0, 0];
+  let u = [
+    seed[1] * a[2] - seed[2] * a[1],
+    seed[2] * a[0] - seed[0] * a[2],
+    seed[0] * a[1] - seed[1] * a[0]
+  ];
+  const un = Math.hypot(u[0], u[1], u[2]) || 1;
+  u = [u[0] / un, u[1] / un, u[2] / un];
+  const v = [
+    a[1] * u[2] - a[2] * u[1],
+    a[2] * u[0] - a[0] * u[2],
+    a[0] * u[1] - a[1] * u[0]
+  ];
+  return [u, v];
+}
+var init_ringBasis = __esm({
+  "src/core/scene/kinds/_ringBasis.ts"() {
+  }
+});
+
 // src/core/scene/kinds/cylinder3d.ts
 var CURVED_SEGMENTS;
 var init_cylinder3d = __esm({
   "src/core/scene/kinds/cylinder3d.ts"() {
     init_registry();
+    init_ringBasis();
     CURVED_SEGMENTS = 16;
     registerKind({
       type: "cylinder3d",
@@ -1558,14 +2066,17 @@ var init_cylinder3d = __esm({
         const r = obj.attrs.radius;
         const ax = a.X?.() ?? 0, ay = a.Y?.() ?? 0, az = a.Z?.() ?? 0;
         const bx = b.X?.() ?? 0, by = b.Y?.() ?? 0, bz = b.Z?.() ?? 0;
+        const [u, v] = perpBasis([bx - ax, by - ay, bz - az]);
         const baseRing = [];
         const topRing = [];
         for (let i = 0; i < CURVED_SEGMENTS; i++) {
           const theta = i / CURVED_SEGMENTS * Math.PI * 2;
-          const dx = r * Math.cos(theta);
-          const dy = r * Math.sin(theta);
-          baseRing.push([ax + dx, ay + dy, az]);
-          topRing.push([bx + dx, by + dy, bz]);
+          const c = Math.cos(theta), s = Math.sin(theta);
+          const ox = r * (c * u[0] + s * v[0]);
+          const oy = r * (c * u[1] + s * v[1]);
+          const oz = r * (c * u[2] + s * v[2]);
+          baseRing.push([ax + ox, ay + oy, az + oz]);
+          topRing.push([bx + ox, by + oy, bz + oz]);
         }
         const vertices = [...baseRing, ...topRing];
         const faces = [];
@@ -1576,7 +2087,7 @@ var init_cylinder3d = __esm({
           faces.push([i, next, CURVED_SEGMENTS + next, CURVED_SEGMENTS + i]);
         }
         const vertJxgs = vertices.map(
-          (v, i) => view.create("point3d", v, {
+          (v2, i) => view.create("point3d", v2, {
             id: `${obj.id}.v${i}`,
             visible: false,
             fixed: true,
@@ -1604,6 +2115,7 @@ var CURVED_SEGMENTS2;
 var init_cone3d = __esm({
   "src/core/scene/kinds/cone3d.ts"() {
     init_registry();
+    init_ringBasis();
     CURVED_SEGMENTS2 = 16;
     registerKind({
       type: "cone3d",
@@ -1626,10 +2138,16 @@ var init_cone3d = __esm({
           apexPt.Y?.() ?? 0,
           apexPt.Z?.() ?? 0
         ];
+        const [u, v] = perpBasis([apexCoords[0] - bx, apexCoords[1] - by, apexCoords[2] - bz]);
         const baseRing = [];
         for (let i = 0; i < CURVED_SEGMENTS2; i++) {
           const theta = i / CURVED_SEGMENTS2 * Math.PI * 2;
-          baseRing.push([bx + r * Math.cos(theta), by + r * Math.sin(theta), bz]);
+          const c = Math.cos(theta), s = Math.sin(theta);
+          baseRing.push([
+            bx + r * (c * u[0] + s * v[0]),
+            by + r * (c * u[1] + s * v[1]),
+            bz + r * (c * u[2] + s * v[2])
+          ]);
         }
         const apexIdx = baseRing.length;
         const vertices = [...baseRing, apexCoords];
@@ -1638,7 +2156,7 @@ var init_cone3d = __esm({
           faces.push([i, (i + 1) % CURVED_SEGMENTS2, apexIdx]);
         }
         const vertJxgs = vertices.map(
-          (v, i) => view.create("point3d", v, {
+          (v2, i) => view.create("point3d", v2, {
             id: `${obj.id}.v${i}`,
             visible: false,
             fixed: true,
@@ -1727,8 +2245,16 @@ function constraintRefs2D(c) {
     }
     case "excenter":
       return [c.vertices[0], c.vertices[1], c.vertices[2]];
-    default:
+    case "commonTangentPoint":
+      return [c.circles[0], c.circles[1]];
+    // Các kind KHÔNG có ref scene-object (toạ độ literal): liệt kê TƯỜNG MINH để
+    // exhaustive never-guard bên dưới buộc khai báo khi thêm constraint kind mới.
+    case "free":
+    case "onAxis":
+      return [];
+    default: {
       return [];
+    }
   }
 }
 var init_d_constraint2 = __esm({
@@ -2250,19 +2776,19 @@ function buildJxgTransforms(board, ctx, t) {
   }
 }
 function makeDistanceFn(ctx, d) {
-  const scale = d.scale ?? 1;
+  const scale2 = d.scale ?? 1;
   const offset = d.offset ?? 0;
   if (d.kind === "literal") {
     const v = d.value;
-    return () => scale * v + offset;
+    return () => scale2 * v + offset;
   }
   if (d.kind === "segmentLength") {
     const p = ctx.resolveRef(d.p1);
     const q = ctx.resolveRef(d.p2);
-    return () => scale * Math.hypot(p.X() - q.X(), p.Y() - q.Y()) + offset;
+    return () => scale2 * Math.hypot(p.X() - q.X(), p.Y() - q.Y()) + offset;
   }
   const circle = ctx.resolveRef(d.circle);
-  return () => scale * circle.Radius() + offset;
+  return () => scale2 * circle.Radius() + offset;
 }
 function buildPointOpts(obj) {
   return {
@@ -2311,6 +2837,73 @@ var init_pointAtDistance = __esm({
   }
 });
 
+// src/stamps/geometry-2d/geometry/commonTangent.ts
+function computeCommonTangentPoint(O1, r1, O2, r2, on, variant, side) {
+  const dx = O2[0] - O1[0];
+  const dy = O2[1] - O1[1];
+  const d = Math.hypot(dx, dy);
+  if (d < EPS) return null;
+  const beta = Math.atan2(dy, dx);
+  const ratio = variant === "external" ? (r1 - r2) / d : (r1 + r2) / d;
+  if (Math.abs(ratio) > 1) return null;
+  const gamma = Math.acos(ratio);
+  const s = side === 0 ? 1 : -1;
+  const angle = beta + s * gamma;
+  const nx = Math.cos(angle);
+  const ny = Math.sin(angle);
+  if (on === 0) {
+    return [O1[0] + r1 * nx, O1[1] + r1 * ny];
+  }
+  if (variant === "external") {
+    return [O2[0] + r2 * nx, O2[1] + r2 * ny];
+  }
+  return [O2[0] - r2 * nx, O2[1] - r2 * ny];
+}
+var EPS;
+var init_commonTangent = __esm({
+  "src/stamps/geometry-2d/geometry/commonTangent.ts"() {
+    EPS = 1e-9;
+  }
+});
+
+// src/core/scene/kinds/point-constraints/commonTangentPoint.ts
+var commonTangentPointConstraint;
+var init_commonTangentPoint = __esm({
+  "src/core/scene/kinds/point-constraints/commonTangentPoint.ts"() {
+    init_commonTangent();
+    init_types3();
+    commonTangentPointConstraint = definePointConstraint({
+      kind: "commonTangentPoint",
+      describe: (obj, state, c) => {
+        const c1 = state?.objects[c.circles[0]]?.label ?? c.circles[0];
+        const c2 = state?.objects[c.circles[1]]?.label ?? c.circles[1];
+        const v = c.variant === "internal" ? "trong" : "ngo\xE0i";
+        return `${obj.label} = ti\u1EBFp \u0111i\u1EC3m ti\u1EBFp tuy\u1EBFn chung ${v} ${c1},${c2} (tr\xEAn ${c.on === 0 ? c1 : c2})`;
+      },
+      render: (obj, ctx, c, opts) => {
+        const board = ctx.jxg;
+        const k1 = ctx.resolveRef(c.circles[0]);
+        const k2 = ctx.resolveRef(c.circles[1]);
+        const O1 = k1?.center ?? k1?.midpoint ?? k1;
+        const O2 = k2?.center ?? k2?.midpoint ?? k2;
+        const compute = () => {
+          const t = computeCommonTangentPoint(
+            [O1.X(), O1.Y()],
+            k1.Radius(),
+            [O2.X(), O2.Y()],
+            k2.Radius(),
+            c.on,
+            c.variant,
+            c.side
+          );
+          return t ?? [0, 0];
+        };
+        return board.create("point", [() => compute()[0], () => compute()[1]], opts);
+      }
+    });
+  }
+});
+
 // src/core/scene/kinds/point-constraints/circleIntersection.ts
 var circleIntersectionConstraint;
 var init_circleIntersection = __esm({
@@ -2590,6 +3183,7 @@ var init_registry2 = __esm({
     init_excenter();
     init_mixtilinearPoint();
     init_pointAtDistance();
+    init_commonTangentPoint();
     init_circleIntersection();
     init_circleSecondIntersection();
     init_secondIntersection();
@@ -2616,6 +3210,7 @@ var init_registry2 = __esm({
       excenterConstraint,
       mixtilinearPointConstraint,
       pointAtDistanceConstraint,
+      commonTangentPointConstraint,
       circleIntersectionConstraint,
       circleSecondIntersectionConstraint,
       secondIntersectionConstraint,
@@ -2632,7 +3227,7 @@ var init_registry2 = __esm({
 });
 
 // src/core/scene/kinds/point.ts
-var def3;
+var def5;
 var init_point = __esm({
   "src/core/scene/kinds/point.ts"() {
     init_registry();
@@ -2640,7 +3235,7 @@ var init_point = __esm({
     init_registry2();
     init_shared();
     init_label();
-    def3 = {
+    def5 = {
       type: "point",
       schemaVersion: 1,
       migrate: {},
@@ -2718,18 +3313,18 @@ var init_point = __esm({
         throw new Error("point: constraint kind changed \u2014 recreate");
       }
     };
-    registerKind(def3);
+    registerKind(def5);
   }
 });
 
 // src/core/scene/kinds/segment.ts
-var def4;
+var def6;
 var init_segment = __esm({
   "src/core/scene/kinds/segment.ts"() {
     init_registry();
     init_labelOf();
     init_label();
-    def4 = {
+    def6 = {
       type: "segment",
       schemaVersion: 1,
       migrate: {},
@@ -2765,7 +3360,7 @@ var init_segment = __esm({
         });
       }
     };
-    registerKind(def4);
+    registerKind(def6);
   }
 });
 
@@ -2793,14 +3388,14 @@ function constructionRefs(c) {
       return [c.throughPoint, c.toCircle];
   }
 }
-var def5;
+var def7;
 var init_line = __esm({
   "src/core/scene/kinds/line.ts"() {
     init_registry();
     init_labelOf();
     init_label();
     init_pointConstructions();
-    def5 = {
+    def7 = {
       type: "line",
       schemaVersion: 1,
       migrate: {},
@@ -2996,17 +3591,17 @@ var init_line = __esm({
         }
       }
     };
-    registerKind(def5);
+    registerKind(def7);
   }
 });
 
 // src/core/scene/kinds/ray.ts
-var def6;
+var def8;
 var init_ray = __esm({
   "src/core/scene/kinds/ray.ts"() {
     init_registry();
     init_labelOf();
-    def6 = {
+    def8 = {
       type: "ray",
       schemaVersion: 1,
       migrate: {},
@@ -3031,17 +3626,17 @@ var init_ray = __esm({
         });
       }
     };
-    registerKind(def6);
+    registerKind(def8);
   }
 });
 
 // src/core/scene/kinds/vector.ts
-var def7;
+var def9;
 var init_vector = __esm({
   "src/core/scene/kinds/vector.ts"() {
     init_registry();
     init_labelOf();
-    def7 = {
+    def9 = {
       type: "vector",
       schemaVersion: 1,
       migrate: {},
@@ -3063,7 +3658,7 @@ var init_vector = __esm({
         });
       }
     };
-    registerKind(def7);
+    registerKind(def9);
   }
 });
 
@@ -3093,14 +3688,14 @@ function constructionRefs2(c) {
       return [c.p1, c.p2];
   }
 }
-var def8;
+var def10;
 var init_circle = __esm({
   "src/core/scene/kinds/circle.ts"() {
     init_registry();
     init_labelOf();
     init_label();
     init_pointConstructions();
-    def8 = {
+    def10 = {
       type: "circle",
       schemaVersion: 1,
       migrate: {},
@@ -3252,7 +3847,7 @@ var init_circle = __esm({
         return board.create("circle", [center, surface], baseOpts);
       }
     };
-    registerKind(def8);
+    registerKind(def10);
   }
 });
 
@@ -3267,12 +3862,12 @@ function constructionRefs3(c) {
       return [c.p1, c.p2, c.p3];
   }
 }
-var def9;
+var def11;
 var init_arc = __esm({
   "src/core/scene/kinds/arc.ts"() {
     init_registry();
     init_labelOf();
-    def9 = {
+    def11 = {
       type: "arc",
       schemaVersion: 1,
       migrate: {},
@@ -3330,17 +3925,17 @@ var init_arc = __esm({
         return board.create("circumcirclearc", [A, B, C], baseOpts);
       }
     };
-    registerKind(def9);
+    registerKind(def11);
   }
 });
 
 // src/core/scene/kinds/sector.ts
-var def10;
+var def12;
 var init_sector = __esm({
   "src/core/scene/kinds/sector.ts"() {
     init_registry();
     init_labelOf();
-    def10 = {
+    def12 = {
       type: "sector",
       schemaVersion: 1,
       migrate: {},
@@ -3380,7 +3975,7 @@ var init_sector = __esm({
         });
       }
     };
-    registerKind(def10);
+    registerKind(def12);
   }
 });
 
@@ -3426,12 +4021,12 @@ function specialShapeName(kind) {
       return "";
   }
 }
-var def11;
+var def13;
 var init_polygon = __esm({
   "src/core/scene/kinds/polygon.ts"() {
     init_registry();
     init_labelOf();
-    def11 = {
+    def13 = {
       type: "polygon",
       schemaVersion: 1,
       migrate: {},
@@ -3618,16 +4213,16 @@ var init_polygon = __esm({
         return poly;
       }
     };
-    registerKind(def11);
+    registerKind(def13);
   }
 });
 
 // src/core/scene/kinds/intersection.ts
-var def12;
+var def14;
 var init_intersection = __esm({
   "src/core/scene/kinds/intersection.ts"() {
     init_registry();
-    def12 = {
+    def14 = {
       type: "intersection",
       schemaVersion: 1,
       migrate: {},
@@ -3702,17 +4297,17 @@ var init_intersection = __esm({
         }
       }
     };
-    registerKind(def12);
+    registerKind(def14);
   }
 });
 
 // src/core/scene/kinds/angle.ts
-var def13;
+var def15;
 var init_angle = __esm({
   "src/core/scene/kinds/angle.ts"() {
     init_registry();
     init_labelOf();
-    def13 = {
+    def15 = {
       type: "angle",
       schemaVersion: 1,
       migrate: {},
@@ -3748,17 +4343,17 @@ var init_angle = __esm({
         });
       }
     };
-    registerKind(def13);
+    registerKind(def15);
   }
 });
 
 // src/core/scene/kinds/distance.ts
-var def14;
+var def16;
 var init_distance = __esm({
   "src/core/scene/kinds/distance.ts"() {
     init_registry();
     init_labelOf();
-    def14 = {
+    def16 = {
       type: "distance",
       schemaVersion: 1,
       migrate: {},
@@ -3787,17 +4382,17 @@ var init_distance = __esm({
         });
       }
     };
-    registerKind(def14);
+    registerKind(def16);
   }
 });
 
 // src/core/scene/kinds/function2d.ts
-var def15;
+var def17;
 var init_function2d = __esm({
   "src/core/scene/kinds/function2d.ts"() {
     init_registry();
     init_parser();
-    def15 = {
+    def17 = {
       type: "function2d",
       schemaVersion: 1,
       migrate: {},
@@ -3836,16 +4431,16 @@ var init_function2d = __esm({
         });
       }
     };
-    registerKind(def15);
+    registerKind(def17);
   }
 });
 
 // src/core/scene/kinds/parameter.ts
-var def16;
+var def18;
 var init_parameter = __esm({
   "src/core/scene/kinds/parameter.ts"() {
     init_registry();
-    def16 = {
+    def18 = {
       type: "parameter",
       schemaVersion: 1,
       migrate: {},
@@ -3863,16 +4458,16 @@ var init_parameter = __esm({
       render: () => null
       // Không render lên board
     };
-    registerKind(def16);
+    registerKind(def18);
   }
 });
 
 // src/core/scene/kinds/pointOnCurve.ts
-var def17;
+var def19;
 var init_pointOnCurve = __esm({
   "src/core/scene/kinds/pointOnCurve.ts"() {
     init_registry();
-    def17 = {
+    def19 = {
       type: "pointOnCurve",
       schemaVersion: 1,
       migrate: {},
@@ -3899,16 +4494,16 @@ var init_pointOnCurve = __esm({
         });
       }
     };
-    registerKind(def17);
+    registerKind(def19);
   }
 });
 
 // src/core/scene/kinds/tangent2d.ts
-var def18;
+var def20;
 var init_tangent2d = __esm({
   "src/core/scene/kinds/tangent2d.ts"() {
     init_registry();
-    def18 = {
+    def20 = {
       type: "tangent2d",
       schemaVersion: 1,
       migrate: {},
@@ -3931,7 +4526,7 @@ var init_tangent2d = __esm({
         });
       }
     };
-    registerKind(def18);
+    registerKind(def20);
   }
 });
 
@@ -4007,13 +4602,13 @@ var init_evaluator = __esm({
 });
 
 // src/core/scene/kinds/extremum2d.ts
-var def19;
+var def21;
 var init_extremum2d = __esm({
   "src/core/scene/kinds/extremum2d.ts"() {
     init_registry();
     init_evaluator();
     init_parser();
-    def19 = {
+    def21 = {
       type: "extremum2d",
       schemaVersion: 1,
       migrate: {},
@@ -4046,18 +4641,18 @@ var init_extremum2d = __esm({
         }));
       }
     };
-    registerKind(def19);
+    registerKind(def21);
   }
 });
 
 // src/core/scene/kinds/root2d.ts
-var def20;
+var def22;
 var init_root2d = __esm({
   "src/core/scene/kinds/root2d.ts"() {
     init_registry();
     init_evaluator();
     init_parser();
-    def20 = {
+    def22 = {
       type: "root2d",
       schemaVersion: 1,
       migrate: {},
@@ -4087,16 +4682,16 @@ var init_root2d = __esm({
         }));
       }
     };
-    registerKind(def20);
+    registerKind(def22);
   }
 });
 
 // src/core/scene/kinds/slope2d.ts
-var def21;
+var def23;
 var init_slope2d = __esm({
   "src/core/scene/kinds/slope2d.ts"() {
     init_registry();
-    def21 = {
+    def23 = {
       type: "slope2d",
       schemaVersion: 1,
       migrate: {},
@@ -4120,7 +4715,7 @@ var init_slope2d = __esm({
         });
       }
     };
-    registerKind(def21);
+    registerKind(def23);
   }
 });
 
@@ -5819,7 +6414,7 @@ var init_useToolHoverTooltip = __esm({
     init_types4();
   }
 });
-function normalize(s) {
+function normalize2(s) {
   return s.toLowerCase().normalize("NFD").replace(/[̀-ͯ]/g, "").replace(/đ/g, "d").replace(/Đ/g, "d");
 }
 function SearchIcon() {
@@ -5866,12 +6461,12 @@ function ToolGrid(props) {
   const { tools, groupOrder, groupLabels, activeTool, onToolChange, chord } = props;
   const { hover, portalReady, showHover, hideHover } = useToolHoverTooltip();
   const [query, setQuery] = React5.useState("");
-  const normalizedQuery = React5.useMemo(() => normalize(query.trim()), [query]);
+  const normalizedQuery = React5.useMemo(() => normalize2(query.trim()), [query]);
   const filteredTools = React5.useMemo(() => {
     if (!normalizedQuery) return tools;
     return tools.filter((t) => {
-      if (normalize(t.label).includes(normalizedQuery)) return true;
-      if (t.hint && normalize(t.hint).includes(normalizedQuery)) return true;
+      if (normalize2(t.label).includes(normalizedQuery)) return true;
+      if (t.hint && normalize2(t.hint).includes(normalizedQuery)) return true;
       return false;
     });
   }, [tools, normalizedQuery]);
@@ -6461,9 +7056,9 @@ async function insertStampImage(api, opts) {
     const old = elements.find((e) => e.id === editingId) ;
     const oldLongest = old ? Math.max(old.width ?? 0, old.height ?? 0) : 0;
     const newLongest = Math.max(width, height);
-    const scale = oldLongest > 0 && newLongest > 0 ? oldLongest / newLongest : 1;
-    const w = width * scale;
-    const h = height * scale;
+    const scale2 = oldLongest > 0 && newLongest > 0 ? oldLongest / newLongest : 1;
+    const w = width * scale2;
+    const h = height * scale2;
     const updated = elements.map(
       (e) => e.id === editingId ? { ...e, fileId, customData, width: w, height: h } : e
     );