@xom11/whiteboard 0.24.1 → 0.24.2

package/dist/index.js

@@ -8,11 +8,6 @@ var jsxRuntime = require('react/jsx-runtime');
 var reactDom = require('react-dom');
 var excalidraw = require('@excalidraw/excalidraw');
 require('@excalidraw/excalidraw/index.css');
-var zod = require('zod');
-var Anthropic = require('@anthropic-ai/sdk');
-var zodToJsonSchema = require('zod-to-json-schema');
-
-function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
 function _interopNamespace(e) {
   if (e && e.__esModule) return e;
@@ -33,7 +28,6 @@ function _interopNamespace(e) {
 }
 
 var React18__namespace = /*#__PURE__*/_interopNamespace(React18);
-var Anthropic__default = /*#__PURE__*/_interopDefault(Anthropic);
 
 var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
@@ -115,7 +109,7 @@ function collectDependents(state, rootId) {
         continue;
       }
       const refs = kindDef.dependsOn(obj.attrs);
-      if (refs.some((r2) => dependents.has(r2))) {
+      if (refs.some((r) => dependents.has(r))) {
         dependents.add(obj.id);
         grew = true;
       }
@@ -789,15 +783,15 @@ var init_cylinder3d = __esm({
         const view = ctx.jxg;
         const a = ctx.resolveRef(obj.attrs.baseCenter);
         const b = ctx.resolveRef(obj.attrs.topCenter);
-        const r2 = obj.attrs.radius;
+        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 baseRing = [];
         const topRing = [];
         for (let i = 0; i < CURVED_SEGMENTS; i++) {
           const theta = i / CURVED_SEGMENTS * Math.PI * 2;
-          const dx = r2 * Math.cos(theta);
-          const dy = r2 * Math.sin(theta);
+          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]);
         }
@@ -853,7 +847,7 @@ var init_cone3d = __esm({
         const view = ctx.jxg;
         const base = ctx.resolveRef(obj.attrs.baseCenter);
         const apexPt = ctx.resolveRef(obj.attrs.apex);
-        const r2 = obj.attrs.radius;
+        const r = obj.attrs.radius;
         const bx = base.X?.() ?? 0, by = base.Y?.() ?? 0, bz = base.Z?.() ?? 0;
         const apexCoords = [
           apexPt.X?.() ?? 0,
@@ -863,7 +857,7 @@ var init_cone3d = __esm({
         const baseRing = [];
         for (let i = 0; i < CURVED_SEGMENTS2; i++) {
           const theta = i / CURVED_SEGMENTS2 * Math.PI * 2;
-          baseRing.push([bx + r2 * Math.cos(theta), by + r2 * Math.sin(theta), bz]);
+          baseRing.push([bx + r * Math.cos(theta), by + r * Math.sin(theta), bz]);
         }
         const apexIdx = baseRing.length;
         const vertices = [...baseRing, apexCoords];
@@ -2700,7 +2694,7 @@ var init_JxgRenderer = __esm({
               if (obj.kind !== "function2d") continue;
               const expr = obj.attrs.expression;
               const refs = collectFreeVars(expr);
-              if (refs.some((r2) => changedParams.has(r2))) {
+              if (refs.some((r) => changedParams.has(r))) {
                 this.remove(id);
                 this.create(obj);
               }
@@ -3519,8 +3513,8 @@ function useToolHoverTooltip() {
   const showHover = React18.useCallback((el, t) => {
     if (hoverTimerRef.current) clearTimeout(hoverTimerRef.current);
     hoverTimerRef.current = setTimeout(() => {
-      const r2 = el.getBoundingClientRect();
-      setHover({ label: t.label, hint: t.hint, x: r2.right, y: r2.top + r2.height / 2 });
+      const r = el.getBoundingClientRect();
+      setHover({ label: t.label, hint: t.hint, x: r.right, y: r.top + r.height / 2 });
     }, TOOLTIP_DELAY_MS);
   }, []);
   const hideHover = React18.useCallback(() => {
@@ -4730,11 +4724,11 @@ function classifyPointVsCircle(point, circle) {
   const dx = point.X() - circle.center.X();
   const dy = point.Y() - circle.center.Y();
   const d = Math.hypot(dx, dy);
-  const r2 = typeof circle.Radius === "function" ? circle.Radius() : Number(circle.radius);
-  if (!Number.isFinite(d) || !Number.isFinite(r2)) return "inside";
-  const eps = Math.max(1e-9, 1e-6 * r2);
-  if (Math.abs(d - r2) <= eps) return "on";
-  return d < r2 ? "inside" : "outside";
+  const r = typeof circle.Radius === "function" ? circle.Radius() : Number(circle.radius);
+  if (!Number.isFinite(d) || !Number.isFinite(r)) return "inside";
+  const eps = Math.max(1e-9, 1e-6 * r);
+  if (Math.abs(d - r) <= eps) return "on";
+  return d < r ? "inside" : "outside";
 }
 var init_classifyPointVsCircle = __esm({
   "src/stamps/geometry-2d/editor/handlers/classifyPointVsCircle.ts"() {
@@ -6147,9 +6141,9 @@ function useJxgSceneIdMap({ store, rendererRef }) {
   const jxgIdToSceneRef = React18.useRef(/* @__PURE__ */ new Map());
   React18.useEffect(() => {
     const rebuild = () => {
-      const r2 = rendererRef.current;
-      if (!r2) return;
-      const elements = r2.elements;
+      const r = rendererRef.current;
+      if (!r) return;
+      const elements = r.elements;
       const next = /* @__PURE__ */ new Map();
       if (elements) {
         for (const [sid, jxg] of elements) {
@@ -7897,9 +7891,9 @@ var init_host = __esm({
         const [canUndo, setCanUndo] = React18.useState(false);
         const [canRedo, setCanRedo] = React18.useState(false);
         const [selectedObjectId, setSelectedObjectId] = React18.useState(void 0);
-        const handleHistoryChange = React18.useCallback((u, r2) => {
+        const handleHistoryChange = React18.useCallback((u, r) => {
           setCanUndo(u);
-          setCanRedo(r2);
+          setCanRedo(r);
         }, []);
         const handleUndo = React18.useCallback(() => sceneStore.undo(), [sceneStore]);
         const handleRedo = React18.useCallback(() => sceneStore.redo(), [sceneStore]);
@@ -9220,8 +9214,8 @@ function constraintToWorld(c, 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 z3 = center[2] + radius * Math.cos(c.phi);
-      return [x, y, z3];
+      const z = center[2] + radius * Math.cos(c.phi);
+      return [x, y, z];
     }
   }
 }
@@ -10143,8 +10137,8 @@ function hitTest(screen, view, state) {
         const relX = bestSphere.world[0] - center[0];
         const relY = bestSphere.world[1] - center[1];
         const relZ = bestSphere.world[2] - center[2];
-        const r2 = Math.hypot(relX, relY, relZ);
-        const phi = r2 === 0 ? 0 : Math.acos(relZ / r2);
+        const r = Math.hypot(relX, relY, relZ);
+        const phi = r === 0 ? 0 : Math.acos(relZ / r);
         const theta = Math.atan2(relY, relX);
         return { kind: "onSphere", sphereId: bestSphere.id, theta, phi, world: bestSphere.world };
       }
@@ -11229,7 +11223,7 @@ var init_icons2 = __esm({
         children
       }
     );
-    dot4 = (cx, cy, r2 = 1.4) => /* @__PURE__ */ jsxRuntime.jsx("circle", { cx, cy, r: r2, fill: "currentColor", stroke: "none" });
+    dot4 = (cx, cy, r = 1.4) => /* @__PURE__ */ jsxRuntime.jsx("circle", { cx, cy, r, fill: "currentColor", stroke: "none" });
     ToolIcons = {
       move: wrap(
         /* @__PURE__ */ jsxRuntime.jsx(jsxRuntime.Fragment, { children: /* @__PURE__ */ jsxRuntime.jsx("path", { d: "M5 4 L5 14 L8 11 L10 16 L13 15 L11 10 L15 10 Z" }) })
@@ -11427,9 +11421,9 @@ var init_host3 = __esm({
         const [canUndo, setCanUndo] = React18.useState(false);
         const [canRedo, setCanRedo] = React18.useState(false);
         const [selectedObjectId, setSelectedObjectId] = React18.useState(void 0);
-        const handleHistoryChange = React18.useCallback((u, r2) => {
+        const handleHistoryChange = React18.useCallback((u, r) => {
           setCanUndo(u);
-          setCanRedo(r2);
+          setCanRedo(r);
         }, []);
         const handleObjectSelect = React18.useCallback((id) => {
           setSelectedObjectId(id ?? void 0);
@@ -12691,9 +12685,9 @@ var init_host4 = __esm({
         const [showGrid, setShowGridState] = React18.useState(initialView?.showGrid ?? true);
         const [canUndo, setCanUndo] = React18.useState(false);
         const [canRedo, setCanRedo] = React18.useState(false);
-        const handleHistoryChange = React18.useCallback((u, r2) => {
+        const handleHistoryChange = React18.useCallback((u, r) => {
           setCanUndo(u);
-          setCanRedo(r2);
+          setCanRedo(r);
         }, []);
         const handleUndo = React18.useCallback(() => sceneStore.undo(), [sceneStore]);
         const handleRedo = React18.useCallback(() => sceneStore.redo(), [sceneStore]);
@@ -15185,999 +15179,6 @@ function Whiteboard({
     )
   ] });
 }
-var NameZ = zod.z.string().regex(/^[A-Za-z][A-Za-z0-9_'₀-₉]{0,11}$/);
-var DslPoint = zod.z.discriminatedUnion("kind", [
-  zod.z.object({
-    name: NameZ,
-    kind: zod.z.literal("free"),
-    x: zod.z.number().finite(),
-    y: zod.z.number().finite()
-  }),
-  zod.z.object({
-    name: NameZ,
-    kind: zod.z.literal("midpoint"),
-    p1: NameZ,
-    p2: NameZ
-  }),
-  zod.z.object({
-    name: NameZ,
-    kind: zod.z.literal("onSegment"),
-    segmentId: NameZ,
-    t: zod.z.number().min(0).max(1)
-  }),
-  zod.z.object({
-    name: NameZ,
-    kind: zod.z.literal("onLine"),
-    lineId: NameZ,
-    t: zod.z.number().finite()
-  }),
-  zod.z.object({
-    name: NameZ,
-    kind: zod.z.literal("onCircle"),
-    circleId: NameZ,
-    theta: zod.z.number().finite()
-  }),
-  zod.z.object({
-    name: NameZ,
-    kind: zod.z.literal("perpFoot"),
-    from: NameZ,
-    onLine: NameZ
-  }),
-  zod.z.object({
-    name: NameZ,
-    kind: zod.z.literal("circumcenter"),
-    vertices: zod.z.tuple([NameZ, NameZ, NameZ])
-  }),
-  zod.z.object({
-    name: NameZ,
-    kind: zod.z.literal("incenter"),
-    vertices: zod.z.tuple([NameZ, NameZ, NameZ])
-  }),
-  zod.z.object({
-    name: NameZ,
-    kind: zod.z.literal("centroid"),
-    vertices: zod.z.tuple([NameZ, NameZ, NameZ])
-  }),
-  zod.z.object({
-    name: NameZ,
-    kind: zod.z.literal("orthocenter"),
-    vertices: zod.z.tuple([NameZ, NameZ, NameZ])
-  }),
-  zod.z.object({
-    name: NameZ,
-    kind: zod.z.literal("intersection"),
-    ref1: NameZ,
-    ref2: NameZ,
-    branch: zod.z.union([zod.z.literal(0), zod.z.literal(1)]).optional()
-  })
-]);
-var DslShape = zod.z.discriminatedUnion("kind", [
-  zod.z.object({
-    name: NameZ,
-    kind: zod.z.literal("segment"),
-    p1: NameZ,
-    p2: NameZ
-  }),
-  zod.z.object({
-    name: NameZ,
-    kind: zod.z.literal("line"),
-    p1: NameZ,
-    p2: NameZ
-  }),
-  zod.z.object({
-    name: NameZ,
-    kind: zod.z.literal("ray"),
-    origin: NameZ,
-    through: NameZ
-  }),
-  zod.z.object({
-    name: NameZ,
-    kind: zod.z.literal("polygon"),
-    vertices: zod.z.array(NameZ).min(3)
-  }),
-  // Line constructions
-  zod.z.object({
-    name: NameZ,
-    kind: zod.z.literal("perpendicular"),
-    throughPoint: NameZ,
-    toLine: NameZ
-  }),
-  zod.z.object({
-    name: NameZ,
-    kind: zod.z.literal("parallel"),
-    throughPoint: NameZ,
-    toLine: NameZ
-  }),
-  zod.z.object({
-    name: NameZ,
-    kind: zod.z.literal("perpBisector"),
-    p1: NameZ,
-    p2: NameZ
-  }),
-  zod.z.object({
-    name: NameZ,
-    kind: zod.z.literal("angleBisector"),
-    p1: NameZ,
-    vertex: NameZ,
-    p2: NameZ
-  }),
-  zod.z.object({
-    name: NameZ,
-    kind: zod.z.literal("tangent"),
-    throughPoint: NameZ,
-    toCircle: NameZ,
-    branch: zod.z.union([zod.z.literal(0), zod.z.literal(1), zod.z.literal("on")]).optional()
-  }),
-  // Circle constructions
-  zod.z.object({
-    name: NameZ,
-    kind: zod.z.literal("circleCP"),
-    center: NameZ,
-    surfacePoint: NameZ
-  }),
-  zod.z.object({
-    name: NameZ,
-    kind: zod.z.literal("circle3"),
-    p1: NameZ,
-    p2: NameZ,
-    p3: NameZ
-  })
-]);
-var DslInput = zod.z.object({
-  version: zod.z.literal(1),
-  points: zod.z.array(DslPoint),
-  shapes: zod.z.array(DslShape).default([])
-});
-
-// src/stamps/geometry-2d/dsl/transpile.ts
-init_types();
-
-// src/stamps/geometry-2d/dsl/transpile/errors.ts
-function mkError(code, message, opts) {
-  return { code, message, path: opts?.path, hint: opts?.hint };
-}
-
-// src/stamps/geometry-2d/dsl/transpile/symbols.ts
-function buildSymbols(dsl) {
-  const symbols = /* @__PURE__ */ new Map();
-  const errors = [];
-  let counter = 0;
-  for (const p of dsl.points) {
-    if (symbols.has(p.name)) {
-      errors.push(mkError("DUPLICATE_NAME", `T\xEAn tr\xF9ng: "${p.name}"`, { path: [p.name] }));
-      continue;
-    }
-    symbols.set(p.name, { name: p.name, role: "point", entity: p, index: counter++ });
-  }
-  for (const s of dsl.shapes) {
-    if (symbols.has(s.name)) {
-      errors.push(mkError("DUPLICATE_NAME", `T\xEAn tr\xF9ng: "${s.name}"`, { path: [s.name] }));
-      continue;
-    }
-    symbols.set(s.name, { name: s.name, role: "shape", entity: s, index: counter++ });
-  }
-  return { symbols, errors };
-}
-
-// src/stamps/geometry-2d/dsl/transpile/refs.ts
-function isPointLike(sym) {
-  return !!sym && sym.role === "point";
-}
-var LINE_LIKE_SHAPE_KINDS = /* @__PURE__ */ new Set([
-  "line",
-  "segment",
-  "ray",
-  "perpendicular",
-  "parallel",
-  "perpBisector",
-  "angleBisector",
-  "tangent"
-]);
-var CIRCLE_KINDS = /* @__PURE__ */ new Set(["circleCP", "circle3"]);
-function isLineLike(sym) {
-  if (!sym || sym.role !== "shape") return false;
-  return LINE_LIKE_SHAPE_KINDS.has(sym.entity.kind);
-}
-function isCircleLike(sym) {
-  if (!sym || sym.role !== "shape") return false;
-  return CIRCLE_KINDS.has(sym.entity.kind);
-}
-function isSegmentExact(sym) {
-  return !!sym && sym.role === "shape" && sym.entity.kind === "segment";
-}
-function validateRefs(dsl, symbols) {
-  const errors = [];
-  const check = (owner, field, refName, predicate, expected) => {
-    const sym = symbols.get(refName);
-    if (!sym) {
-      errors.push(mkError(
-        "UNKNOWN_REF",
-        `${owner}.${field} tham chi\u1EBFu "${refName}" kh\xF4ng t\u1ED3n t\u1EA1i`,
-        { path: [owner, field] }
-      ));
-      return;
-    }
-    if (!predicate(sym)) {
-      errors.push(mkError(
-        "KIND_MISMATCH",
-        `${owner}.${field}="${refName}" sai ki\u1EC3u (c\u1EA7n ${expected}, g\u1EB7p ${sym.role === "point" ? "point" : sym.entity.kind})`,
-        { path: [owner, field] }
-      ));
-    }
-  };
-  for (const p of dsl.points) {
-    switch (p.kind) {
-      case "free":
-        break;
-      case "midpoint":
-        check(p.name, "p1", p.p1, isPointLike, "point");
-        check(p.name, "p2", p.p2, isPointLike, "point");
-        break;
-      case "onSegment":
-        check(p.name, "segmentId", p.segmentId, isSegmentExact, "segment");
-        break;
-      case "onLine":
-        check(p.name, "lineId", p.lineId, isLineLike, "line-like");
-        break;
-      case "onCircle":
-        check(p.name, "circleId", p.circleId, isCircleLike, "circle");
-        break;
-      case "perpFoot":
-        check(p.name, "from", p.from, isPointLike, "point");
-        check(p.name, "onLine", p.onLine, isLineLike, "line-like");
-        break;
-      case "circumcenter":
-      case "incenter":
-      case "centroid":
-      case "orthocenter":
-        for (let i = 0; i < 3; i++) {
-          check(p.name, `vertices[${i}]`, p.vertices[i], isPointLike, "point");
-        }
-        break;
-      case "intersection": {
-        const refPredicate = (s) => isLineLike(s) || isCircleLike(s);
-        check(p.name, "ref1", p.ref1, refPredicate, "line-like ho\u1EB7c circle");
-        check(p.name, "ref2", p.ref2, refPredicate, "line-like ho\u1EB7c circle");
-        break;
-      }
-    }
-  }
-  for (const s of dsl.shapes) {
-    switch (s.kind) {
-      case "segment":
-      case "line":
-        check(s.name, "p1", s.p1, isPointLike, "point");
-        check(s.name, "p2", s.p2, isPointLike, "point");
-        break;
-      case "ray":
-        check(s.name, "origin", s.origin, isPointLike, "point");
-        check(s.name, "through", s.through, isPointLike, "point");
-        break;
-      case "polygon":
-        s.vertices.forEach((v, i) => check(s.name, `vertices[${i}]`, v, isPointLike, "point"));
-        break;
-      case "perpendicular":
-      case "parallel":
-        check(s.name, "throughPoint", s.throughPoint, isPointLike, "point");
-        check(s.name, "toLine", s.toLine, isLineLike, "line-like");
-        break;
-      case "perpBisector":
-        check(s.name, "p1", s.p1, isPointLike, "point");
-        check(s.name, "p2", s.p2, isPointLike, "point");
-        break;
-      case "angleBisector":
-        check(s.name, "p1", s.p1, isPointLike, "point");
-        check(s.name, "vertex", s.vertex, isPointLike, "point");
-        check(s.name, "p2", s.p2, isPointLike, "point");
-        break;
-      case "tangent":
-        check(s.name, "throughPoint", s.throughPoint, isPointLike, "point");
-        check(s.name, "toCircle", s.toCircle, isCircleLike, "circle");
-        break;
-      case "circleCP":
-        check(s.name, "center", s.center, isPointLike, "point");
-        check(s.name, "surfacePoint", s.surfacePoint, isPointLike, "point");
-        break;
-      case "circle3":
-        check(s.name, "p1", s.p1, isPointLike, "point");
-        check(s.name, "p2", s.p2, isPointLike, "point");
-        check(s.name, "p3", s.p3, isPointLike, "point");
-        break;
-    }
-  }
-  return { errors };
-}
-function collectRefs(entity) {
-  if ("kind" in entity) {
-    switch (entity.kind) {
-      case "free":
-        return [];
-      case "midpoint":
-        return [entity.p1, entity.p2];
-      case "onSegment":
-        return [entity.segmentId];
-      case "onLine":
-        return [entity.lineId];
-      case "onCircle":
-        return [entity.circleId];
-      case "perpFoot":
-        return [entity.from, entity.onLine];
-      case "circumcenter":
-      case "incenter":
-      case "centroid":
-      case "orthocenter":
-        return [...entity.vertices];
-      case "intersection":
-        return [entity.ref1, entity.ref2];
-      case "segment":
-      case "line":
-        return [entity.p1, entity.p2];
-      case "ray":
-        return [entity.origin, entity.through];
-      case "polygon":
-        return [...entity.vertices];
-      case "perpendicular":
-      case "parallel":
-        return [entity.throughPoint, entity.toLine];
-      case "perpBisector":
-        return [entity.p1, entity.p2];
-      case "angleBisector":
-        return [entity.p1, entity.vertex, entity.p2];
-      case "tangent":
-        return [entity.throughPoint, entity.toCircle];
-      case "circleCP":
-        return [entity.center, entity.surfacePoint];
-      case "circle3":
-        return [entity.p1, entity.p2, entity.p3];
-    }
-  }
-  return [];
-}
-
-// src/stamps/geometry-2d/dsl/transpile/cycles.ts
-function detectCycles(symbols) {
-  const color = /* @__PURE__ */ new Map();
-  const parent = /* @__PURE__ */ new Map();
-  const errors = [];
-  const reportedCycles = /* @__PURE__ */ new Set();
-  for (const name of symbols.keys()) color.set(name, "white");
-  function reportCycle(start, hit) {
-    const chain = [start];
-    let cur = parent.get(start);
-    while (cur && cur !== hit && chain.length < symbols.size + 2) {
-      chain.push(cur);
-      cur = parent.get(cur);
-    }
-    chain.push(hit);
-    const minIdx = chain.indexOf(chain.reduce((a, b) => a < b ? a : b));
-    const rotated = [...chain.slice(minIdx), ...chain.slice(0, minIdx)];
-    const key = rotated.join("\u2192");
-    if (reportedCycles.has(key)) return;
-    reportedCycles.add(key);
-    errors.push(mkError(
-      "CYCLE",
-      `Ph\u1EE5 thu\u1ED9c v\xF2ng: ${chain.reverse().join(" \u2192 ")}`,
-      { path: [...chain], hint: "Ki\u1EC3m tra l\u1EA1i quan h\u1EC7 midpoint/perpFoot/intersection." }
-    ));
-  }
-  function dfs(name) {
-    color.set(name, "gray");
-    const sym = symbols.get(name);
-    if (sym) {
-      for (const ref of collectRefs(sym.entity)) {
-        if (!symbols.has(ref)) continue;
-        const c = color.get(ref);
-        if (c === "gray") {
-          reportCycle(name, ref);
-          continue;
-        }
-        if (c === "white") {
-          parent.set(ref, name);
-          dfs(ref);
-        }
-      }
-    }
-    color.set(name, "black");
-  }
-  for (const name of symbols.keys()) {
-    if (color.get(name) === "white") {
-      parent.set(name, null);
-      dfs(name);
-    }
-  }
-  return { errors };
-}
-
-// src/stamps/geometry-2d/dsl/transpile/ids.ts
-function prefixFor(sym) {
-  if (sym.role === "point") {
-    const p = sym.entity;
-    return p.kind === "intersection" ? "i" : "p";
-  }
-  const s = sym.entity;
-  switch (s.kind) {
-    case "segment":
-      return "s";
-    case "ray":
-      return "r";
-    case "polygon":
-      return "poly";
-    case "circleCP":
-    case "circle3":
-      return "c";
-    // line + 5 line-constructions all share 'l'
-    case "line":
-    case "perpendicular":
-    case "parallel":
-    case "perpBisector":
-    case "angleBisector":
-    case "tangent":
-      return "l";
-  }
-}
-function assignIds(symbols) {
-  const counters = { p: 0, i: 0, s: 0, l: 0, r: 0, poly: 0, c: 0 };
-  const ids = /* @__PURE__ */ new Map();
-  for (const [name, sym] of symbols.entries()) {
-    const prefix = prefixFor(sym);
-    counters[prefix] += 1;
-    ids.set(name, `${prefix}${counters[prefix]}`);
-  }
-  return ids;
-}
-
-// src/stamps/geometry-2d/dsl/transpile/emitPoint.ts
-function resolveId(ids, name) {
-  const id = ids.get(name);
-  if (!id) throw new Error(`emitPoint: id not assigned for "${name}"`);
-  return id;
-}
-function emitPoint(p, ids, kindHints) {
-  const baseId = resolveId(ids, p.name);
-  const baseFields = {
-    label: p.name,
-    visible: true,
-    locked: false,
-    layer: "default",
-    schemaVersion: 1
-  };
-  if (p.kind === "intersection") {
-    const r1Hint = kindHints.get(p.ref1);
-    const r2Hint = kindHints.get(p.ref2);
-    const r1IsCircle = r1Hint === "circle";
-    const r2IsCircle = r2Hint === "circle";
-    let intersectKind;
-    if (r1IsCircle && r2IsCircle) intersectKind = "circleCircle";
-    else if (r1IsCircle || r2IsCircle) intersectKind = "lineCircle";
-    else intersectKind = "lineLine";
-    const attrs = {
-      kind: intersectKind,
-      ref1: resolveId(ids, p.ref1),
-      ref2: resolveId(ids, p.ref2)
-    };
-    if (intersectKind !== "lineLine") {
-      attrs.branch = p.branch ?? 0;
-    }
-    return {
-      id: baseId,
-      kind: "intersection",
-      ...baseFields,
-      attrs
-    };
-  }
-  let constraint;
-  switch (p.kind) {
-    case "free":
-      constraint = { kind: "free", x: p.x, y: p.y };
-      break;
-    case "midpoint":
-      constraint = { kind: "midpoint", p1: resolveId(ids, p.p1), p2: resolveId(ids, p.p2) };
-      break;
-    case "onSegment":
-      constraint = { kind: "onSegment", segmentId: resolveId(ids, p.segmentId), t: p.t };
-      break;
-    case "onLine":
-      constraint = { kind: "onLine", lineId: resolveId(ids, p.lineId), t: p.t };
-      break;
-    case "onCircle":
-      constraint = { kind: "onCircle", circleId: resolveId(ids, p.circleId), theta: p.theta };
-      break;
-    case "perpFoot":
-      constraint = { kind: "perpFoot", from: resolveId(ids, p.from), onLine: resolveId(ids, p.onLine) };
-      break;
-    case "circumcenter":
-    case "incenter":
-    case "centroid":
-    case "orthocenter":
-      constraint = {
-        kind: p.kind,
-        vertices: [resolveId(ids, p.vertices[0]), resolveId(ids, p.vertices[1]), resolveId(ids, p.vertices[2])]
-      };
-      break;
-  }
-  return {
-    id: baseId,
-    kind: "point",
-    ...baseFields,
-    attrs: { constraint }
-  };
-}
-
-// src/stamps/geometry-2d/dsl/transpile/emitShape.ts
-function r(ids, name) {
-  const id = ids.get(name);
-  if (!id) throw new Error(`emitShape: id not assigned for "${name}"`);
-  return id;
-}
-function emitShape(s, ids) {
-  const id = r(ids, s.name);
-  const base = {
-    label: s.name,
-    visible: true,
-    locked: false,
-    layer: "default",
-    schemaVersion: 1
-  };
-  switch (s.kind) {
-    case "segment":
-      return { id, kind: "segment", ...base, attrs: { p1: r(ids, s.p1), p2: r(ids, s.p2) } };
-    case "line":
-      return { id, kind: "line", ...base, attrs: { p1: r(ids, s.p1), p2: r(ids, s.p2) } };
-    case "ray":
-      return { id, kind: "ray", ...base, attrs: { origin: r(ids, s.origin), through: r(ids, s.through) } };
-    case "polygon":
-      return { id, kind: "polygon", ...base, attrs: { vertices: s.vertices.map((v) => r(ids, v)) } };
-    case "perpendicular":
-    case "parallel":
-      return {
-        id,
-        kind: "line",
-        ...base,
-        attrs: { construction: { kind: s.kind, throughPoint: r(ids, s.throughPoint), toLine: r(ids, s.toLine) } }
-      };
-    case "perpBisector":
-      return {
-        id,
-        kind: "line",
-        ...base,
-        attrs: { construction: { kind: "perpBisector", p1: r(ids, s.p1), p2: r(ids, s.p2) } }
-      };
-    case "angleBisector":
-      return {
-        id,
-        kind: "line",
-        ...base,
-        attrs: { construction: { kind: "angleBisector", p1: r(ids, s.p1), vertex: r(ids, s.vertex), p2: r(ids, s.p2) } }
-      };
-    case "tangent": {
-      const construction = {
-        kind: "tangent",
-        throughPoint: r(ids, s.throughPoint),
-        toCircle: r(ids, s.toCircle)
-      };
-      if (s.branch !== void 0) construction.branch = s.branch;
-      return { id, kind: "line", ...base, attrs: { construction } };
-    }
-    case "circleCP":
-      return {
-        id,
-        kind: "circle",
-        ...base,
-        attrs: { center: r(ids, s.center), surfacePoint: r(ids, s.surfacePoint) }
-      };
-    case "circle3":
-      return {
-        id,
-        kind: "circle",
-        ...base,
-        attrs: { construction: { kind: "circumscribed", p1: r(ids, s.p1), p2: r(ids, s.p2), p3: r(ids, s.p3) } }
-      };
-  }
-}
-
-// src/stamps/geometry-2d/dsl/transpile.ts
-function hintOf(entity) {
-  if ("kind" in entity) {
-    switch (entity.kind) {
-      case "free":
-      case "midpoint":
-      case "onSegment":
-      case "onLine":
-      case "onCircle":
-      case "perpFoot":
-      case "circumcenter":
-      case "incenter":
-      case "centroid":
-      case "orthocenter":
-      case "intersection":
-        return "point";
-      case "segment":
-        return "segment";
-      case "line":
-        return "line";
-      case "ray":
-        return "ray";
-      case "polygon":
-        return "point";
-      // not used as ref target in MVP
-      case "perpendicular":
-      case "parallel":
-      case "perpBisector":
-      case "angleBisector":
-      case "tangent":
-        return "lineConstruction";
-      case "circleCP":
-      case "circle3":
-        return "circle";
-    }
-  }
-  return "point";
-}
-function transpile(dslRaw) {
-  const parsed = DslInput.safeParse(dslRaw);
-  if (!parsed.success) {
-    const errors = parsed.error.issues.map(
-      (iss) => mkError("SCHEMA", iss.message, { path: iss.path.map(String) })
-    );
-    return { ok: false, errors };
-  }
-  const dsl = parsed.data;
-  const { symbols, errors: dupErrors } = buildSymbols(dsl);
-  const { errors: refErrors } = validateRefs(dsl, symbols);
-  const { errors: cycleErrors } = detectCycles(symbols);
-  const allErrors = [...dupErrors, ...refErrors, ...cycleErrors];
-  if (allErrors.length > 0) return { ok: false, errors: allErrors };
-  const ids = assignIds(symbols);
-  const kindHints = /* @__PURE__ */ new Map();
-  for (const [name, sym] of symbols.entries()) {
-    kindHints.set(name, hintOf(sym.entity));
-  }
-  const objects = {};
-  const order = [];
-  for (const p of dsl.points) {
-    const obj = emitPoint(p, ids, kindHints);
-    objects[obj.id] = obj;
-    order.push(obj.id);
-  }
-  for (const s of dsl.shapes) {
-    const obj = emitShape(s, ids);
-    objects[obj.id] = obj;
-    order.push(obj.id);
-  }
-  const empty = createEmptyState("2d");
-  const state = {
-    objects,
-    order,
-    counter: order.length,
-    meta: empty.meta
-  };
-  return { ok: true, state };
-}
-async function callProvider(args) {
-  const client = new Anthropic__default.default({ apiKey: args.apiKey });
-  const resp = await client.messages.create(
-    {
-      model: args.model,
-      max_tokens: args.maxTokens,
-      system: args.system,
-      tools: args.tools,
-      tool_choice: args.toolChoice,
-      messages: args.messages
-    },
-    args.signal ? { signal: args.signal } : void 0
-  );
-  return resp;
-}
-
-// src/stamps/geometry-2d/dsl/fixtures/triangle-equilateral.ts
-var fixture = {
-  problem: "Cho tam gi\xE1c \u0111\u1EC1u ABC c\u1EA1nh 4.",
-  dsl: {
-    version: 1,
-    points: [
-      { name: "A", kind: "free", x: 0, y: 0 },
-      { name: "B", kind: "free", x: 4, y: 0 },
-      { name: "C", kind: "free", x: 2, y: 3.464 }
-    ],
-    shapes: [
-      { name: "ABC", kind: "polygon", vertices: ["A", "B", "C"] }
-    ]
-  }
-};
-
-// src/stamps/geometry-2d/dsl/fixtures/triangle-median.ts
-var fixture2 = {
-  problem: "Tam gi\xE1c ABC, M l\xE0 trung \u0111i\u1EC3m BC. V\u1EBD AM.",
-  dsl: {
-    version: 1,
-    points: [
-      { name: "A", kind: "free", x: 0, y: 3 },
-      { name: "B", kind: "free", x: -2, y: 0 },
-      { name: "C", kind: "free", x: 3, y: 0 },
-      { name: "M", kind: "midpoint", p1: "B", p2: "C" }
-    ],
-    shapes: [
-      { name: "ABC", kind: "polygon", vertices: ["A", "B", "C"] },
-      { name: "AM", kind: "segment", p1: "A", p2: "M" }
-    ]
-  }
-};
-
-// src/stamps/geometry-2d/dsl/fixtures/triangle-altitude.ts
-var fixture3 = {
-  problem: "Tam gi\xE1c ABC, AH l\xE0 \u0111\u01B0\u1EDDng cao xu\u1ED1ng BC.",
-  dsl: {
-    version: 1,
-    points: [
-      { name: "A", kind: "free", x: 1, y: 3 },
-      { name: "B", kind: "free", x: -2, y: 0 },
-      { name: "C", kind: "free", x: 3, y: 0 },
-      { name: "H", kind: "perpFoot", from: "A", onLine: "BC" }
-    ],
-    shapes: [
-      { name: "ABC", kind: "polygon", vertices: ["A", "B", "C"] },
-      { name: "BC", kind: "segment", p1: "B", p2: "C" },
-      { name: "AH", kind: "segment", p1: "A", p2: "H" }
-    ]
-  }
-};
-
-// src/stamps/geometry-2d/dsl/fixtures/triangle-centroid.ts
-var fixture4 = {
-  problem: "Tam gi\xE1c ABC, G l\xE0 tr\u1ECDng t\xE2m.",
-  dsl: {
-    version: 1,
-    points: [
-      { name: "A", kind: "free", x: 0, y: 3 },
-      { name: "B", kind: "free", x: -2, y: 0 },
-      { name: "C", kind: "free", x: 3, y: 0 },
-      { name: "G", kind: "centroid", vertices: ["A", "B", "C"] }
-    ],
-    shapes: [
-      { name: "ABC", kind: "polygon", vertices: ["A", "B", "C"] }
-    ]
-  }
-};
-
-// src/stamps/geometry-2d/dsl/fixtures/triangle-orthocenter.ts
-var fixture5 = {
-  problem: "Tam gi\xE1c ABC, H l\xE0 tr\u1EF1c t\xE2m.",
-  dsl: {
-    version: 1,
-    points: [
-      { name: "A", kind: "free", x: 0, y: 3 },
-      { name: "B", kind: "free", x: -2, y: 0 },
-      { name: "C", kind: "free", x: 3, y: 0 },
-      { name: "H", kind: "orthocenter", vertices: ["A", "B", "C"] }
-    ],
-    shapes: [
-      { name: "ABC", kind: "polygon", vertices: ["A", "B", "C"] }
-    ]
-  }
-};
-
-// src/stamps/geometry-2d/dsl/fixtures/triangle-circumcircle.ts
-var fixture6 = {
-  problem: "Tam gi\xE1c ABC n\u1ED9i ti\u1EBFp \u0111\u01B0\u1EDDng tr\xF2n t\xE2m O.",
-  dsl: {
-    version: 1,
-    points: [
-      { name: "A", kind: "free", x: 0, y: 3 },
-      { name: "B", kind: "free", x: -2, y: 0 },
-      { name: "C", kind: "free", x: 3, y: 0 },
-      { name: "O", kind: "circumcenter", vertices: ["A", "B", "C"] }
-    ],
-    shapes: [
-      { name: "ABC", kind: "polygon", vertices: ["A", "B", "C"] },
-      { name: "k", kind: "circle3", p1: "A", p2: "B", p3: "C" }
-    ]
-  }
-};
-
-// src/stamps/geometry-2d/dsl/fixtures/triangle-incircle.ts
-var fixture7 = {
-  problem: "Tam gi\xE1c ABC, I l\xE0 t\xE2m n\u1ED9i ti\u1EBFp, \u0111\u01B0\u1EDDng tr\xF2n (I) ti\u1EBFp x\xFAc BC t\u1EA1i D.",
-  dsl: {
-    version: 1,
-    points: [
-      { name: "A", kind: "free", x: 0, y: 3 },
-      { name: "B", kind: "free", x: -2, y: 0 },
-      { name: "C", kind: "free", x: 3, y: 0 },
-      { name: "I", kind: "incenter", vertices: ["A", "B", "C"] },
-      { name: "D", kind: "perpFoot", from: "I", onLine: "BC" }
-    ],
-    shapes: [
-      { name: "ABC", kind: "polygon", vertices: ["A", "B", "C"] },
-      { name: "BC", kind: "segment", p1: "B", p2: "C" },
-      { name: "incircle", kind: "circleCP", center: "I", surfacePoint: "D" }
-    ]
-  }
-};
-
-// src/stamps/geometry-2d/dsl/fixtures/parallelogram.ts
-var fixture8 = {
-  problem: "H\xECnh b\xECnh h\xE0nh ABCD, hai \u0111\u01B0\u1EDDng ch\xE9o AC, BD c\u1EAFt nhau t\u1EA1i O.",
-  dsl: {
-    version: 1,
-    points: [
-      { name: "A", kind: "free", x: 0, y: 0 },
-      { name: "B", kind: "free", x: 4, y: 0 },
-      { name: "C", kind: "free", x: 5, y: 2 },
-      { name: "D", kind: "free", x: 1, y: 2 },
-      { name: "O", kind: "intersection", ref1: "AC", ref2: "BD" }
-    ],
-    shapes: [
-      { name: "ABCD", kind: "polygon", vertices: ["A", "B", "C", "D"] },
-      { name: "AC", kind: "segment", p1: "A", p2: "C" },
-      { name: "BD", kind: "segment", p1: "B", p2: "D" }
-    ]
-  }
-};
-
-// src/stamps/geometry-2d/dsl/fixtures/two-circles-intersect.ts
-var fixture9 = {
-  problem: "Hai \u0111\u01B0\u1EDDng tr\xF2n (O\u2081), (O\u2082) c\u1EAFt nhau t\u1EA1i P, Q.",
-  dsl: {
-    version: 1,
-    points: [
-      { name: "O1", kind: "free", x: 0, y: 0 },
-      { name: "A1", kind: "free", x: 2, y: 0 },
-      { name: "O2", kind: "free", x: 3, y: 0 },
-      { name: "A2", kind: "free", x: 5, y: 0 },
-      { name: "P", kind: "intersection", ref1: "k1", ref2: "k2", branch: 0 },
-      { name: "Q", kind: "intersection", ref1: "k1", ref2: "k2", branch: 1 }
-    ],
-    shapes: [
-      { name: "k1", kind: "circleCP", center: "O1", surfacePoint: "A1" },
-      { name: "k2", kind: "circleCP", center: "O2", surfacePoint: "A2" }
-    ]
-  }
-};
-
-// src/stamps/geometry-2d/ai/prompt.ts
-var FIXTURES = [fixture, fixture2, fixture3, fixture4, fixture5, fixture6, fixture7, fixture8, fixture9];
-function buildSystemPrompt() {
-  const examples = FIXTURES.map(
-    (f, i) => `### V\xED d\u1EE5 ${i + 1}
-**\u0110\u1EC1:** ${f.problem}
-**DSL:**
-\`\`\`json
-${JSON.stringify(f.dsl, null, 2)}
-\`\`\``
-  ).join("\n\n");
-  return `B\u1EA1n l\xE0 tr\u1EE3 l\xFD v\u1EBD h\xECnh h\u1ECDc 2D cho h\u1ECDc sinh THCS v\xE0 l\u1EDBp 10 Vi\u1EC7t Nam.
-
-## Nhi\u1EC7m v\u1EE5
-\u0110\u1ECDc \u0111\u1EC1 b\xE0i ti\u1EBFng Vi\u1EC7t \u2192 emit DSL JSON m\xF4 t\u1EA3 h\xECnh. H\u1EC7 th\u1ED1ng s\u1EBD render h\xECnh t\u1EEB DSL.
-
-## Quy t\u1EAFc
-1. D\xF9ng tool \`build_figure\` khi v\u1EBD \u0111\u01B0\u1EE3c. D\xF9ng tool \`refuse\` khi kh\xF4ng v\u1EBD \u0111\u01B0\u1EE3c ho\u1EB7c \u0111\u1EC1 ngo\xE0i ph\u1EA1m vi (3D, l\u01B0\u1EE3ng gi\xE1c, ph\xE9p bi\u1EBFn h\xECnh l\u1EDBp 11+, \u0111\u1EA1i s\u1ED1).
-2. \u01AFu ti\xEAn derived points (midpoint, perpFoot, circumcenter, ...) thay v\xEC t\u1EF1 compute to\u1EA1 \u0111\u1ED9.
-3. Anchor (free) ch\u1EC9 d\xF9ng cho \u0111i\u1EC3m g\u1ED1c (th\u01B0\u1EDDng A, B, C c\u1EE7a tam gi\xE1c). \u0110\u1EB7t coord h\u1EE3p l\xFD quanh g\u1ED1c (-5..5).
-4. M\u1ECDi \u0111i\u1EC3m + h\xECnh ph\u1EA3i c\xF3 \`name\` (label "A", "M", "O\u2081", ...). Tham chi\u1EBFu b\u1EB1ng name, kh\xF4ng ph\u1EA3i id.
-5. Tam gi\xE1c: emit c\u1EA3 \`polygon\` (v\u1EBD vi\u1EC1n) + segment/\u0111\u01B0\u1EDDng ph\u1EE5 ri\xEAng n\u1EBFu \u0111\u1EC1 y\xEAu c\u1EA7u (\u0111\u01B0\u1EDDng cao, trung tuy\u1EBFn).
-6. \u0110\u01B0\u1EDDng tr\xF2n (O; R) cho tr\u01B0\u1EDBc b\xE1n k\xEDnh s\u1ED1: emit anchor helper tr\xEAn \u0111\u01B0\u1EDDng tr\xF2n r\u1ED3i d\xF9ng \`circleCP\` (DSL kh\xF4ng h\u1ED7 tr\u1EE3 radius numeric tr\u1EF1c ti\u1EBFp).
-7. N\u1EBFu \u0111\u1EC1 m\u01A1 h\u1ED3: ch\u1ECDn case ph\u1ED5 bi\u1EBFn nh\u1EA5t, kh\xF4ng h\u1ECFi l\u1EA1i.
-
-## Primitives s\u1EB5n c\xF3
-**Points:** free, midpoint, onSegment, onLine, onCircle, perpFoot, circumcenter, incenter, centroid, orthocenter, intersection
-**Shapes:** segment, line, ray, polygon, perpendicular, parallel, perpBisector, angleBisector, tangent, circleCP, circle3
-
-## 9 v\xED d\u1EE5
-${examples}
-
-## Khi kh\xF4ng v\u1EBD \u0111\u01B0\u1EE3c
-G\u1ECDi \`refuse\` v\u1EDBi \`reason\` ti\u1EBFng Vi\u1EC7t gi\u1EA3i th\xEDch c\u1EE5 th\u1EC3 (vd: "\u0110\u1EC1 thu\u1ED9c l\u1EDBp 11, ngo\xE0i ph\u1EA1m vi MVP" ho\u1EB7c "\u0110\u1EC1 kh\xF4ng r\xF5 v\u1ECB tr\xED \u0111i\u1EC3m M").`;
-}
-var BUILD_FIGURE_TOOL = {
-  name: "build_figure",
-  description: "V\u1EBD h\xECnh h\u1ECDc 2D theo \u0111\u1EC1 b\xE0i. Emit DSL JSON m\xF4 t\u1EA3 c\xE1c \u0111i\u1EC3m v\xE0 h\xECnh.",
-  input_schema: zodToJsonSchema.zodToJsonSchema(DslInput, {
-    target: "jsonSchema7",
-    $refStrategy: "none"
-  })
-};
-var RefuseInputZ = zod.z.object({
-  reason: zod.z.string().min(1).describe("L\xFD do kh\xF4ng v\u1EBD \u0111\u01B0\u1EE3c (ti\u1EBFng Vi\u1EC7t)")
-});
-var REFUSE_TOOL = {
-  name: "refuse",
-  description: "T\u1EEB ch\u1ED1i khi kh\xF4ng v\u1EBD \u0111\u01B0\u1EE3c ho\u1EB7c \u0111\u1EC1 ngo\xE0i ph\u1EA1m vi (3D, l\u01B0\u1EE3ng gi\xE1c, l\u1EDBp 11+).",
-  input_schema: zodToJsonSchema.zodToJsonSchema(RefuseInputZ, { target: "jsonSchema7" })
-};
-var TOOLS4 = [BUILD_FIGURE_TOOL, REFUSE_TOOL];
-
-// src/stamps/geometry-2d/ai/buildFigure.ts
-var DEFAULT_MODEL = "claude-opus-4-7";
-var DEFAULT_MAX_TOKENS = 8192;
-function toUsage(u) {
-  return {
-    inputTokens: u.input_tokens,
-    outputTokens: u.output_tokens,
-    cacheReadTokens: u.cache_read_input_tokens ?? 0,
-    cacheCreationTokens: u.cache_creation_input_tokens ?? 0
-  };
-}
-async function generateFigure(problem, opts) {
-  if (!opts.apiKey) {
-    return { ok: false, reason: "api_error", message: "apiKey b\u1EAFt bu\u1ED9c" };
-  }
-  if (!problem || !problem.trim()) {
-    return { ok: false, reason: "api_error", message: "\u0110\u1EC1 b\xE0i r\u1ED7ng" };
-  }
-  const systemText = buildSystemPrompt();
-  const enableCaching = opts.enableCaching !== false;
-  const systemBlock = enableCaching ? { type: "text", text: systemText, cache_control: { type: "ephemeral" } } : { type: "text", text: systemText };
-  let response;
-  try {
-    response = await callProvider({
-      apiKey: opts.apiKey,
-      model: opts.model ?? DEFAULT_MODEL,
-      maxTokens: opts.maxTokens ?? DEFAULT_MAX_TOKENS,
-      system: [systemBlock],
-      tools: TOOLS4,
-      toolChoice: { type: "any" },
-      messages: [{ role: "user", content: problem }],
-      signal: opts.signal
-    });
-  } catch (e) {
-    const err = e;
-    return {
-      ok: false,
-      reason: "api_error",
-      message: err.message ?? "L\u1ED7i g\u1ECDi Claude API",
-      ...err.status !== void 0 ? { status: err.status } : {}
-    };
-  }
-  const usage = toUsage(response.usage);
-  const toolUse = response.content.find((c) => c.type === "tool_use");
-  if (!toolUse || toolUse.type !== "tool_use") {
-    const text = response.content.find((c) => c.type === "text");
-    const textStr = text?.type === "text" ? text.text : "(empty)";
-    return {
-      ok: false,
-      reason: "parse_error",
-      message: "AI kh\xF4ng g\u1ECDi tool n\xE0o. Response: " + textStr,
-      raw: response.content,
-      usage
-    };
-  }
-  if (toolUse.name === "refuse") {
-    const input = toolUse.input;
-    return {
-      ok: false,
-      reason: "refused",
-      message: input.reason ?? "AI t\u1EEB ch\u1ED1i kh\xF4ng n\xEAu l\xFD do",
-      usage
-    };
-  }
-  if (toolUse.name !== "build_figure") {
-    return {
-      ok: false,
-      reason: "parse_error",
-      message: `Tool kh\xF4ng x\xE1c \u0111\u1ECBnh: "${toolUse.name}"`,
-      raw: toolUse,
-      usage
-    };
-  }
-  const tResult = transpile(toolUse.input);
-  if (!tResult.ok) {
-    return {
-      ok: false,
-      reason: "transpile_error",
-      message: "DSL t\u1EEB AI kh\xF4ng h\u1EE3p l\u1EC7",
-      errors: tResult.errors,
-      dsl: toolUse.input,
-      usage
-    };
-  }
-  return {
-    ok: true,
-    state: tResult.state,
-    dsl: toolUse.input,
-    usage
-  };
-}
 
 exports.ALL_STAMPS = ALL_STAMPS;
 exports.DEFAULT_STAMPS = DEFAULT_STAMPS;
@@ -16189,7 +15190,6 @@ exports.closePdfDocument = closePdfDocument;
 exports.configurePdfWorker = configurePdfWorker;
 exports.findCatalogEntry = findCatalogEntry;
 exports.findStampForCustomData = findStampForCustomData;
-exports.generateFigure = generateFigure;
 exports.geometry3dStamp = geometry3dStamp;
 exports.geometryStamp = geometryStamp;
 exports.graph2dStamp = graph2dStamp;