@xom11/whiteboard 0.11.0 → 0.24.0

package/dist/index.mjs

@@ -1,35 +1,72 @@
 "use client";
 import './index.css';
-import { geometryStamp } from './chunk-YVJP7NRG.mjs';
-export { geometryStamp } from './chunk-YVJP7NRG.mjs';
-import { geometry3dStamp } from './chunk-PWIMZIB6.mjs';
-export { geometry3dStamp } from './chunk-PWIMZIB6.mjs';
-import { latexStamp } from './chunk-7P7SQFOW.mjs';
-export { latexStamp } from './chunk-7P7SQFOW.mjs';
-import { graph2dStamp } from './chunk-D257NCQW.mjs';
-export { graph2dStamp } from './chunk-D257NCQW.mjs';
-export { isGraph2DCustomData } from './chunk-74VEEZBV.mjs';
-export { isGeometryCustomData } from './chunk-G7FR3AIV.mjs';
-export { isLatexCustomData } from './chunk-X5R72SSJ.mjs';
-export { isGeometry3DCustomData } from './chunk-WQOABS6N.mjs';
-import './chunk-HTBLO5JO.mjs';
-import './chunk-C6SCVOMC.mjs';
-import './chunk-BJTO5JO5.mjs';
-import { lazy, useState, useRef, useMemo, useCallback, useEffect, Suspense } from 'react';
+import { geometryStamp } from './chunk-O6QTYAKE.mjs';
+export { geometryStamp } from './chunk-O6QTYAKE.mjs';
+import { geometry3dStamp } from './chunk-2SKXRBGS.mjs';
+export { geometry3dStamp } from './chunk-2SKXRBGS.mjs';
+import { latexStamp } from './chunk-RXOFO64U.mjs';
+export { latexStamp } from './chunk-RXOFO64U.mjs';
+import { graph2dStamp } from './chunk-XVSO7FBM.mjs';
+export { graph2dStamp } from './chunk-XVSO7FBM.mjs';
+import './chunk-33PEN2WC.mjs';
+import './chunk-O4WIZFRQ.mjs';
+import './chunk-VBJLUHCY.mjs';
+import './chunk-7WG2KDRF.mjs';
+import './chunk-FZY33J6Z.mjs';
+import './chunk-6XUPIGVD.mjs';
+import './chunk-X5R72SSJ.mjs';
+import './chunk-RBUILBX3.mjs';
+import './chunk-R5FL6S7L.mjs';
+import './chunk-RD34F5PM.mjs';
+import { createEmptyState } from './chunk-3KBL77M6.mjs';
+import './chunk-VRWZILTG.mjs';
+import './chunk-TQYQVXNW.mjs';
+import './chunk-5UTGXHLJ.mjs';
+import { lazy, useRef, useCallback, useEffect, Suspense, useState, useMemo, useLayoutEffect } from 'react';
 import { createPortal } from 'react-dom';
 import { jsxs, jsx, Fragment } from 'react/jsx-runtime';
 import '@excalidraw/excalidraw/index.css';
+import { z } from 'zod';
+import Anthropic from '@anthropic-ai/sdk';
+import { zodToJsonSchema } from 'zod-to-json-schema';
 
-// src/serialize.ts
-function pickSyncableAppState(s) {
-  return {
-    viewBackgroundColor: s.viewBackgroundColor,
-    zoom: s.zoom,
-    scrollX: s.scrollX,
-    scrollY: s.scrollY,
-    gridSize: s.gridSize ?? null,
-    theme: s.theme
-  };
+// src/stamps/shared/catalog.ts
+var STAMP_CATALOG = Object.freeze([
+  {
+    id: "geometry",
+    title: "H\xECnh h\u1ECDc 2D (JSXGraph)",
+    version: 1,
+    experimental: false,
+    runtimeDeps: ["jsxgraph"],
+    bundleSize: { js: 50.75, css: 0 }
+  },
+  {
+    id: "latex",
+    title: "C\xF4ng th\u1EE9c LaTeX (KaTeX)",
+    version: 1,
+    experimental: false,
+    runtimeDeps: ["katex"],
+    bundleSize: { js: 8.93, css: 0 }
+  },
+  {
+    id: "geometry3d",
+    title: "H\xECnh h\u1ECDc 3D (JSXGraph view3d)",
+    version: 2,
+    experimental: true,
+    runtimeDeps: ["jsxgraph"],
+    bundleSize: { js: 40.03, css: 0 }
+  },
+  {
+    id: "graph2d",
+    title: "\u0110\u1ED3 th\u1ECB h\xE0m s\u1ED1 2D (JSXGraph)",
+    version: 2,
+    experimental: true,
+    runtimeDeps: ["jsxgraph"],
+    bundleSize: { js: 33.27, css: 0 }
+  }
+]);
+function findCatalogEntry(id) {
+  return STAMP_CATALOG.find((entry) => entry.id === id) ?? null;
 }
 
 // src/stamps/shared/registry.ts
@@ -922,17 +959,14 @@ function ThumbnailItem({ pageNum, thumb, selected, onToggle }) {
               alignItems: "center",
               justifyContent: "center"
             },
-            children: thumb ? (
-              // eslint-disable-next-line @next/next/no-img-element
-              /* @__PURE__ */ jsx(
-                "img",
-                {
-                  src: thumb.dataURL,
-                  alt: "",
-                  style: { width: "100%", height: "100%", display: "block", objectFit: "contain" },
-                  draggable: false
-                }
-              )
+            children: thumb ? /* @__PURE__ */ jsx(
+              "img",
+              {
+                src: thumb.dataURL,
+                alt: "",
+                style: { width: "100%", height: "100%", display: "block", objectFit: "contain" },
+                draggable: false
+              }
             ) : /* @__PURE__ */ jsx("div", { style: { fontSize: 11, opacity: 0.5 }, children: "\u2026" })
           }
         ),
@@ -980,6 +1014,174 @@ function ThumbnailItem({ pageNum, thumb, selected, onToggle }) {
     }
   );
 }
+var DOUBLE_CLICK_MS = 400;
+function useStampDoubleClick({ enabled, stamps, onOpen }) {
+  const lastClickRef = useRef({
+    time: 0,
+    elementId: null
+  });
+  return useCallback(
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    (_activeTool, pointerDownState) => {
+      if (!enabled) return;
+      const hitElement = pointerDownState?.hit?.element;
+      if (!hitElement || hitElement.type !== "image") return;
+      const stamp = findStampForCustomData(hitElement.customData, stamps);
+      if (!stamp) return;
+      const now = Date.now();
+      const isDouble = lastClickRef.current.elementId === hitElement.id && now - lastClickRef.current.time < DOUBLE_CLICK_MS;
+      lastClickRef.current = { time: now, elementId: hitElement.id };
+      if (!isDouble) return;
+      onOpen(stamp.kind, {
+        id: hitElement.id,
+        customData: hitElement.customData
+      });
+    },
+    [enabled, stamps, onOpen]
+  );
+}
+var ALLOWED_KEYS = /* @__PURE__ */ new Set([
+  "Tab",
+  "ArrowUp",
+  "ArrowDown",
+  "ArrowLeft",
+  "ArrowRight",
+  "Shift",
+  "Control",
+  "Alt",
+  "Meta",
+  "CapsLock",
+  "Home",
+  "End",
+  "PageUp",
+  "PageDown"
+]);
+function isEditable(el) {
+  if (!(el instanceof HTMLElement)) return false;
+  if (el.isContentEditable) return true;
+  const tag = el.tagName;
+  return tag === "INPUT" || tag === "TEXTAREA" || tag === "SELECT";
+}
+function useStampShortcutBlocker({ activeStamp, stamps }) {
+  const shortcutKeys = useMemo(
+    () => new Set(stamps.map((s) => s.shortcutKey.toLowerCase())),
+    [stamps]
+  );
+  useEffect(() => {
+    if (!activeStamp) return;
+    const blocker = (e) => {
+      if (isEditable(e.target)) return;
+      if (e.ctrlKey || e.metaKey) return;
+      if (ALLOWED_KEYS.has(e.key)) return;
+      if (e.key === "Escape") return;
+      if (shortcutKeys.has(e.key.toLowerCase())) return;
+      e.preventDefault();
+      e.stopPropagation();
+    };
+    window.addEventListener("keydown", blocker, { capture: true });
+    return () => window.removeEventListener("keydown", blocker, { capture: true });
+  }, [activeStamp, shortcutKeys]);
+}
+function useStampClickOutside({ activeStamp, hostRef, onClose }) {
+  useEffect(() => {
+    if (!activeStamp) return;
+    let lastFire = 0;
+    const handler = (e) => {
+      const target = e.target;
+      if (!target) return;
+      if (target.closest('[data-stamp-area="true"]')) return;
+      const now = Date.now();
+      if (now - lastFire < 50) return;
+      lastFire = now;
+      hostRef.current?.tryInsert();
+      onClose();
+    };
+    window.addEventListener("pointerdown", handler, { capture: true });
+    window.addEventListener("mousedown", handler, { capture: true });
+    return () => {
+      window.removeEventListener("pointerdown", handler, { capture: true });
+      window.removeEventListener("mousedown", handler, { capture: true });
+    };
+  }, [activeStamp, hostRef, onClose]);
+}
+function useExcalidrawApi(opts = {}) {
+  const { onApi } = opts;
+  const [api, setApi] = useState(null);
+  const apiRef = useRef(null);
+  const [isDark, setIsDark] = useState(false);
+  const isDarkRef = useRef(false);
+  const onApiRef = useRef(onApi);
+  onApiRef.current = onApi;
+  const setApiFromExcalidraw = useCallback((a) => {
+    if (apiRef.current === a) return;
+    apiRef.current = a;
+    queueMicrotask(() => {
+      setApi(a);
+      onApiRef.current?.(a);
+    });
+  }, []);
+  const syncThemeFromAppState = useCallback(
+    (appState) => {
+      const next = appState?.theme === "dark";
+      if (isDarkRef.current !== next) {
+        isDarkRef.current = next;
+        queueMicrotask(() => setIsDark(next));
+      }
+    },
+    []
+  );
+  return { api, apiRef, isDark, isDarkRef, setApiFromExcalidraw, syncThemeFromAppState };
+}
+function useActiveStamp(opts) {
+  const { readOnly, stamps } = opts;
+  const [activeStamp, setActiveStamp] = useState(null);
+  const [editingElement, setEditingElement] = useState(null);
+  const stampByKind = useMemo(() => {
+    const m = /* @__PURE__ */ new Map();
+    for (const s of stamps) m.set(s.kind, s);
+    return m;
+  }, [stamps]);
+  const activeStampDef = activeStamp ? stampByKind.get(activeStamp) ?? null : null;
+  const HostComponent = activeStampDef?.Host ?? null;
+  const openStamp = useCallback(
+    (kind, element = null) => {
+      if (readOnly) return;
+      if (!stampByKind.has(kind)) return;
+      setEditingElement(element);
+      setActiveStamp(kind);
+    },
+    [readOnly, stampByKind]
+  );
+  const closeStamp = useCallback(() => {
+    setActiveStamp(null);
+    setEditingElement(null);
+  }, []);
+  const toggleStampByKind = useCallback(
+    (kind) => {
+      setActiveStamp((cur) => {
+        if (cur === kind) {
+          setEditingElement(null);
+          return null;
+        }
+        if (readOnly) return cur;
+        if (!stampByKind.has(kind)) return cur;
+        setEditingElement(null);
+        return kind;
+      });
+    },
+    [readOnly, stampByKind]
+  );
+  return {
+    activeStamp,
+    editingElement,
+    stampByKind,
+    activeStampDef,
+    HostComponent,
+    openStamp,
+    closeStamp,
+    toggleStampByKind
+  };
+}
 
 // src/pdf/insertPdfPages.ts
 var PAGE_GAP = 24;
@@ -1089,95 +1291,103 @@ async function insertPdfPages(api, source, options = {}) {
   });
   return { insertedElementIds, pages: rendered };
 }
-var DOUBLE_CLICK_MS = 400;
-function useStampDoubleClick({ enabled, stamps, onOpen }) {
-  const lastClickRef = useRef({
-    time: 0,
-    elementId: null
-  });
-  return useCallback(
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    (_activeTool, pointerDownState) => {
-      if (!enabled) return;
-      const hitElement = pointerDownState?.hit?.element;
-      if (!hitElement || hitElement.type !== "image") return;
-      const stamp = findStampForCustomData(hitElement.customData, stamps);
-      if (!stamp) return;
-      const now = Date.now();
-      const isDouble = lastClickRef.current.elementId === hitElement.id && now - lastClickRef.current.time < DOUBLE_CLICK_MS;
-      lastClickRef.current = { time: now, elementId: hitElement.id };
-      if (!isDouble) return;
-      onOpen(stamp.kind, {
-        id: hitElement.id,
-        customData: hitElement.customData
-      });
+
+// src/hooks/usePdfImporter.ts
+function usePdfImporter(opts) {
+  const { readOnly, api } = opts;
+  const [pdfPending, setPdfPending] = useState(null);
+  const [pdfBusy, setPdfBusy] = useState(false);
+  const handlePdfPick = useCallback(
+    async (file) => {
+      if (readOnly || pdfBusy) return;
+      setPdfBusy(true);
+      try {
+        const doc = await loadPdfDocument(file);
+        setPdfPending({ doc, fileName: file.name, totalPages: doc.numPages });
+      } catch (err) {
+        console.warn("[whiteboard] \u0110\u1ECDc PDF th\u1EA5t b\u1EA1i:", err);
+        window.alert("Kh\xF4ng \u0111\u1ECDc \u0111\u01B0\u1EE3c PDF. File c\xF3 th\u1EC3 \u0111\xE3 h\u1ECFng ho\u1EB7c b\u1ECB m\u1EADt kh\u1EA9u b\u1EA3o v\u1EC7.");
+      } finally {
+        setPdfBusy(false);
+      }
     },
-    [enabled, stamps, onOpen]
+    [readOnly, pdfBusy]
   );
-}
-var ALLOWED_KEYS = /* @__PURE__ */ new Set([
-  "Tab",
-  "ArrowUp",
-  "ArrowDown",
-  "ArrowLeft",
-  "ArrowRight",
-  "Shift",
-  "Control",
-  "Alt",
-  "Meta",
-  "CapsLock",
-  "Home",
-  "End",
-  "PageUp",
-  "PageDown"
-]);
-function isEditable(el) {
-  if (!(el instanceof HTMLElement)) return false;
-  if (el.isContentEditable) return true;
-  const tag = el.tagName;
-  return tag === "INPUT" || tag === "TEXTAREA" || tag === "SELECT";
-}
-function useStampShortcutBlocker({ activeStamp, stamps }) {
-  const shortcutKeys = useMemo(
-    () => new Set(stamps.map((s) => s.shortcutKey.toLowerCase())),
-    [stamps]
+  const handlePdfPickRef = useRef(handlePdfPick);
+  useLayoutEffect(() => {
+    handlePdfPickRef.current = handlePdfPick;
+  });
+  const handlePdfConfirm = useCallback(
+    async (pages) => {
+      if (!pdfPending || !api) return;
+      const { doc } = pdfPending;
+      setPdfPending(null);
+      setPdfBusy(true);
+      const scale = 2;
+      try {
+        const rendered = await rasterizePdf(doc, { pages, scale });
+        await closePdfDocument(doc);
+        insertRasterizedPagesIntoScene(api, rendered, { scale });
+      } catch (err) {
+        console.warn("[whiteboard] Ch\xE8n PDF th\u1EA5t b\u1EA1i:", err);
+        window.alert("Ch\xE8n PDF th\u1EA5t b\u1EA1i. Xem console \u0111\u1EC3 bi\u1EBFt chi ti\u1EBFt.");
+      } finally {
+        setPdfBusy(false);
+      }
+    },
+    [pdfPending, api]
   );
+  const handlePdfCancel = useCallback(() => {
+    if (pdfPending) {
+      void closePdfDocument(pdfPending.doc);
+    }
+    setPdfPending(null);
+  }, [pdfPending]);
   useEffect(() => {
-    if (!activeStamp) return;
-    const blocker = (e) => {
-      if (isEditable(e.target)) return;
-      if (e.ctrlKey || e.metaKey) return;
-      if (ALLOWED_KEYS.has(e.key)) return;
-      if (e.key === "Escape") return;
-      if (shortcutKeys.has(e.key.toLowerCase())) return;
-      e.preventDefault();
-      e.stopPropagation();
-    };
-    window.addEventListener("keydown", blocker, { capture: true });
-    return () => window.removeEventListener("keydown", blocker, { capture: true });
-  }, [activeStamp, shortcutKeys]);
-}
-function useStampClickOutside({ activeStamp, hostRef, onClose }) {
-  useEffect(() => {
-    if (!activeStamp) return;
-    let lastFire = 0;
-    const handler = (e) => {
-      const target = e.target;
-      if (!target) return;
-      if (target.closest('[data-stamp-area="true"]')) return;
-      const now = Date.now();
-      if (now - lastFire < 50) return;
-      lastFire = now;
-      hostRef.current?.tryInsert();
-      onClose();
+    if (readOnly) return;
+    const root = document.querySelector(".excalidraw");
+    if (!root) return;
+    const onDragOver = (e) => {
+      const items = e.dataTransfer?.items;
+      if (!items) return;
+      for (let i = 0; i < items.length; i++) {
+        if (items[i].kind === "file" && items[i].type === "application/pdf") {
+          e.preventDefault();
+          e.stopPropagation();
+          if (e.dataTransfer) e.dataTransfer.dropEffect = "copy";
+          return;
+        }
+      }
     };
-    window.addEventListener("pointerdown", handler, { capture: true });
-    window.addEventListener("mousedown", handler, { capture: true });
+    const onDrop = (e) => {
+      const files = e.dataTransfer?.files;
+      if (!files || files.length === 0) return;
+      const pdf = Array.from(files).find((f) => f.type === "application/pdf");
+      if (!pdf) return;
+      e.preventDefault();
+      e.stopPropagation();
+      void handlePdfPickRef.current(pdf);
+    };
+    root.addEventListener("dragover", onDragOver, { capture: true });
+    root.addEventListener("drop", onDrop, { capture: true });
     return () => {
-      window.removeEventListener("pointerdown", handler, { capture: true });
-      window.removeEventListener("mousedown", handler, { capture: true });
+      root.removeEventListener("dragover", onDragOver, { capture: true });
+      root.removeEventListener("drop", onDrop, { capture: true });
     };
-  }, [activeStamp, hostRef, onClose]);
+  }, [readOnly, api]);
+  return { pdfPending, pdfBusy, handlePdfPick, handlePdfConfirm, handlePdfCancel };
+}
+
+// src/serialize.ts
+function pickSyncableAppState(s) {
+  return {
+    viewBackgroundColor: s.viewBackgroundColor,
+    zoom: s.zoom,
+    scrollX: s.scrollX,
+    scrollY: s.scrollY,
+    gridSize: s.gridSize ?? null,
+    theme: s.theme
+  };
 }
 
 // src/stamps/shared/restoreStampFiles.ts
@@ -1187,6 +1397,7 @@ function svgToDataURL(svg) {
 }
 async function buildFileForStamp(fileId, customData, stamp) {
   try {
+    if (!stamp.matchesCustomData(customData)) return null;
     const svg = await stamp.renderSvgFromCustomData(customData);
     return { id: fileId, dataURL: svgToDataURL(svg), mimeType: "image/svg+xml", created: Date.now() };
   } catch (err) {
@@ -1507,26 +1718,25 @@ async function pruneFiles(storageKey, keepIds) {
     console.warn("[whiteboard] pruneFiles failed:", err);
   }
 }
-var Excalidraw = lazy(
-  () => import('./ExcalidrawWithMenus-EAVPOPJZ.mjs').then((m) => ({ default: m.ExcalidrawWithMenus }))
-);
-var ExcalidrawLoadingFallback = () => /* @__PURE__ */ jsx("div", { className: "flex h-full items-center justify-center text-sm text-gray-500", children: "\u0110ang t\u1EA3i b\u1EA3ng\u2026" });
+
+// src/hooks/useScenePersist.ts
 var SYNC_THROTTLE_MS = 200;
-function Whiteboard({
-  storageKey = "default",
-  readOnly = false,
-  onSceneChange,
-  onFilesChange,
-  onApi,
-  langCode = "vi-VN",
-  stamps = DEFAULT_STAMPS,
-  initialScene,
-  initialFiles
-}) {
-  const [api, setApi] = useState(null);
-  const apiRef = useRef(null);
-  const [isDarkTheme, setIsDarkTheme] = useState(false);
-  const isDarkThemeRef = useRef(false);
+var FILE_THROTTLE_MS = 1e3;
+var PRUNE_THROTTLE_MS = 2e3;
+var RESTORE_PASS_DELAY_MS = 400;
+function useScenePersist(opts) {
+  const {
+    storageKey,
+    initialScene,
+    initialFiles,
+    readOnly,
+    onSceneChange,
+    onFilesChange,
+    api,
+    apiRef,
+    stamps
+  } = opts;
+  const persistEnabled = typeof storageKey === "string" && storageKey.length > 0;
   const knownFileIdsRef = useRef(/* @__PURE__ */ new Set());
   const lastSceneHashRef = useRef("");
   const sceneThrottleRef = useRef(null);
@@ -1537,7 +1747,6 @@ function Whiteboard({
   const hashElementsVersionRef = useRef(null);
   const stampsRef = useRef(stamps);
   stampsRef.current = stamps;
-  const persistEnabled = typeof storageKey === "string" && storageKey.length > 0;
   const persistKeyRef = useRef(storageKey);
   persistKeyRef.current = storageKey;
   const onSceneChangeRef = useRef(onSceneChange);
@@ -1554,117 +1763,6 @@ function Whiteboard({
     elements: persistedInitial.elements,
     appState: persistedInitial.appState
   } : null;
-  const [activeStamp, setActiveStamp] = useState(null);
-  const activeStampRef = useRef(activeStamp);
-  activeStampRef.current = activeStamp;
-  const [editingElement, setEditingElement] = useState(null);
-  const hostRef = useRef(null);
-  const [pdfPending, setPdfPending] = useState(null);
-  const [pdfBusy, setPdfBusy] = useState(false);
-  const handledCropIdRef = useRef(null);
-  const prevExcalidrawToolRef = useRef("selection");
-  const stampByKind = useMemo(() => {
-    const m = /* @__PURE__ */ new Map();
-    for (const s of stamps) m.set(s.kind, s);
-    return m;
-  }, [stamps]);
-  const activeStampDef = activeStamp ? stampByKind.get(activeStamp) ?? null : null;
-  const HostComponent = activeStampDef?.Host ?? null;
-  const openStamp = useCallback(
-    (kind, element = null) => {
-      if (readOnly) return;
-      if (!stampByKind.has(kind)) return;
-      setEditingElement(element);
-      setActiveStamp(kind);
-    },
-    [readOnly, stampByKind]
-  );
-  const closeStamp = useCallback(() => {
-    setActiveStamp(null);
-    setEditingElement(null);
-  }, []);
-  const toggleStampByKind = useCallback(
-    (kind) => {
-      if (activeStamp === kind) closeStamp();
-      else openStamp(kind);
-    },
-    [activeStamp, openStamp, closeStamp]
-  );
-  const handleChange = useCallback(
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    (elements, appState, files) => {
-      const nextDark = appState?.theme === "dark";
-      if (isDarkThemeRef.current !== nextDark) {
-        isDarkThemeRef.current = nextDark;
-        queueMicrotask(() => setIsDarkTheme(nextDark));
-      }
-      if (readOnly) return;
-      latestSceneRef.current = { elements, appState };
-      const cropId = appState?.croppingElementId;
-      if (cropId && cropId !== handledCropIdRef.current && api) {
-        const el = elements.find((e) => e.id === cropId);
-        if (el) {
-          const stamp = findStampForCustomData(el.customData, stamps);
-          if (stamp) {
-            handledCropIdRef.current = cropId;
-            const elId = el.id;
-            const elCustom = el.customData;
-            const stampKind = stamp.kind;
-            queueMicrotask(() => {
-              try {
-                api.updateScene({
-                  appState: { croppingElementId: null, selectedElementIds: {} }
-                });
-              } catch {
-              }
-              openStamp(stampKind, { id: elId, customData: elCustom });
-            });
-            return;
-          }
-        }
-      }
-      if (!cropId) {
-        handledCropIdRef.current = null;
-      }
-      const fileIds = Object.keys(files);
-      const newIds = fileIds.filter((id) => !knownFileIdsRef.current.has(id));
-      if (newIds.length > 0) {
-        newIds.forEach((id) => knownFileIdsRef.current.add(id));
-        onFilesChange?.(files, newIds);
-      }
-      if (!sceneThrottleRef.current) {
-        sceneThrottleRef.current = setTimeout(async () => {
-          sceneThrottleRef.current = null;
-          try {
-            const mod = await import('@excalidraw/excalidraw');
-            hashElementsVersionRef.current = mod.hashElementsVersion;
-          } catch (err) {
-            console.warn("[whiteboard] import excalidraw \u0111\u1EC3 flush scene th\u1EA5t b\u1EA1i:", err);
-            return;
-          }
-          flushSceneRef.current();
-        }, SYNC_THROTTLE_MS);
-      }
-      if (persistEnabled && newIds.length > 0) {
-        for (const id of newIds) {
-          if (files[id]) pendingFilesRef.current[id] = files[id];
-        }
-        if (!fileThrottleRef.current) {
-          fileThrottleRef.current = setTimeout(() => {
-            fileThrottleRef.current = null;
-            flushFilesRef.current();
-          }, 1e3);
-        }
-      }
-      if (persistEnabled && !pruneThrottleRef.current) {
-        pruneThrottleRef.current = setTimeout(() => {
-          pruneThrottleRef.current = null;
-          flushPruneRef.current();
-        }, 2e3);
-      }
-    },
-    [readOnly, api, onSceneChange, onFilesChange, persistEnabled, storageKey, stamps, openStamp]
-  );
   const flushSceneRef = useRef(() => void 0);
   flushSceneRef.current = () => {
     try {
@@ -1725,6 +1823,46 @@ function Whiteboard({
       console.warn("[whiteboard] flushPrune th\u1EA5t b\u1EA1i:", err);
     }
   };
+  const onSceneTick = (elements, appState, files) => {
+    if (readOnly) return;
+    latestSceneRef.current = { elements, appState };
+    const fileIds = Object.keys(files);
+    const newIds = fileIds.filter((id) => !knownFileIdsRef.current.has(id));
+    if (newIds.length > 0) {
+      newIds.forEach((id) => knownFileIdsRef.current.add(id));
+      onFilesChangeRef.current?.(files, newIds);
+    }
+    if (!sceneThrottleRef.current) {
+      sceneThrottleRef.current = setTimeout(async () => {
+        sceneThrottleRef.current = null;
+        try {
+          const mod = await import('@excalidraw/excalidraw');
+          hashElementsVersionRef.current = mod.hashElementsVersion;
+        } catch (err) {
+          console.warn("[whiteboard] import excalidraw \u0111\u1EC3 flush scene th\u1EA5t b\u1EA1i:", err);
+          return;
+        }
+        flushSceneRef.current();
+      }, SYNC_THROTTLE_MS);
+    }
+    if (persistEnabled && newIds.length > 0) {
+      for (const id of newIds) {
+        if (files[id]) pendingFilesRef.current[id] = files[id];
+      }
+      if (!fileThrottleRef.current) {
+        fileThrottleRef.current = setTimeout(() => {
+          fileThrottleRef.current = null;
+          flushFilesRef.current();
+        }, FILE_THROTTLE_MS);
+      }
+    }
+    if (persistEnabled && !pruneThrottleRef.current) {
+      pruneThrottleRef.current = setTimeout(() => {
+        pruneThrottleRef.current = null;
+        flushPruneRef.current();
+      }, PRUNE_THROTTLE_MS);
+    }
+  };
   const initialFilesAddedRef = useRef(false);
   useEffect(() => {
     if (!api || initialFilesAddedRef.current) return;
@@ -1804,7 +1942,7 @@ function Whiteboard({
     void run();
     const t = setTimeout(() => {
       void run();
-    }, 400);
+    }, RESTORE_PASS_DELAY_MS);
     return () => {
       cancelled = true;
       clearTimeout(t);
@@ -1830,6 +1968,89 @@ function Whiteboard({
     },
     []
   );
+  return { effectiveInitialScene, onSceneTick };
+}
+var Excalidraw = lazy(
+  () => import('./ExcalidrawWithMenus-KBLDWPM2.mjs').then((m) => ({ default: m.ExcalidrawWithMenus }))
+);
+var ExcalidrawLoadingFallback = () => /* @__PURE__ */ jsx("div", { className: "flex h-full items-center justify-center text-sm text-gray-500", children: "\u0110ang t\u1EA3i b\u1EA3ng\u2026" });
+function Whiteboard({
+  storageKey = "default",
+  readOnly = false,
+  onSceneChange,
+  onFilesChange,
+  onApi,
+  langCode = "vi-VN",
+  stamps = DEFAULT_STAMPS,
+  initialScene,
+  initialFiles,
+  generateGeometryFigure
+}) {
+  const { api, apiRef, isDark, setApiFromExcalidraw, syncThemeFromAppState } = useExcalidrawApi({ onApi });
+  const {
+    activeStamp,
+    editingElement,
+    HostComponent,
+    openStamp,
+    closeStamp,
+    toggleStampByKind
+  } = useActiveStamp({ readOnly, stamps });
+  const {
+    pdfPending,
+    pdfBusy,
+    handlePdfPick,
+    handlePdfConfirm,
+    handlePdfCancel
+  } = usePdfImporter({ readOnly, api });
+  const { effectiveInitialScene, onSceneTick } = useScenePersist({
+    storageKey,
+    initialScene,
+    initialFiles,
+    readOnly,
+    onSceneChange,
+    onFilesChange,
+    api,
+    apiRef,
+    stamps
+  });
+  const hostRef = useRef(null);
+  const handledCropIdRef = useRef(null);
+  const prevExcalidrawToolRef = useRef("selection");
+  const handleChange = useCallback(
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    (elements, appState, files) => {
+      syncThemeFromAppState(appState);
+      if (readOnly) return;
+      const cropId = appState?.croppingElementId;
+      if (cropId && cropId !== handledCropIdRef.current && api) {
+        const el = elements.find((e) => e.id === cropId);
+        if (el) {
+          const stamp = findStampForCustomData(el.customData, stamps);
+          if (stamp) {
+            handledCropIdRef.current = cropId;
+            const elId = el.id;
+            const elCustom = el.customData;
+            const stampKind = stamp.kind;
+            queueMicrotask(() => {
+              try {
+                api.updateScene({
+                  appState: { croppingElementId: null, selectedElementIds: {} }
+                });
+              } catch {
+              }
+              openStamp(stampKind, { id: elId, customData: elCustom });
+            });
+            return;
+          }
+        }
+      }
+      if (!cropId) {
+        handledCropIdRef.current = null;
+      }
+      onSceneTick(elements, appState, files);
+    },
+    [readOnly, api, stamps, openStamp, syncThemeFromAppState, onSceneTick]
+  );
   const handlePointerDown = useStampDoubleClick({
     enabled: !readOnly,
     stamps,
@@ -1873,92 +2094,11 @@ function Whiteboard({
     return () => window.removeEventListener("keydown", onKey, { capture: true });
   }, [activeStamp, closeStamp]);
   useStampClickOutside({ activeStamp, hostRef, onClose: closeStamp });
-  const handlePdfPick = useCallback(
-    async (file) => {
-      if (readOnly || pdfBusy) return;
-      setPdfBusy(true);
-      try {
-        const doc = await loadPdfDocument(file);
-        setPdfPending({ doc, fileName: file.name, totalPages: doc.numPages });
-      } catch (err) {
-        console.warn("[whiteboard] \u0110\u1ECDc PDF th\u1EA5t b\u1EA1i:", err);
-        window.alert("Kh\xF4ng \u0111\u1ECDc \u0111\u01B0\u1EE3c PDF. File c\xF3 th\u1EC3 \u0111\xE3 h\u1ECFng ho\u1EB7c b\u1ECB m\u1EADt kh\u1EA9u b\u1EA3o v\u1EC7.");
-      } finally {
-        setPdfBusy(false);
-      }
-    },
-    [readOnly, pdfBusy]
-  );
-  const handlePdfConfirm = useCallback(
-    async (pages) => {
-      if (!pdfPending || !api) return;
-      const { doc } = pdfPending;
-      setPdfPending(null);
-      setPdfBusy(true);
-      const scale = 2;
-      try {
-        const rendered = await rasterizePdf(doc, { pages, scale });
-        await closePdfDocument(doc);
-        insertRasterizedPagesIntoScene(api, rendered, { scale });
-      } catch (err) {
-        console.warn("[whiteboard] Ch\xE8n PDF th\u1EA5t b\u1EA1i:", err);
-        window.alert("Ch\xE8n PDF th\u1EA5t b\u1EA1i. Xem console \u0111\u1EC3 bi\u1EBFt chi ti\u1EBFt.");
-      } finally {
-        setPdfBusy(false);
-      }
-    },
-    [pdfPending, api]
-  );
-  const handlePdfCancel = useCallback(() => {
-    if (pdfPending) {
-      void closePdfDocument(pdfPending.doc);
-    }
-    setPdfPending(null);
-  }, [pdfPending]);
-  useEffect(() => {
-    if (readOnly) return;
-    const root = document.querySelector(".excalidraw");
-    if (!root) return;
-    const onDragOver = (e) => {
-      const items = e.dataTransfer?.items;
-      if (!items) return;
-      for (let i = 0; i < items.length; i++) {
-        if (items[i].kind === "file" && items[i].type === "application/pdf") {
-          e.preventDefault();
-          e.stopPropagation();
-          if (e.dataTransfer) e.dataTransfer.dropEffect = "copy";
-          return;
-        }
-      }
-    };
-    const onDrop = (e) => {
-      const files = e.dataTransfer?.files;
-      if (!files || files.length === 0) return;
-      const pdf = Array.from(files).find((f) => f.type === "application/pdf");
-      if (!pdf) return;
-      e.preventDefault();
-      e.stopPropagation();
-      void handlePdfPick(pdf);
-    };
-    root.addEventListener("dragover", onDragOver, { capture: true });
-    root.addEventListener("drop", onDrop, { capture: true });
-    return () => {
-      root.removeEventListener("dragover", onDragOver, { capture: true });
-      root.removeEventListener("drop", onDrop, { capture: true });
-    };
-  }, [readOnly, handlePdfPick, api]);
-  return /* @__PURE__ */ jsxs("div", { className: `relative h-full w-full${isDarkTheme ? " theme--dark" : ""}`, children: [
+  return /* @__PURE__ */ jsxs("div", { className: `relative h-full w-full${isDark ? " theme--dark" : ""}`, children: [
     /* @__PURE__ */ jsx(Suspense, { fallback: /* @__PURE__ */ jsx(ExcalidrawLoadingFallback, {}), children: /* @__PURE__ */ jsx(
       Excalidraw,
       {
-        excalidrawAPI: (a) => {
-          if (apiRef.current === a) return;
-          apiRef.current = a;
-          queueMicrotask(() => {
-            setApi(a);
-            onApi?.(a);
-          });
-        },
+        excalidrawAPI: setApiFromExcalidraw,
         langCode,
         viewModeEnabled: readOnly,
         initialData: effectiveInitialScene ? {
@@ -2017,12 +2157,1003 @@ function Whiteboard({
         api,
         editingElement,
         onClose: closeStamp,
-        isDark: isDarkTheme
+        isDark,
+        generateGeometryFigure
       }
     )
   ] });
 }
+var NameZ = z.string().regex(/^[A-Za-z][A-Za-z0-9_'₀-₉]{0,11}$/);
+var DslPoint = z.discriminatedUnion("kind", [
+  z.object({
+    name: NameZ,
+    kind: z.literal("free"),
+    x: z.number().finite(),
+    y: z.number().finite()
+  }),
+  z.object({
+    name: NameZ,
+    kind: z.literal("midpoint"),
+    p1: NameZ,
+    p2: NameZ
+  }),
+  z.object({
+    name: NameZ,
+    kind: z.literal("onSegment"),
+    segmentId: NameZ,
+    t: z.number().min(0).max(1)
+  }),
+  z.object({
+    name: NameZ,
+    kind: z.literal("onLine"),
+    lineId: NameZ,
+    t: z.number().finite()
+  }),
+  z.object({
+    name: NameZ,
+    kind: z.literal("onCircle"),
+    circleId: NameZ,
+    theta: z.number().finite()
+  }),
+  z.object({
+    name: NameZ,
+    kind: z.literal("perpFoot"),
+    from: NameZ,
+    onLine: NameZ
+  }),
+  z.object({
+    name: NameZ,
+    kind: z.literal("circumcenter"),
+    vertices: z.tuple([NameZ, NameZ, NameZ])
+  }),
+  z.object({
+    name: NameZ,
+    kind: z.literal("incenter"),
+    vertices: z.tuple([NameZ, NameZ, NameZ])
+  }),
+  z.object({
+    name: NameZ,
+    kind: z.literal("centroid"),
+    vertices: z.tuple([NameZ, NameZ, NameZ])
+  }),
+  z.object({
+    name: NameZ,
+    kind: z.literal("orthocenter"),
+    vertices: z.tuple([NameZ, NameZ, NameZ])
+  }),
+  z.object({
+    name: NameZ,
+    kind: z.literal("intersection"),
+    ref1: NameZ,
+    ref2: NameZ,
+    branch: z.union([z.literal(0), z.literal(1)]).optional()
+  })
+]);
+var DslShape = z.discriminatedUnion("kind", [
+  z.object({
+    name: NameZ,
+    kind: z.literal("segment"),
+    p1: NameZ,
+    p2: NameZ
+  }),
+  z.object({
+    name: NameZ,
+    kind: z.literal("line"),
+    p1: NameZ,
+    p2: NameZ
+  }),
+  z.object({
+    name: NameZ,
+    kind: z.literal("ray"),
+    origin: NameZ,
+    through: NameZ
+  }),
+  z.object({
+    name: NameZ,
+    kind: z.literal("polygon"),
+    vertices: z.array(NameZ).min(3)
+  }),
+  // Line constructions
+  z.object({
+    name: NameZ,
+    kind: z.literal("perpendicular"),
+    throughPoint: NameZ,
+    toLine: NameZ
+  }),
+  z.object({
+    name: NameZ,
+    kind: z.literal("parallel"),
+    throughPoint: NameZ,
+    toLine: NameZ
+  }),
+  z.object({
+    name: NameZ,
+    kind: z.literal("perpBisector"),
+    p1: NameZ,
+    p2: NameZ
+  }),
+  z.object({
+    name: NameZ,
+    kind: z.literal("angleBisector"),
+    p1: NameZ,
+    vertex: NameZ,
+    p2: NameZ
+  }),
+  z.object({
+    name: NameZ,
+    kind: z.literal("tangent"),
+    throughPoint: NameZ,
+    toCircle: NameZ,
+    branch: z.union([z.literal(0), z.literal(1), z.literal("on")]).optional()
+  }),
+  // Circle constructions
+  z.object({
+    name: NameZ,
+    kind: z.literal("circleCP"),
+    center: NameZ,
+    surfacePoint: NameZ
+  }),
+  z.object({
+    name: NameZ,
+    kind: z.literal("circle3"),
+    p1: NameZ,
+    p2: NameZ,
+    p3: NameZ
+  })
+]);
+var DslInput = z.object({
+  version: z.literal(1),
+  points: z.array(DslPoint),
+  shapes: z.array(DslShape).default([])
+});
+
+// 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({ 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(DslInput, {
+    target: "jsonSchema7",
+    $refStrategy: "none"
+  })
+};
+var RefuseInputZ = z.object({
+  reason: 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(RefuseInputZ, { target: "jsonSchema7" })
+};
+var TOOLS = [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: TOOLS,
+      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
+  };
+}
 
-export { ALL_STAMPS, DEFAULT_STAMPS, EXPERIMENTAL_STAMPS, STABLE_STAMPS, Whiteboard, closePdfDocument, configurePdfWorker, findStampForCustomData, insertPdfPages, insertRasterizedPagesIntoScene, isStampElement, loadPdfDocument, parsePageRange, pickSyncableAppState, rasterizePdf, restoreMissingStampFiles };
+export { ALL_STAMPS, DEFAULT_STAMPS, EXPERIMENTAL_STAMPS, STABLE_STAMPS, STAMP_CATALOG, Whiteboard, closePdfDocument, configurePdfWorker, findCatalogEntry, findStampForCustomData, generateFigure, insertPdfPages, insertRasterizedPagesIntoScene, isStampElement, loadPdfDocument, parsePageRange, pickSyncableAppState, rasterizePdf, restoreMissingStampFiles };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map