@xom11/whiteboard 0.31.0 → 0.32.0

package/dist/geometry-2d.js

@@ -73,16 +73,16 @@ var init_types = __esm({
 });
 
 // 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({
@@ -168,8 +168,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;
     }
@@ -382,8 +382,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({
@@ -391,12 +419,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,
@@ -434,6 +809,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) => {
@@ -483,6 +867,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);
       }
     };
@@ -544,32 +937,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);
   }
 });
 
@@ -635,33 +1073,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);
   }
 });
 
@@ -760,11 +1242,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",
@@ -783,14 +1291,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 = [];
@@ -801,7 +1312,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,
@@ -829,6 +1340,7 @@ var CURVED_SEGMENTS2;
 var init_cone3d = __esm({
   "src/core/scene/kinds/cone3d.ts"() {
     init_registry();
+    init_ringBasis();
     CURVED_SEGMENTS2 = 16;
     registerKind({
       type: "cone3d",
@@ -851,10 +1363,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];
@@ -863,7 +1381,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,
@@ -952,8 +1470,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({
@@ -1491,19 +2017,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 {
@@ -1552,6 +2078,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_types2();
+    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({
@@ -1831,6 +2424,7 @@ var init_registry2 = __esm({
     init_excenter();
     init_mixtilinearPoint();
     init_pointAtDistance();
+    init_commonTangentPoint();
     init_circleIntersection();
     init_circleSecondIntersection();
     init_secondIntersection();
@@ -1857,6 +2451,7 @@ var init_registry2 = __esm({
       excenterConstraint,
       mixtilinearPointConstraint,
       pointAtDistanceConstraint,
+      commonTangentPointConstraint,
       circleIntersectionConstraint,
       circleSecondIntersectionConstraint,
       secondIntersectionConstraint,
@@ -1873,7 +2468,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();
@@ -1881,7 +2476,7 @@ var init_point = __esm({
     init_registry2();
     init_shared();
     init_label();
-    def3 = {
+    def5 = {
       type: "point",
       schemaVersion: 1,
       migrate: {},
@@ -1959,18 +2554,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: {},
@@ -2006,7 +2601,7 @@ var init_segment = __esm({
         });
       }
     };
-    registerKind(def4);
+    registerKind(def6);
   }
 });
 
@@ -2034,14 +2629,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: {},
@@ -2237,17 +2832,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: {},
@@ -2272,17 +2867,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: {},
@@ -2304,7 +2899,7 @@ var init_vector = __esm({
         });
       }
     };
-    registerKind(def7);
+    registerKind(def9);
   }
 });
 
@@ -2334,14 +2929,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: {},
@@ -2493,7 +3088,7 @@ var init_circle = __esm({
         return board.create("circle", [center, surface], baseOpts);
       }
     };
-    registerKind(def8);
+    registerKind(def10);
   }
 });
 
@@ -2508,12 +3103,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: {},
@@ -2571,17 +3166,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: {},
@@ -2621,7 +3216,7 @@ var init_sector = __esm({
         });
       }
     };
-    registerKind(def10);
+    registerKind(def12);
   }
 });
 
@@ -2667,12 +3262,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: {},
@@ -2859,16 +3454,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: {},
@@ -2943,17 +3538,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: {},
@@ -2989,17 +3584,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: {},
@@ -3028,7 +3623,7 @@ var init_distance = __esm({
         });
       }
     };
-    registerKind(def14);
+    registerKind(def16);
   }
 });
 
@@ -3157,12 +3752,12 @@ var init_parser = __esm({
 });
 
 // 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: {},
@@ -3201,16 +3796,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: {},
@@ -3228,16 +3823,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: {},
@@ -3264,16 +3859,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: {},
@@ -3296,7 +3891,7 @@ var init_tangent2d = __esm({
         });
       }
     };
-    registerKind(def18);
+    registerKind(def20);
   }
 });
 
@@ -3372,13 +3967,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: {},
@@ -3411,18 +4006,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: {},
@@ -3452,16 +4047,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: {},
@@ -3485,7 +4080,7 @@ var init_slope2d = __esm({
         });
       }
     };
-    registerKind(def21);
+    registerKind(def23);
   }
 });
 
@@ -3691,8 +4286,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);
@@ -3896,11 +4491,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);
@@ -4177,15 +4772,18 @@ function computeAutoFitBbox(points, circles, aspect, padPct = 0.12) {
   const xs = points.map((p) => p[0]).filter(Number.isFinite);
   const ys = points.map((p) => p[1]).filter(Number.isFinite);
   let xmin = Infinity, xmax = -Infinity, ymin = Infinity, ymax = -Infinity;
-  let clusterDiag = 0;
+  let fullDiag = 0;
   if (xs.length >= 2 && ys.length >= 2) {
     [xmin, xmax] = robustRange(xs);
     [ymin, ymax] = robustRange(ys);
-    clusterDiag = Math.hypot(xmax - xmin, ymax - ymin);
+    fullDiag = Math.hypot(
+      Math.max(...xs) - Math.min(...xs),
+      Math.max(...ys) - Math.min(...ys)
+    );
   }
   for (const c of circles) {
     if (!Number.isFinite(c.cx) || !Number.isFinite(c.cy) || !Number.isFinite(c.r)) continue;
-    if (clusterDiag > 0 && c.r > CIRCLE_MAX_FACTOR * clusterDiag) continue;
+    if (fullDiag > 0 && c.r > CIRCLE_MAX_FACTOR * fullDiag) continue;
     xmin = Math.min(xmin, c.cx - c.r);
     xmax = Math.max(xmax, c.cx + c.r);
     ymin = Math.min(ymin, c.cy - c.r);
@@ -5048,7 +5646,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() {
@@ -5095,12 +5693,12 @@ function ToolGrid(props) {
   const { tools, groupOrder, groupLabels, activeTool, onToolChange, chord } = props;
   const { hover, portalReady, showHover, hideHover } = useToolHoverTooltip();
   const [query, setQuery] = React2.useState("");
-  const normalizedQuery = React2.useMemo(() => normalize(query.trim()), [query]);
+  const normalizedQuery = React2.useMemo(() => normalize2(query.trim()), [query]);
   const filteredTools = React2.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]);
@@ -6808,8 +7406,8 @@ var init_circles = __esm({
         const ax = picks[0].X(), ay = picks[0].Y();
         const bx = picks[1].X(), by = picks[1].Y();
         const cx = picks[2].X(), cy = picks[2].Y();
-        const cross = (bx - ax) * (cy - ay) - (by - ay) * (cx - ax);
-        if (Math.abs(cross) < 1e-6) {
+        const cross2 = (bx - ax) * (cy - ay) - (by - ay) * (cx - ax);
+        if (Math.abs(cross2) < 1e-6) {
           ctx.toast?.("Kh\xF4ng v\u1EBD \u0111\u01B0\u1EE3c cung qua 3 \u0111i\u1EC3m th\u1EB3ng h\xE0ng", {
             variant: "warning",
             id: "arc3-collinear"
@@ -9588,6 +10186,141 @@ var init_tesseract = __esm({
   }
 });
 
+// src/stamps/geometry-2d/ai/vision/repairOcrSymbols.ts
+function repairOcrSymbols(text) {
+  let t = text;
+  t = t.replace(PERP_RE, "$1 \u22A5 $3");
+  t = t.replace(TRI_STRICT_RE, "tam gi\xE1c $1 $2");
+  t = t.replace(TRI_DOUBLE_RE, "tam gi\xE1c A$1");
+  t = t.replace(CIRCLE_O_RE, "(O)");
+  t = t.replace(ELEM_RE, "$1 \u2208 (O)");
+  t = t.replace(INTERSECT_RE, "$1 \u2229 $2 = {");
+  t = t.replace(SQUARE_RE, "$1\xB2");
+  t = t.replace(HORN_O_C_RE, "C");
+  t = t.replace(DUONG_DBAR_RE, "\u0110\u01B0\u1EDDng");
+  t = t.replace(DUONG_LOWER_RE, "\u0111\u01B0\u1EDDng");
+  t = t.replace(DUONG_TRON_RE, "$1tr\xF2n");
+  t = t.replace(FLORIN_F_RE, "F");
+  t = t.replace(TAI_TAI_RE, "t\u1EA1i$1");
+  t = t.replace(TAM_TAM_RE, "t\xE2m$1");
+  t = t.replace(EURO_ELEM_RE, "\u2208");
+  t = t.replace(PARALLEL_RE, "\u2225");
+  t = t.replace(CENT_C_RE, "c");
+  t = t.replace(ETH_D_RE, "D");
+  t = t.replace(SLASH_O_RE, "O");
+  t = t.replace(GOI_RE, "G\u1ECDi");
+  t = t.replace(LAY_RE, "L\u1EA5y");
+  t = t.replace(DIQUA_RE, "\u0111i qua");
+  t = t.replace(VA_VAND_RE, "v\xE0 ");
+  t = t.replace(TREN_RE, "$1r\xEAn");
+  t = t.replace(DAY_RE, "d\xE2y");
+  t = t.replace(CHUNG_MINH_RE, "$1minh");
+  t = t.replace(THANG_HANG_RE, "th\u1EB3ng h\xE0ng");
+  t = t.replace(TINH_RE, "T\xEDnh");
+  t = t.replace(DO_DAI_RE, "\u0111\u1ED9 d\xE0i");
+  t = t.replace(NIM_RE, "n\u1EB1m");
+  t = t.replace(NAM_GIUA_RE, "n\u1EB1m");
+  t = t.replace(ANGLE_Z_RE, "\u2220$1");
+  t = t.replace(DE_PAREN_RE, "(\u0110\u1EC1 ");
+  t = t.replace(DE_VERB_RE, "$1xu\u1EA5t$2");
+  t = t.replace(DE_THI_LOWER_RE, "\u0111\u1EC1");
+  t = t.replace(DI_DONG_RE, "di \u0111\u1ED9ng");
+  t = t.replace(POUND_E_RE, "E");
+  t = t.replace(TRI_SPACE_2_1, "$1$2$3$4");
+  t = t.replace(TRI_SPACE_1_2, "$1$2$3$4");
+  t = t.replace(DIAERESIS_O_RE, "O");
+  t = t.replace(INTERSECT_PAREN_RE, "$1 \u2229 $2$3");
+  return t;
+}
+var PT, PERP_RE, TRI_STRICT_RE, TRI_DOUBLE_RE, CIRCLE_O_RE, ELEM_RE, INTERSECT_RE, SQUARE_RE, HORN_O_C_RE, DUONG_DBAR_RE, DUONG_TRON_RE, FLORIN_F_RE, TAI_TAI_RE, TAM_TAM_RE, EURO_ELEM_RE, PARALLEL_RE, CENT_C_RE, ETH_D_RE, SLASH_O_RE, GOI_RE, LAY_RE, DIQUA_RE, VA_VAND_RE, TREN_RE, DUONG_LOWER_RE, DAY_RE, CHUNG_MINH_RE, THANG_HANG_RE, TINH_RE, DO_DAI_RE, NIM_RE, NAM_GIUA_RE, ANGLE_Z_RE, DE_PAREN_RE, DE_VERB_RE, DE_THI_LOWER_RE, DI_DONG_RE, POUND_E_RE, TRI_SPACE_2_1, TRI_SPACE_1_2, DIAERESIS_O_RE, INTERSECT_PAREN_RE;
+var init_repairOcrSymbols = __esm({
+  "src/stamps/geometry-2d/ai/vision/repairOcrSymbols.ts"() {
+    PT = `[A-Z]{2,3}['\u2032]?`;
+    PERP_RE = new RegExp(
+      `(?<![\\p{L}\\d])(${PT})\\s+([1|L])\\s+(${PT})(?![\\p{L}\\d])`,
+      "gu"
+    );
+    TRI_STRICT_RE = /(?<!giác )(?<!thang )(?<![\p{L}\d])A([A-Z]{3})\s+(đều|cân|nhọn|vuông)(?![\p{L}])/gu;
+    TRI_DOUBLE_RE = /(?<![\p{L}\d])AA([A-Z]{2})(?![A-Z])/gu;
+    CIRCLE_O_RE = /\(0\)/gu;
+    ELEM_RE = /(?<![\p{L}\d])([A-Z](?:\s*,\s*[A-Z])+)\s*e\s*\((?:O|0)\)/gu;
+    INTERSECT_RE = /([A-Z]{2,3})N\s+([A-Z]\S{0,2})\s*=\s*\{/gu;
+    SQUARE_RE = /([A-Z])\?(?=\s*[-=+)])/gu;
+    HORN_O_C_RE = /(?<!\p{Ll})Ơ(?!\p{Ll})/gu;
+    DUONG_DBAR_RE = /D(?:ường|uong)(?= (?:tròn|tron|thẳng|kính|cao|chéo|trung|phân|vuông|nối|gấp|tâm))/gu;
+    DUONG_TRON_RE = /([Đđ]ường\s+)tron(?![\p{L}])/gu;
+    FLORIN_F_RE = /Ƒ/gu;
+    TAI_TAI_RE = /(?<![\p{L}])tai(\s+)(?=[A-Z(]|điểm)/gu;
+    TAM_TAM_RE = /(?<![\p{L}])tam(\s+)(?=đường|\(|đối xứng)/gu;
+    EURO_ELEM_RE = /€/gu;
+    PARALLEL_RE = /\|\|/gu;
+    CENT_C_RE = /¢/gu;
+    ETH_D_RE = /(?<!\p{Ll})Ð(?!\p{Ll})/gu;
+    SLASH_O_RE = /(?<!\p{Ll})Ø(?!\p{Ll})/gu;
+    GOI_RE = /(?<!\p{L})Goi(?!\p{L})/gu;
+    LAY_RE = /(?<!\p{L})Lay(?!\p{L})/gu;
+    DIQUA_RE = /(?<!\p{L})di qua(?!\p{L})/gu;
+    VA_VAND_RE = /(?<!\p{L})va (?=[A-Z(]|dây|đường)/gu;
+    TREN_RE = /([Tt])rén(?![\p{L}])/gu;
+    DUONG_LOWER_RE = /(?<![\p{L}])dường(?= (?:tròn|tron|thẳng|kính|cao|chéo|trung|phân|vuông|nối|gấp|tâm))/gu;
+    DAY_RE = /(?<![\p{L}])day(?=\s+(?:cung(?![\p{L}])|[A-Z]{2}))/gu;
+    CHUNG_MINH_RE = /([Cc]hứng )mình(?![\p{L}])/gu;
+    THANG_HANG_RE = /thẳng hang(?![\p{L}])/gu;
+    TINH_RE = /(?<![\p{L}])Tinh(?= (?:[A-Z]|do(?![\p{L}])|độ|diện|bán|chu|số|giá))/gu;
+    DO_DAI_RE = /(?<![\p{L}])do dai(?![\p{L}])/gu;
+    NIM_RE = /(?<![\p{L}])nim(?= (?:giữa|trên|trong)(?![\p{L}]))/gu;
+    NAM_GIUA_RE = /(?<![\p{L}])năm(?= (?:giữa|trên) [A-Z])/gu;
+    ANGLE_Z_RE = /(?<![\p{L}\d])4?Z([A-Z]{2,3})(?![A-Z])/gu;
+    DE_PAREN_RE = /\(Dé /gu;
+    DE_VERB_RE = /(\(Đề )\S+( bởi)/gu;
+    DE_THI_LOWER_RE = /(?<![\p{L}])dé(?= thi)/gu;
+    DI_DONG_RE = /(?<![\p{L}])di dong(?![\p{L}])/gu;
+    POUND_E_RE = /£/gu;
+    TRI_SPACE_2_1 = /(tam\s*giác\s+)([A-Z])([A-Z])\s+([A-Z])(?![A-Z\p{Ll}])/gu;
+    TRI_SPACE_1_2 = /(tam\s*giác\s+)([A-Z])\s+([A-Z])([A-Z])(?![A-Z\p{Ll}])/gu;
+    DIAERESIS_O_RE = /(?<!\p{Ll})Ö(?!\p{Ll})/gu;
+    INTERSECT_PAREN_RE = /(\([A-Z]{3}\))\s+N\s+([A-Z]{2})(\s*=\s*\{)/gu;
+  }
+});
+
+// src/stamps/geometry-2d/ai/vision/detectFormulaRisk.ts
+function hasManglingLtGt(text) {
+  const re = /[<>]/gu;
+  let m;
+  while ((m = re.exec(text)) !== null) {
+    const prev = text.slice(0, m.index).replace(/\s+$/u, "").slice(-1);
+    const next = text.slice(m.index + 1).replace(/^\s+/u, "").slice(0, 1);
+    const prevOperand = /[A-Za-z0-9]/.test(prev);
+    const nextOperand = /[A-Za-z0-9]/.test(next);
+    if (!(prevOperand && nextOperand)) return true;
+  }
+  return false;
+}
+function detectFormulaRisk(text) {
+  const reasons = [];
+  if (hasManglingLtGt(text)) {
+    reasons.push('ph\xE2n s\u1ED1/bi\u1EC3u th\u1EE9c nghi b\u1ECB nu\u1ED1t (k\xFD hi\u1EC7u "<"/">")');
+  }
+  if (SUP_RESIDUE.test(text)) {
+    reasons.push('s\u1ED1 m\u0169 ho\u1EB7c \u0111\u1ED9 nghi b\u1ECB m\u1EA5t (d\u1EA5u "?")');
+  }
+  for (const m of text.matchAll(ANGLE_DEG)) {
+    const tok = m[1];
+    if (/[A-Z]/.test(tok) && /[^\x00-\x7F]/u.test(tok)) {
+      reasons.push("t\xEAn g\xF3c nghi b\u1ECB nh\u1EADn d\u1EA1ng sai (k\xFD t\u1EF1 c\xF3 d\u1EA5u)");
+      break;
+    }
+  }
+  return reasons;
+}
+var SUP_RESIDUE, ANGLE_DEG;
+var init_detectFormulaRisk = __esm({
+  "src/stamps/geometry-2d/ai/vision/detectFormulaRisk.ts"() {
+    SUP_RESIDUE = /[A-Z0-9]\?(?=\s*[-=+)(])/u;
+    ANGLE_DEG = /([\p{L}]{1,6})\s*=\s*\d+\s*°/gu;
+  }
+});
+
 // src/stamps/geometry-2d/ai/vision/extractProblem.ts
 async function extractProblemFromImage(image, opts = {}) {
   let raw;
@@ -9615,6 +10348,7 @@ async function extractProblemFromImage(image, opts = {}) {
     ok: true,
     text,
     confidence,
+    warnings: detectFormulaRisk(text),
     usage: { inputTokens: 0, outputTokens: 0 }
   };
 }
@@ -9626,6 +10360,7 @@ function postProcess(raw) {
   t = t.replace(/```[\s\S]*?```/g, "").replace(/`([^`]+)`/g, "$1");
   t = t.replace(/\s+/g, " ").trim();
   t = t.normalize("NFC");
+  t = repairOcrSymbols(t);
   if (t.length > MAX_TEXT_CHARS) t = t.slice(0, MAX_TEXT_CHARS);
   return t;
 }
@@ -9633,6 +10368,8 @@ var MIN_HIGH_CONFIDENCE_CHARS, MAX_TEXT_CHARS, TESSERACT_HIGH_CONFIDENCE_THRESHO
 var init_extractProblem = __esm({
   "src/stamps/geometry-2d/ai/vision/extractProblem.ts"() {
     init_tesseract();
+    init_repairOcrSymbols();
+    init_detectFormulaRisk();
     MIN_HIGH_CONFIDENCE_CHARS = 10;
     MAX_TEXT_CHARS = 2e3;
     TESSERACT_HIGH_CONFIDENCE_THRESHOLD = 70;
@@ -9644,6 +10381,14 @@ async function handleExtractProblem(image, opts = {}) {
   try {
     const r = await extractProblemFromImage(image, opts);
     if (r.ok) {
+      if (r.warnings.length > 0) {
+        return {
+          kind: "low-confidence",
+          text: r.text,
+          warning: `C\xF3 th\u1EC3 c\xF3 c\xF4ng th\u1EE9c/k\xFD hi\u1EC7u b\u1ECB nh\u1EADn d\u1EA1ng sai (${r.warnings.join("; ")}). Ki\u1EC3m tra k\u1EF9 tr\u01B0\u1EDBc khi v\u1EBD.`,
+          usage: r.usage
+        };
+      }
       if (r.confidence === "low") {
         return {
           kind: "low-confidence",
@@ -9708,9 +10453,9 @@ async function fileToImagePart(file) {
   const bitmap = await createImageBitmap(file);
   const { width, height } = bitmap;
   const maxEdge = Math.max(width, height);
-  const scale = maxEdge > MAX_EDGE_PX ? MAX_EDGE_PX / maxEdge : 1;
-  const targetW = Math.round(width * scale);
-  const targetH = Math.round(height * scale);
+  const scale2 = maxEdge > MAX_EDGE_PX ? MAX_EDGE_PX / maxEdge : 1;
+  const targetW = Math.round(width * scale2);
+  const targetH = Math.round(height * scale2);
   const canvas = typeof OffscreenCanvas !== "undefined" ? new OffscreenCanvas(targetW, targetH) : Object.assign(document.createElement("canvas"), { width: targetW, height: targetH });
   const ctx = canvas.getContext("2d");
   if (!ctx) throw new Error("Kh\xF4ng t\u1EA1o \u0111\u01B0\u1EE3c canvas 2D context");
@@ -10646,9 +11391,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
     );
@@ -10857,6 +11602,21 @@ function serializePoint(obj, state) {
         entity: { name: obj.label, kind: "pointAtDistance", from: refs[0], through: refs[1], distance }
       };
     }
+    case "commonTangentPoint": {
+      const refs = resolveRefs([c.circles[0], c.circles[1]], state);
+      if (!refs) return fail("unresolved-ref", `${c.circles[0]},${c.circles[1]}`);
+      return {
+        ok: true,
+        entity: {
+          name: obj.label,
+          kind: "commonTangentPoint",
+          circles: [refs[0], refs[1]],
+          on: c.on,
+          variant: c.variant,
+          side: c.side
+        }
+      };
+    }
     // Out of DSL v1:
     case "onAxis":
     case "onPolygon":
@@ -11184,6 +11944,10 @@ function describeEntity(e) {
     }
     case "onPerpBisector":
       return `${e.name} = \u0111i\u1EC3m tr\xEAn trung tr\u1EF1c ${e.p1}${e.p2}`;
+    case "commonTangentPoint": {
+      const v = e.variant === "internal" ? "trong" : "ngo\xE0i";
+      return `${e.name} = ti\u1EBFp \u0111i\u1EC3m ti\u1EBFp tuy\u1EBFn chung ${v} ${e.circles[0]},${e.circles[1]} (tr\xEAn ${e.circles[e.on]})`;
+    }
     default: {
       return "";
     }