@xom11/whiteboard 0.24.2 → 0.25.0

package/dist/index.js

@@ -6,6 +6,7 @@ var immer = require('immer');
 var React18 = require('react');
 var jsxRuntime = require('react/jsx-runtime');
 var reactDom = require('react-dom');
+var zod = require('zod');
 var excalidraw = require('@excalidraw/excalidraw');
 require('@excalidraw/excalidraw/index.css');
 
@@ -3269,11 +3270,11 @@ function formatMeasure(items) {
   return items.map((it) => `${it.label} = ${it.value.toFixed(2)}`).join(", ");
 }
 function ObjectRow(props) {
-  const { obj, state, selected, onSelect, onToggleVisible, onToggleLocked, onRename, onChangeColor, onDelete } = props;
+  const { obj, state, selected, onSelect, onToggleVisible, onToggleLocked, onRename, onChangeColor, onDelete, describe } = props;
   const meta = getKindUiMeta(obj.kind);
   let title = "";
   try {
-    title = getKind(obj.kind).describe(obj, state);
+    title = describe ? describe(obj, state) : getKind(obj.kind).describe(obj, state);
   } catch {
     title = `${meta.displayName} ${obj.label}`;
   }
@@ -7210,12 +7211,1122 @@ var init_Toast2 = __esm({
     init_useToast();
   }
 });
-function useAiFigure(generator) {
+var NameZ;
+var init_names = __esm({
+  "src/stamps/geometry-2d/dsl/names.ts"() {
+    NameZ = zod.z.string().regex(/^[A-Za-z][A-Za-z0-9_'₀-₉]{0,11}$/);
+  }
+});
+
+// src/stamps/geometry-2d/dsl/kinds/_types.ts
+function defineModule(m) {
+  return m;
+}
+var init_types4 = __esm({
+  "src/stamps/geometry-2d/dsl/kinds/_types.ts"() {
+  }
+});
+
+// src/stamps/geometry-2d/dsl/kinds/_shared.ts
+function emitPointObject(id, name, constraint) {
+  return {
+    id,
+    kind: "point",
+    label: name,
+    ...POINT_BASE_FIELDS,
+    attrs: { constraint }
+  };
+}
+function resolveTriangleVertices(ctx, vertices) {
+  return [ctx.resolveId(vertices[0]), ctx.resolveId(vertices[1]), ctx.resolveId(vertices[2])];
+}
+var POINT_BASE_FIELDS, SHAPE_BASE_FIELDS;
+var init_shared = __esm({
+  "src/stamps/geometry-2d/dsl/kinds/_shared.ts"() {
+    POINT_BASE_FIELDS = {
+      visible: true,
+      locked: false,
+      layer: "default",
+      schemaVersion: 1
+    };
+    SHAPE_BASE_FIELDS = {
+      visible: true,
+      locked: false,
+      layer: "default",
+      schemaVersion: 1
+    };
+  }
+});
+var freeModule;
+var init_free = __esm({
+  "src/stamps/geometry-2d/dsl/kinds/points/free.ts"() {
+    init_names();
+    init_types4();
+    init_shared();
+    freeModule = defineModule({
+      kind: "free",
+      role: "point",
+      category: "points",
+      prefix: "p",
+      schema: zod.z.object({
+        name: NameZ,
+        kind: zod.z.literal("free"),
+        x: zod.z.number().finite(),
+        y: zod.z.number().finite()
+      }),
+      collectRefs: () => [],
+      emit: (e, ctx) => [{
+        role: "primary",
+        object: emitPointObject(ctx.resolveId(e.name), e.name, { kind: "free", x: e.x, y: e.y })
+      }]
+    });
+  }
+});
+var midpointModule;
+var init_midpoint = __esm({
+  "src/stamps/geometry-2d/dsl/kinds/points/midpoint.ts"() {
+    init_names();
+    init_types4();
+    init_shared();
+    midpointModule = defineModule({
+      kind: "midpoint",
+      role: "point",
+      category: "points",
+      prefix: "p",
+      schema: zod.z.object({
+        name: NameZ,
+        kind: zod.z.literal("midpoint"),
+        p1: NameZ,
+        p2: NameZ
+      }),
+      collectRefs: (e) => [e.p1, e.p2],
+      emit: (e, ctx) => [{
+        role: "primary",
+        object: emitPointObject(
+          ctx.resolveId(e.name),
+          e.name,
+          { kind: "midpoint", p1: ctx.resolveId(e.p1), p2: ctx.resolveId(e.p2) }
+        )
+      }]
+    });
+  }
+});
+var onSegmentModule;
+var init_onSegment = __esm({
+  "src/stamps/geometry-2d/dsl/kinds/points/onSegment.ts"() {
+    init_names();
+    init_types4();
+    init_shared();
+    onSegmentModule = defineModule({
+      kind: "onSegment",
+      role: "point",
+      category: "points",
+      prefix: "p",
+      schema: zod.z.object({
+        name: NameZ,
+        kind: zod.z.literal("onSegment"),
+        segmentId: NameZ,
+        t: zod.z.number().min(0).max(1)
+      }),
+      collectRefs: (e) => [e.segmentId],
+      emit: (e, ctx) => [{
+        role: "primary",
+        object: emitPointObject(
+          ctx.resolveId(e.name),
+          e.name,
+          { kind: "onSegment", segmentId: ctx.resolveId(e.segmentId), t: e.t }
+        )
+      }]
+    });
+  }
+});
+var onLineModule;
+var init_onLine = __esm({
+  "src/stamps/geometry-2d/dsl/kinds/points/onLine.ts"() {
+    init_names();
+    init_types4();
+    init_shared();
+    onLineModule = defineModule({
+      kind: "onLine",
+      role: "point",
+      category: "points",
+      prefix: "p",
+      schema: zod.z.object({
+        name: NameZ,
+        kind: zod.z.literal("onLine"),
+        lineId: NameZ,
+        t: zod.z.number().finite()
+      }),
+      collectRefs: (e) => [e.lineId],
+      emit: (e, ctx) => [{
+        role: "primary",
+        object: emitPointObject(
+          ctx.resolveId(e.name),
+          e.name,
+          { kind: "onLine", lineId: ctx.resolveId(e.lineId), t: e.t }
+        )
+      }]
+    });
+  }
+});
+var onCircleModule;
+var init_onCircle = __esm({
+  "src/stamps/geometry-2d/dsl/kinds/points/onCircle.ts"() {
+    init_names();
+    init_types4();
+    init_shared();
+    onCircleModule = defineModule({
+      kind: "onCircle",
+      role: "point",
+      category: "points",
+      prefix: "p",
+      schema: zod.z.object({
+        name: NameZ,
+        kind: zod.z.literal("onCircle"),
+        circleId: NameZ,
+        theta: zod.z.number().finite()
+      }),
+      collectRefs: (e) => [e.circleId],
+      emit: (e, ctx) => [{
+        role: "primary",
+        object: emitPointObject(
+          ctx.resolveId(e.name),
+          e.name,
+          { kind: "onCircle", circleId: ctx.resolveId(e.circleId), theta: e.theta }
+        )
+      }]
+    });
+  }
+});
+var perpFootModule;
+var init_perpFoot = __esm({
+  "src/stamps/geometry-2d/dsl/kinds/points/perpFoot.ts"() {
+    init_names();
+    init_types4();
+    init_shared();
+    perpFootModule = defineModule({
+      kind: "perpFoot",
+      role: "point",
+      category: "points",
+      prefix: "p",
+      schema: zod.z.object({
+        name: NameZ,
+        kind: zod.z.literal("perpFoot"),
+        from: NameZ,
+        onLine: NameZ
+      }),
+      collectRefs: (e) => [e.from, e.onLine],
+      emit: (e, ctx) => [{
+        role: "primary",
+        object: emitPointObject(
+          ctx.resolveId(e.name),
+          e.name,
+          { kind: "perpFoot", from: ctx.resolveId(e.from), onLine: ctx.resolveId(e.onLine) }
+        )
+      }]
+    });
+  }
+});
+var circumcenterModule;
+var init_circumcenter = __esm({
+  "src/stamps/geometry-2d/dsl/kinds/points/circumcenter.ts"() {
+    init_names();
+    init_types4();
+    init_shared();
+    circumcenterModule = defineModule({
+      kind: "circumcenter",
+      role: "point",
+      category: "points",
+      prefix: "p",
+      schema: zod.z.object({
+        name: NameZ,
+        kind: zod.z.literal("circumcenter"),
+        vertices: zod.z.tuple([NameZ, NameZ, NameZ])
+      }),
+      collectRefs: (e) => [...e.vertices],
+      emit: (e, ctx) => [{
+        role: "primary",
+        object: emitPointObject(
+          ctx.resolveId(e.name),
+          e.name,
+          { kind: "circumcenter", vertices: resolveTriangleVertices(ctx, e.vertices) }
+        )
+      }]
+    });
+  }
+});
+var incenterModule;
+var init_incenter = __esm({
+  "src/stamps/geometry-2d/dsl/kinds/points/incenter.ts"() {
+    init_names();
+    init_types4();
+    init_shared();
+    incenterModule = defineModule({
+      kind: "incenter",
+      role: "point",
+      category: "points",
+      prefix: "p",
+      schema: zod.z.object({
+        name: NameZ,
+        kind: zod.z.literal("incenter"),
+        vertices: zod.z.tuple([NameZ, NameZ, NameZ])
+      }),
+      collectRefs: (e) => [...e.vertices],
+      emit: (e, ctx) => [{
+        role: "primary",
+        object: emitPointObject(
+          ctx.resolveId(e.name),
+          e.name,
+          { kind: "incenter", vertices: resolveTriangleVertices(ctx, e.vertices) }
+        )
+      }]
+    });
+  }
+});
+var centroidModule;
+var init_centroid = __esm({
+  "src/stamps/geometry-2d/dsl/kinds/points/centroid.ts"() {
+    init_names();
+    init_types4();
+    init_shared();
+    centroidModule = defineModule({
+      kind: "centroid",
+      role: "point",
+      category: "points",
+      prefix: "p",
+      schema: zod.z.object({
+        name: NameZ,
+        kind: zod.z.literal("centroid"),
+        vertices: zod.z.tuple([NameZ, NameZ, NameZ])
+      }),
+      collectRefs: (e) => [...e.vertices],
+      emit: (e, ctx) => [{
+        role: "primary",
+        object: emitPointObject(
+          ctx.resolveId(e.name),
+          e.name,
+          { kind: "centroid", vertices: resolveTriangleVertices(ctx, e.vertices) }
+        )
+      }]
+    });
+  }
+});
+var orthocenterModule;
+var init_orthocenter = __esm({
+  "src/stamps/geometry-2d/dsl/kinds/points/orthocenter.ts"() {
+    init_names();
+    init_types4();
+    init_shared();
+    orthocenterModule = defineModule({
+      kind: "orthocenter",
+      role: "point",
+      category: "points",
+      prefix: "p",
+      schema: zod.z.object({
+        name: NameZ,
+        kind: zod.z.literal("orthocenter"),
+        vertices: zod.z.tuple([NameZ, NameZ, NameZ])
+      }),
+      collectRefs: (e) => [...e.vertices],
+      emit: (e, ctx) => [{
+        role: "primary",
+        object: emitPointObject(
+          ctx.resolveId(e.name),
+          e.name,
+          { kind: "orthocenter", vertices: resolveTriangleVertices(ctx, e.vertices) }
+        )
+      }]
+    });
+  }
+});
+var intersectionModule;
+var init_intersection2 = __esm({
+  "src/stamps/geometry-2d/dsl/kinds/points/intersection.ts"() {
+    init_names();
+    init_types4();
+    init_shared();
+    intersectionModule = defineModule({
+      kind: "intersection",
+      role: "point",
+      category: "points",
+      prefix: "i",
+      schema: 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()
+      }),
+      collectRefs: (e) => [e.ref1, e.ref2],
+      emit: (e, ctx) => {
+        const r1IsCircle = ctx.hintOf(e.ref1) === "circle";
+        const r2IsCircle = ctx.hintOf(e.ref2) === "circle";
+        let intersectKind;
+        if (r1IsCircle && r2IsCircle) intersectKind = "circleCircle";
+        else if (r1IsCircle || r2IsCircle) intersectKind = "lineCircle";
+        else intersectKind = "lineLine";
+        const attrs = {
+          kind: intersectKind,
+          ref1: ctx.resolveId(e.ref1),
+          ref2: ctx.resolveId(e.ref2)
+        };
+        if (intersectKind !== "lineLine") {
+          attrs.branch = e.branch ?? 0;
+        }
+        return [{
+          role: "primary",
+          object: {
+            id: ctx.resolveId(e.name),
+            kind: "intersection",
+            label: e.name,
+            ...POINT_BASE_FIELDS,
+            attrs
+          }
+        }];
+      }
+    });
+  }
+});
+var segmentModule;
+var init_segment2 = __esm({
+  "src/stamps/geometry-2d/dsl/kinds/lines/segment.ts"() {
+    init_names();
+    init_types4();
+    init_shared();
+    segmentModule = defineModule({
+      kind: "segment",
+      role: "segment",
+      category: "lines",
+      prefix: "s",
+      schema: zod.z.object({
+        name: NameZ,
+        kind: zod.z.literal("segment"),
+        p1: NameZ,
+        p2: NameZ
+      }),
+      collectRefs: (e) => [e.p1, e.p2],
+      emit: (e, ctx) => [{
+        role: "primary",
+        object: {
+          id: ctx.resolveId(e.name),
+          kind: "segment",
+          label: e.name,
+          ...SHAPE_BASE_FIELDS,
+          attrs: { p1: ctx.resolveId(e.p1), p2: ctx.resolveId(e.p2) }
+        }
+      }]
+    });
+  }
+});
+var lineModule;
+var init_line2 = __esm({
+  "src/stamps/geometry-2d/dsl/kinds/lines/line.ts"() {
+    init_names();
+    init_types4();
+    init_shared();
+    lineModule = defineModule({
+      kind: "line",
+      role: "line",
+      category: "lines",
+      prefix: "l",
+      schema: zod.z.object({
+        name: NameZ,
+        kind: zod.z.literal("line"),
+        p1: NameZ,
+        p2: NameZ
+      }),
+      collectRefs: (e) => [e.p1, e.p2],
+      emit: (e, ctx) => [{
+        role: "primary",
+        object: {
+          id: ctx.resolveId(e.name),
+          kind: "line",
+          label: e.name,
+          ...SHAPE_BASE_FIELDS,
+          attrs: { p1: ctx.resolveId(e.p1), p2: ctx.resolveId(e.p2) }
+        }
+      }]
+    });
+  }
+});
+var rayModule;
+var init_ray2 = __esm({
+  "src/stamps/geometry-2d/dsl/kinds/lines/ray.ts"() {
+    init_names();
+    init_types4();
+    init_shared();
+    rayModule = defineModule({
+      kind: "ray",
+      role: "ray",
+      category: "lines",
+      prefix: "r",
+      schema: zod.z.object({
+        name: NameZ,
+        kind: zod.z.literal("ray"),
+        origin: NameZ,
+        through: NameZ
+      }),
+      collectRefs: (e) => [e.origin, e.through],
+      emit: (e, ctx) => [{
+        role: "primary",
+        object: {
+          id: ctx.resolveId(e.name),
+          kind: "ray",
+          label: e.name,
+          ...SHAPE_BASE_FIELDS,
+          attrs: { origin: ctx.resolveId(e.origin), through: ctx.resolveId(e.through) }
+        }
+      }]
+    });
+  }
+});
+var perpendicularModule;
+var init_perpendicular = __esm({
+  "src/stamps/geometry-2d/dsl/kinds/lines/perpendicular.ts"() {
+    init_names();
+    init_types4();
+    init_shared();
+    perpendicularModule = defineModule({
+      kind: "perpendicular",
+      role: "lineConstruction",
+      category: "lines",
+      prefix: "l",
+      schema: zod.z.object({
+        name: NameZ,
+        kind: zod.z.literal("perpendicular"),
+        throughPoint: NameZ,
+        toLine: NameZ
+      }),
+      collectRefs: (e) => [e.throughPoint, e.toLine],
+      emit: (e, ctx) => [{
+        role: "primary",
+        object: {
+          id: ctx.resolveId(e.name),
+          kind: "line",
+          label: e.name,
+          ...SHAPE_BASE_FIELDS,
+          attrs: {
+            construction: {
+              kind: "perpendicular",
+              throughPoint: ctx.resolveId(e.throughPoint),
+              toLine: ctx.resolveId(e.toLine)
+            }
+          }
+        }
+      }]
+    });
+  }
+});
+var parallelModule;
+var init_parallel = __esm({
+  "src/stamps/geometry-2d/dsl/kinds/lines/parallel.ts"() {
+    init_names();
+    init_types4();
+    init_shared();
+    parallelModule = defineModule({
+      kind: "parallel",
+      role: "lineConstruction",
+      category: "lines",
+      prefix: "l",
+      schema: zod.z.object({
+        name: NameZ,
+        kind: zod.z.literal("parallel"),
+        throughPoint: NameZ,
+        toLine: NameZ
+      }),
+      collectRefs: (e) => [e.throughPoint, e.toLine],
+      emit: (e, ctx) => [{
+        role: "primary",
+        object: {
+          id: ctx.resolveId(e.name),
+          kind: "line",
+          label: e.name,
+          ...SHAPE_BASE_FIELDS,
+          attrs: {
+            construction: {
+              kind: "parallel",
+              throughPoint: ctx.resolveId(e.throughPoint),
+              toLine: ctx.resolveId(e.toLine)
+            }
+          }
+        }
+      }]
+    });
+  }
+});
+var perpBisectorModule;
+var init_perpBisector = __esm({
+  "src/stamps/geometry-2d/dsl/kinds/lines/perpBisector.ts"() {
+    init_names();
+    init_types4();
+    init_shared();
+    perpBisectorModule = defineModule({
+      kind: "perpBisector",
+      role: "lineConstruction",
+      category: "lines",
+      prefix: "l",
+      schema: zod.z.object({
+        name: NameZ,
+        kind: zod.z.literal("perpBisector"),
+        p1: NameZ,
+        p2: NameZ
+      }),
+      collectRefs: (e) => [e.p1, e.p2],
+      emit: (e, ctx) => [{
+        role: "primary",
+        object: {
+          id: ctx.resolveId(e.name),
+          kind: "line",
+          label: e.name,
+          ...SHAPE_BASE_FIELDS,
+          attrs: {
+            construction: {
+              kind: "perpBisector",
+              p1: ctx.resolveId(e.p1),
+              p2: ctx.resolveId(e.p2)
+            }
+          }
+        }
+      }]
+    });
+  }
+});
+var angleBisectorModule;
+var init_angleBisector = __esm({
+  "src/stamps/geometry-2d/dsl/kinds/lines/angleBisector.ts"() {
+    init_names();
+    init_types4();
+    init_shared();
+    angleBisectorModule = defineModule({
+      kind: "angleBisector",
+      role: "lineConstruction",
+      category: "lines",
+      prefix: "l",
+      schema: zod.z.object({
+        name: NameZ,
+        kind: zod.z.literal("angleBisector"),
+        p1: NameZ,
+        vertex: NameZ,
+        p2: NameZ
+      }),
+      collectRefs: (e) => [e.p1, e.vertex, e.p2],
+      emit: (e, ctx) => [{
+        role: "primary",
+        object: {
+          id: ctx.resolveId(e.name),
+          kind: "line",
+          label: e.name,
+          ...SHAPE_BASE_FIELDS,
+          attrs: {
+            construction: {
+              kind: "angleBisector",
+              p1: ctx.resolveId(e.p1),
+              vertex: ctx.resolveId(e.vertex),
+              p2: ctx.resolveId(e.p2)
+            }
+          }
+        }
+      }]
+    });
+  }
+});
+var tangentModule;
+var init_tangent = __esm({
+  "src/stamps/geometry-2d/dsl/kinds/lines/tangent.ts"() {
+    init_names();
+    init_types4();
+    init_shared();
+    tangentModule = defineModule({
+      kind: "tangent",
+      role: "lineConstruction",
+      category: "lines",
+      prefix: "l",
+      schema: 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()
+      }),
+      collectRefs: (e) => [e.throughPoint, e.toCircle],
+      emit: (e, ctx) => {
+        const construction = {
+          kind: "tangent",
+          throughPoint: ctx.resolveId(e.throughPoint),
+          toCircle: ctx.resolveId(e.toCircle)
+        };
+        if (e.branch !== void 0) construction.branch = e.branch;
+        return [{
+          role: "primary",
+          object: {
+            id: ctx.resolveId(e.name),
+            kind: "line",
+            label: e.name,
+            ...SHAPE_BASE_FIELDS,
+            attrs: { construction }
+          }
+        }];
+      }
+    });
+  }
+});
+var polygonModule;
+var init_polygon3 = __esm({
+  "src/stamps/geometry-2d/dsl/kinds/polygons/polygon.ts"() {
+    init_names();
+    init_types4();
+    init_shared();
+    polygonModule = defineModule({
+      kind: "polygon",
+      role: "polygon",
+      category: "polygons",
+      prefix: "poly",
+      schema: zod.z.object({
+        name: NameZ,
+        kind: zod.z.literal("polygon"),
+        vertices: zod.z.array(NameZ).min(3)
+      }),
+      collectRefs: (e) => [...e.vertices],
+      emit: (e, ctx) => [{
+        role: "primary",
+        object: {
+          id: ctx.resolveId(e.name),
+          kind: "polygon",
+          label: e.name,
+          ...SHAPE_BASE_FIELDS,
+          attrs: { vertices: e.vertices.map((v) => ctx.resolveId(v)) }
+        }
+      }]
+    });
+  }
+});
+var circleCPModule;
+var init_circleCP = __esm({
+  "src/stamps/geometry-2d/dsl/kinds/circles/circleCP.ts"() {
+    init_names();
+    init_types4();
+    init_shared();
+    circleCPModule = defineModule({
+      kind: "circleCP",
+      role: "circle",
+      category: "circles",
+      prefix: "c",
+      schema: zod.z.object({
+        name: NameZ,
+        kind: zod.z.literal("circleCP"),
+        center: NameZ,
+        surfacePoint: NameZ
+      }),
+      collectRefs: (e) => [e.center, e.surfacePoint],
+      emit: (e, ctx) => [{
+        role: "primary",
+        object: {
+          id: ctx.resolveId(e.name),
+          kind: "circle",
+          label: e.name,
+          ...SHAPE_BASE_FIELDS,
+          attrs: { center: ctx.resolveId(e.center), surfacePoint: ctx.resolveId(e.surfacePoint) }
+        }
+      }]
+    });
+  }
+});
+var circle3Module;
+var init_circle3 = __esm({
+  "src/stamps/geometry-2d/dsl/kinds/circles/circle3.ts"() {
+    init_names();
+    init_types4();
+    init_shared();
+    circle3Module = defineModule({
+      kind: "circle3",
+      role: "circle",
+      category: "circles",
+      prefix: "c",
+      schema: zod.z.object({
+        name: NameZ,
+        kind: zod.z.literal("circle3"),
+        p1: NameZ,
+        p2: NameZ,
+        p3: NameZ
+      }),
+      collectRefs: (e) => [e.p1, e.p2, e.p3],
+      emit: (e, ctx) => [{
+        role: "primary",
+        object: {
+          id: ctx.resolveId(e.name),
+          kind: "circle",
+          label: e.name,
+          ...SHAPE_BASE_FIELDS,
+          attrs: {
+            construction: {
+              kind: "circumscribed",
+              p1: ctx.resolveId(e.p1),
+              p2: ctx.resolveId(e.p2),
+              p3: ctx.resolveId(e.p3)
+            }
+          }
+        }
+      }]
+    });
+  }
+});
+var ALL_MODULES, POINT_KINDS;
+var init_registry2 = __esm({
+  "src/stamps/geometry-2d/dsl/registry.ts"() {
+    init_free();
+    init_midpoint();
+    init_onSegment();
+    init_onLine();
+    init_onCircle();
+    init_perpFoot();
+    init_circumcenter();
+    init_incenter();
+    init_centroid();
+    init_orthocenter();
+    init_intersection2();
+    init_segment2();
+    init_line2();
+    init_ray2();
+    init_perpendicular();
+    init_parallel();
+    init_perpBisector();
+    init_angleBisector();
+    init_tangent();
+    init_polygon3();
+    init_circleCP();
+    init_circle3();
+    ALL_MODULES = [
+      freeModule,
+      midpointModule,
+      onSegmentModule,
+      onLineModule,
+      onCircleModule,
+      perpFootModule,
+      circumcenterModule,
+      incenterModule,
+      centroidModule,
+      orthocenterModule,
+      intersectionModule,
+      segmentModule,
+      lineModule,
+      rayModule,
+      perpendicularModule,
+      parallelModule,
+      perpBisectorModule,
+      angleBisectorModule,
+      tangentModule,
+      polygonModule,
+      circleCPModule,
+      circle3Module
+    ];
+    new Map(ALL_MODULES.map((m) => [m.kind, m]));
+    POINT_KINDS = new Set(
+      ALL_MODULES.filter((m) => m.role === "point").map((m) => m.kind)
+    );
+    new Set(
+      ALL_MODULES.filter(
+        (m) => m.role === "segment" || m.role === "line" || m.role === "ray" || m.role === "lineConstruction"
+      ).map((m) => m.kind)
+    );
+    new Set(
+      ALL_MODULES.filter((m) => m.role === "circle").map((m) => m.kind)
+    );
+    zod.z.discriminatedUnion(
+      "kind",
+      ALL_MODULES.map((m) => m.schema)
+    );
+  }
+});
+
+// src/stamps/geometry-2d/dsl/serialize.ts
+function isValidName(s) {
+  return NAME_REGEX.test(s);
+}
+function labelOf2(id, state) {
+  const obj = state.objects[id];
+  return obj ? obj.label : null;
+}
+function resolveRefs(ids, state) {
+  const out = [];
+  for (const id of ids) {
+    const lab = labelOf2(id, state);
+    if (lab == null || !isValidName(lab)) return null;
+    out.push(lab);
+  }
+  return out;
+}
+function fail(reason, detail) {
+  return { ok: false, reason, detail };
+}
+function serializePoint(obj, state) {
+  const c = obj.attrs?.constraint;
+  if (!c) return fail("unsupported-constraint", "missing");
+  switch (c.kind) {
+    case "free":
+      return { ok: true, entity: { name: obj.label, kind: "free", x: c.x, y: c.y } };
+    case "midpoint": {
+      const refs = resolveRefs([c.p1, c.p2], state);
+      if (!refs) return fail("unresolved-ref", `${c.p1},${c.p2}`);
+      return { ok: true, entity: { name: obj.label, kind: "midpoint", p1: refs[0], p2: refs[1] } };
+    }
+    case "onSegment": {
+      const refs = resolveRefs([c.segmentId], state);
+      if (!refs) return fail("unresolved-ref", c.segmentId);
+      return { ok: true, entity: { name: obj.label, kind: "onSegment", segmentId: refs[0], t: c.t } };
+    }
+    case "onLine": {
+      const refs = resolveRefs([c.lineId], state);
+      if (!refs) return fail("unresolved-ref", c.lineId);
+      return { ok: true, entity: { name: obj.label, kind: "onLine", lineId: refs[0], t: c.t } };
+    }
+    case "onCircle": {
+      const refs = resolveRefs([c.circleId], state);
+      if (!refs) return fail("unresolved-ref", c.circleId);
+      return { ok: true, entity: { name: obj.label, kind: "onCircle", circleId: refs[0], theta: c.theta } };
+    }
+    case "perpFoot": {
+      const refs = resolveRefs([c.from, c.onLine], state);
+      if (!refs) return fail("unresolved-ref", `${c.from},${c.onLine}`);
+      return { ok: true, entity: { name: obj.label, kind: "perpFoot", from: refs[0], onLine: refs[1] } };
+    }
+    case "circumcenter":
+    case "incenter":
+    case "centroid":
+    case "orthocenter": {
+      const refs = resolveRefs(c.vertices, state);
+      if (!refs || refs.length !== 3) return fail("unresolved-ref", c.vertices.join(","));
+      return {
+        ok: true,
+        entity: {
+          name: obj.label,
+          kind: c.kind,
+          vertices: [refs[0], refs[1], refs[2]]
+        }
+      };
+    }
+    // Out of DSL v1:
+    case "onAxis":
+    case "onPolygon":
+    case "transformed":
+      return fail("unsupported-constraint", c.kind);
+    default: {
+      return fail("unsupported-constraint");
+    }
+  }
+}
+function serializeIntersection(obj, state) {
+  const a = obj.attrs;
+  const refs = resolveRefs([a.ref1, a.ref2], state);
+  if (!refs) return fail("unresolved-ref", `${a.ref1},${a.ref2}`);
+  if (a.kind === "lineLine") {
+    return { ok: true, entity: { name: obj.label, kind: "intersection", ref1: refs[0], ref2: refs[1] } };
+  }
+  return {
+    ok: true,
+    entity: {
+      name: obj.label,
+      kind: "intersection",
+      ref1: refs[0],
+      ref2: refs[1],
+      branch: a.branch
+    }
+  };
+}
+function serializeSegment(obj, state) {
+  const refs = resolveRefs([obj.attrs.p1, obj.attrs.p2], state);
+  if (!refs) return fail("unresolved-ref", `${obj.attrs.p1},${obj.attrs.p2}`);
+  return { ok: true, entity: { name: obj.label, kind: "segment", p1: refs[0], p2: refs[1] } };
+}
+function serializeRay(obj, state) {
+  const refs = resolveRefs([obj.attrs.origin, obj.attrs.through], state);
+  if (!refs) return fail("unresolved-ref", `${obj.attrs.origin},${obj.attrs.through}`);
+  return { ok: true, entity: { name: obj.label, kind: "ray", origin: refs[0], through: refs[1] } };
+}
+function serializeLine(obj, state) {
+  const a = obj.attrs;
+  const c = a.construction;
+  if (!c) {
+    if (!a.p1 || !a.p2) return fail("unsupported-construction", "missing p1/p2");
+    const refs = resolveRefs([a.p1, a.p2], state);
+    if (!refs) return fail("unresolved-ref", `${a.p1},${a.p2}`);
+    return { ok: true, entity: { name: obj.label, kind: "line", p1: refs[0], p2: refs[1] } };
+  }
+  switch (c.kind) {
+    case "perpendicular":
+    case "parallel": {
+      const refs = resolveRefs([c.throughPoint, c.toLine], state);
+      if (!refs) return fail("unresolved-ref", `${c.throughPoint},${c.toLine}`);
+      return {
+        ok: true,
+        entity: { name: obj.label, kind: c.kind, throughPoint: refs[0], toLine: refs[1] }
+      };
+    }
+    case "perpBisector": {
+      const refs = resolveRefs([c.p1, c.p2], state);
+      if (!refs) return fail("unresolved-ref", `${c.p1},${c.p2}`);
+      return { ok: true, entity: { name: obj.label, kind: "perpBisector", p1: refs[0], p2: refs[1] } };
+    }
+    case "angleBisector": {
+      const refs = resolveRefs([c.p1, c.vertex, c.p2], state);
+      if (!refs) return fail("unresolved-ref", `${c.p1},${c.vertex},${c.p2}`);
+      return {
+        ok: true,
+        entity: {
+          name: obj.label,
+          kind: "angleBisector",
+          p1: refs[0],
+          vertex: refs[1],
+          p2: refs[2]
+        }
+      };
+    }
+    case "tangent": {
+      const refs = resolveRefs([c.throughPoint, c.toCircle], state);
+      if (!refs) return fail("unresolved-ref", `${c.throughPoint},${c.toCircle}`);
+      const entity = c.branch !== void 0 ? {
+        name: obj.label,
+        kind: "tangent",
+        throughPoint: refs[0],
+        toCircle: refs[1],
+        branch: c.branch
+      } : { name: obj.label, kind: "tangent", throughPoint: refs[0], toCircle: refs[1] };
+      return { ok: true, entity };
+    }
+    case "angleBisectorLines":
+      return fail("unsupported-construction", "angleBisectorLines");
+    default: {
+      return fail("unsupported-construction");
+    }
+  }
+}
+function serializePolygon(obj, state) {
+  const a = obj.attrs;
+  if (a.construction) return fail("unsupported-construction", a.construction.kind);
+  if (!Array.isArray(a.vertices) || a.vertices.length < 3) {
+    return fail("unsupported-construction", "missing vertices");
+  }
+  const refs = resolveRefs(a.vertices, state);
+  if (!refs) return fail("unresolved-ref", a.vertices.join(","));
+  return { ok: true, entity: { name: obj.label, kind: "polygon", vertices: refs } };
+}
+function serializeCircle(obj, state) {
+  const a = obj.attrs;
+  const c = a.construction;
+  if (!c) {
+    if (!a.center || !a.surfacePoint) {
+      return fail("unsupported-construction", "missing center/surfacePoint");
+    }
+    const refs = resolveRefs([a.center, a.surfacePoint], state);
+    if (!refs) return fail("unresolved-ref", `${a.center},${a.surfacePoint}`);
+    return {
+      ok: true,
+      entity: { name: obj.label, kind: "circleCP", center: refs[0], surfacePoint: refs[1] }
+    };
+  }
+  if (c.kind === "circumscribed") {
+    const refs = resolveRefs([c.p1, c.p2, c.p3], state);
+    if (!refs) return fail("unresolved-ref", `${c.p1},${c.p2},${c.p3}`);
+    return {
+      ok: true,
+      entity: { name: obj.label, kind: "circle3", p1: refs[0], p2: refs[1], p3: refs[2] }
+    };
+  }
+  return fail("unsupported-construction");
+}
+function serializeObject(obj, state) {
+  if (!isValidName(obj.label)) {
+    return fail("invalid-label", obj.label);
+  }
+  switch (obj.kind) {
+    case "point":
+      return serializePoint(obj, state);
+    case "segment":
+      return serializeSegment(obj, state);
+    case "ray":
+      return serializeRay(obj, state);
+    case "line":
+      return serializeLine(obj, state);
+    case "polygon":
+      return serializePolygon(obj, state);
+    case "circle":
+      return serializeCircle(obj, state);
+    case "intersection":
+      return serializeIntersection(obj, state);
+    default:
+      return fail("unsupported-kind", obj.kind);
+  }
+}
+function serializeState(state) {
+  const points = [];
+  const shapes = [];
+  const unsupported = [];
+  for (const id of state.order) {
+    const obj = state.objects[id];
+    if (!obj) continue;
+    const r = serializeObject(obj, state);
+    if (!r.ok) {
+      unsupported.push({
+        id: obj.id,
+        label: obj.label,
+        kind: obj.kind,
+        reason: r.reason,
+        detail: r.detail
+      });
+      continue;
+    }
+    if (POINT_KINDS.has(r.entity.kind)) {
+      points.push(r.entity);
+    } else {
+      shapes.push(r.entity);
+    }
+  }
+  return {
+    dsl: { version: 1, points, shapes },
+    unsupported
+  };
+}
+var NAME_REGEX;
+var init_serialize2 = __esm({
+  "src/stamps/geometry-2d/dsl/serialize.ts"() {
+    init_registry2();
+    NAME_REGEX = /^[A-Za-z][A-Za-z0-9_'₀-₉]{0,11}$/;
+  }
+});
+function useAiFigure(generator, options = {}) {
+  const { currentState } = options;
   const [prompt, setPrompt] = React18.useState("");
   const [isLoading, setIsLoading] = React18.useState(false);
   const [error, setError] = React18.useState(null);
+  const [tokens, setTokens] = React18.useState(0);
   const abortRef = React18.useRef(null);
   const requestIdRef = React18.useRef(0);
+  const { dsl: currentDsl, unsupported, entityCount, hasContent } = React18.useMemo(() => {
+    if (!currentState || currentState.order.length === 0) {
+      return {
+        dsl: null,
+        unsupported: [],
+        entityCount: { points: 0, shapes: 0 },
+        hasContent: false
+      };
+    }
+    const { dsl, unsupported: unsupported2 } = serializeState(currentState);
+    return {
+      dsl,
+      unsupported: unsupported2,
+      entityCount: { points: dsl.points.length, shapes: dsl.shapes.length },
+      hasContent: true
+    };
+  }, [currentState]);
+  const hasUnsupported = unsupported.length > 0;
+  const initialMode = hasContent && !hasUnsupported ? "refine" : "build";
+  const [mode, setModeInternal] = React18.useState(initialMode);
+  React18.useEffect(() => {
+    if (!hasContent && mode === "refine") setModeInternal("build");
+    if (hasUnsupported && mode === "refine") setModeInternal("build");
+  }, [hasContent, hasUnsupported, mode]);
+  const setMode = React18.useCallback((next) => {
+    setModeInternal(next);
+  }, []);
   React18.useEffect(() => () => abortRef.current?.abort(), []);
   const submit = React18.useCallback(async () => {
     const problem = prompt.trim();
@@ -7233,8 +8344,15 @@ function useAiFigure(generator) {
     abortRef.current = controller;
     setIsLoading(true);
     setError(null);
+    setTokens(0);
     try {
-      const generated = await generator(problem, { signal: controller.signal });
+      const generated = await generator(problem, {
+        signal: controller.signal,
+        onProgress: (info) => {
+          if (requestId === requestIdRef.current) setTokens(info.tokens);
+        },
+        ...mode === "refine" && currentDsl ? { currentDsl } : {}
+      });
       if (controller.signal.aborted || requestId !== requestIdRef.current) return null;
       if (!generated.ok) {
         setError(generated.message);
@@ -7246,7 +8364,9 @@ function useAiFigure(generator) {
         return null;
       }
       if (requestId === requestIdRef.current) {
-        setError(caught instanceof Error && caught.message ? caught.message : "Kh\xF4ng th\u1EC3 d\u1EF1ng h\xECnh b\u1EB1ng AI.");
+        setError(
+          caught instanceof Error && caught.message ? caught.message : "Kh\xF4ng th\u1EC3 d\u1EF1ng h\xECnh b\u1EB1ng AI."
+        );
       }
       return null;
     } finally {
@@ -7255,27 +8375,75 @@ function useAiFigure(generator) {
         setIsLoading(false);
       }
     }
-  }, [generator, prompt]);
-  return { prompt, setPrompt, isLoading, error, submit };
+  }, [generator, prompt, mode, currentDsl]);
+  const cancel = React18.useCallback(() => {
+    abortRef.current?.abort();
+  }, []);
+  return {
+    prompt,
+    setPrompt,
+    isLoading,
+    error,
+    submit,
+    cancel,
+    tokens,
+    mode,
+    setMode,
+    entityCount,
+    hasUnsupported
+  };
 }
 var init_useAiFigure = __esm({
   "src/stamps/geometry-2d/editor/useAiFigure.ts"() {
     "use client";
+    init_serialize2();
   }
 });
-function AiFigurePrompt({ generator, onGenerated }) {
+function AiFigurePrompt({ generator, onGenerated, currentState }) {
   const {
     prompt,
     setPrompt,
     isLoading,
     error,
-    submit
-  } = useAiFigure(generator);
-  const handleSubmit = React18.useCallback(async (event) => {
-    event.preventDefault();
-    const generated = await submit();
-    if (generated) onGenerated(generated);
-  }, [onGenerated, submit]);
+    submit,
+    cancel,
+    tokens,
+    mode,
+    setMode,
+    entityCount,
+    hasUnsupported
+  } = useAiFigure(generator, { currentState });
+  const [elapsed, setElapsed] = React18.useState(0);
+  React18.useEffect(() => {
+    if (!isLoading) {
+      setElapsed(0);
+      return;
+    }
+    setElapsed(0);
+    const id = setInterval(() => setElapsed((s) => s + 1), 1e3);
+    return () => clearInterval(id);
+  }, [isLoading]);
+  const handleSubmit = React18.useCallback(
+    async (event) => {
+      event.preventDefault();
+      const generated = await submit();
+      if (generated) onGenerated(generated);
+    },
+    [onGenerated, submit]
+  );
+  const handleSwitchToBuild = React18.useCallback(() => {
+    if (currentState && currentState.order.length > 0) {
+      const ok = window.confirm(
+        "D\u1EF1ng m\u1EDBi s\u1EBD thay to\xE0n b\u1ED9 h\xECnh hi\u1EC7n t\u1EA1i b\u1EB1ng h\xECnh m\u1EDBi t\u1EEB AI. Ti\u1EBFp t\u1EE5c?"
+      );
+      if (!ok) return;
+    }
+    setMode("build");
+  }, [currentState, setMode]);
+  const primaryLabel = isLoading ? tokens > 0 ? `\u0110ang d\u1EF1ng ${tokens}tok / ${elapsed}s \u2014 Hu\u1EF7` : `\u0110ang d\u1EF1ng... ${elapsed}s \u2014 Hu\u1EF7` : "D\u1EF1ng b\u1EB1ng AI";
+  const hasContent = currentState != null && currentState.order.length > 0;
+  const examples = mode === "refine" ? REFINE_EXAMPLES : BUILD_EXAMPLES;
+  const refineChipLabel = entityCount.points + entityCount.shapes > 0 ? `Th\xEAm v\xE0o \xB7 ${entityCount.points}\u0111, ${entityCount.shapes}\u0111o\u1EA1n` : "Th\xEAm v\xE0o";
   return /* @__PURE__ */ jsxRuntime.jsxs(
     "form",
     {
@@ -7285,7 +8453,47 @@ function AiFigurePrompt({ generator, onGenerated }) {
       },
       className: "border-b border-slate-200 bg-slate-50 px-3 py-2",
       children: [
-        /* @__PURE__ */ jsxRuntime.jsx("label", { htmlFor: "geometry-ai-prompt", className: "mb-1 block text-xs font-medium text-slate-600", children: "D\u1EF1ng h\xECnh b\u1EB1ng AI" }),
+        /* @__PURE__ */ jsxRuntime.jsx(
+          "label",
+          {
+            htmlFor: "geometry-ai-prompt",
+            className: "mb-1 block text-xs font-medium text-slate-600",
+            children: "D\u1EF1ng h\xECnh b\u1EB1ng AI"
+          }
+        ),
+        hasContent && /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "mb-2 flex items-center gap-2", children: [
+          /* @__PURE__ */ jsxRuntime.jsx(
+            "button",
+            {
+              type: "button",
+              "data-testid": "geometry-ai-mode-refine",
+              onClick: () => setMode("refine"),
+              disabled: isLoading || hasUnsupported,
+              className: `rounded-full border px-2 py-0.5 text-[11px] transition ${mode === "refine" ? "border-emerald-600 bg-emerald-100 text-emerald-800" : "border-slate-300 bg-white text-slate-600 hover:border-emerald-400"} ${hasUnsupported ? "cursor-not-allowed opacity-50" : ""}`,
+              title: hasUnsupported ? "H\xECnh hi\u1EC7n t\u1EA1i c\xF3 \u0111\u1ED1i t\u01B0\u1EE3ng ngo\xE0i DSL \u2014 ch\u1EC9 d\u1EF1ng m\u1EDBi \u0111\u01B0\u1EE3c" : refineChipLabel,
+              children: refineChipLabel
+            }
+          ),
+          /* @__PURE__ */ jsxRuntime.jsx(
+            "button",
+            {
+              type: "button",
+              "data-testid": "geometry-ai-mode-build",
+              onClick: handleSwitchToBuild,
+              disabled: isLoading,
+              className: `rounded-full border px-2 py-0.5 text-[11px] transition ${mode === "build" ? "border-emerald-600 bg-emerald-100 text-emerald-800" : "border-slate-300 bg-white text-slate-600 hover:border-emerald-400"}`,
+              children: "D\u1EF1ng m\u1EDBi"
+            }
+          ),
+          hasUnsupported && /* @__PURE__ */ jsxRuntime.jsx(
+            "span",
+            {
+              className: "text-[10px] text-amber-700",
+              "data-testid": "geometry-ai-unsupported-warning",
+              children: "H\xECnh c\xF3 \u0111\u1ED1i t\u01B0\u1EE3ng ngo\xE0i DSL"
+            }
+          )
+        ] }),
         /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex items-start gap-2", children: [
           /* @__PURE__ */ jsxRuntime.jsx(
             "textarea",
@@ -7296,29 +8504,63 @@ function AiFigurePrompt({ generator, onGenerated }) {
               onChange: (event) => setPrompt(event.target.value),
               disabled: isLoading,
               rows: 2,
-              placeholder: "V\xED d\u1EE5: Cho tam gi\xE1c ABC, d\u1EF1ng \u0111\u01B0\u1EDDng cao AH.",
+              placeholder: mode === "refine" ? "V\xED d\u1EE5: th\xEAm trung \u0111i\u1EC3m M c\u1EE7a BC" : "V\xED d\u1EE5: Cho tam gi\xE1c ABC, d\u1EF1ng \u0111\u01B0\u1EDDng cao AH.",
               className: "min-h-12 flex-1 resize-none rounded border border-slate-300 bg-white px-2 py-1.5 text-xs text-slate-800 outline-none focus:border-emerald-500 disabled:opacity-60"
             }
           ),
-          /* @__PURE__ */ jsxRuntime.jsx(
+          isLoading ? /* @__PURE__ */ jsxRuntime.jsx(
+            "button",
+            {
+              type: "button",
+              onClick: cancel,
+              className: "rounded bg-amber-600 px-3 py-2 text-xs font-medium text-white transition hover:bg-amber-700",
+              children: primaryLabel
+            }
+          ) : /* @__PURE__ */ jsxRuntime.jsx(
             "button",
             {
               type: "submit",
-              disabled: isLoading || !prompt.trim(),
+              disabled: !prompt.trim(),
               className: "rounded bg-emerald-600 px-3 py-2 text-xs font-medium text-white transition hover:bg-emerald-700 disabled:opacity-50",
-              children: isLoading ? "\u0110ang d\u1EF1ng..." : "D\u1EF1ng b\u1EB1ng AI"
+              children: primaryLabel
             }
           )
         ] }),
-        error && /* @__PURE__ */ jsxRuntime.jsx("p", { role: "alert", className: "mt-1 text-xs text-red-600", children: error })
+        error && /* @__PURE__ */ jsxRuntime.jsx("p", { role: "alert", className: "mt-1 text-xs text-red-600", children: error }),
+        !isLoading && !prompt.trim() && !error && /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "mt-1.5 flex flex-wrap items-center gap-1", children: [
+          /* @__PURE__ */ jsxRuntime.jsx("span", { className: "text-[10px] text-slate-500", children: "G\u1EE3i \xFD:" }),
+          examples.map((ex) => /* @__PURE__ */ jsxRuntime.jsx(
+            "button",
+            {
+              type: "button",
+              onClick: () => setPrompt(ex),
+              className: "rounded-full border border-slate-300 bg-white px-2 py-0.5 text-[10px] text-slate-600 transition hover:border-emerald-400 hover:bg-emerald-50 hover:text-emerald-700",
+              children: ex
+            },
+            ex
+          ))
+        ] })
       ]
     }
   );
 }
+var BUILD_EXAMPLES, REFINE_EXAMPLES;
 var init_AiFigurePrompt = __esm({
   "src/stamps/geometry-2d/editor/AiFigurePrompt.tsx"() {
     "use client";
     init_useAiFigure();
+    BUILD_EXAMPLES = [
+      "Tam gi\xE1c ABC, d\u1EF1ng trung \u0111i\u1EC3m M c\u1EE7a BC",
+      "Tam gi\xE1c ABC vu\xF4ng t\u1EA1i A, AH l\xE0 \u0111\u01B0\u1EDDng cao xu\u1ED1ng BC",
+      "H\xECnh thoi ABCD, hai \u0111\u01B0\u1EDDng ch\xE9o c\u1EAFt nhau t\u1EA1i O",
+      "T\u1EEB \u0111i\u1EC3m M ngo\xE0i \u0111\u01B0\u1EDDng tr\xF2n (O), k\u1EBB hai ti\u1EBFp tuy\u1EBFn"
+    ];
+    REFINE_EXAMPLES = [
+      "Th\xEAm trung \u0111i\u1EC3m M c\u1EE7a BC",
+      "D\u1EF1ng \u0111\u01B0\u1EDDng cao AH xu\u1ED1ng BC",
+      "V\u1EBD \u0111\u01B0\u1EDDng tr\xF2n ngo\u1EA1i ti\u1EBFp",
+      "Th\xEAm ti\u1EBFp tuy\u1EBFn t\u1EA1i A"
+    ];
   }
 });
 var GeometryEditorPanelInner, GeometryEditorPanel;
@@ -7369,6 +8611,11 @@ var init_EditorPanel = __esm({
           onSelectionChangeRef.current = onSelectionChange;
         }, [onSelectionChange]);
         useEditorState({ store, onHistoryChange });
+        const currentSceneState = React18.useSyncExternalStore(
+          (cb) => store.subscribe(cb),
+          () => store.getState(),
+          () => store.getState()
+        );
         React18.useEffect(() => {
           const sync = () => setHasContent(Object.keys(store.getState().objects).length > 0);
           sync();
@@ -7562,7 +8809,7 @@ var init_EditorPanel = __esm({
                   /* @__PURE__ */ jsxRuntime.jsx("line", { x1: "18", y1: "6", x2: "6", y2: "18" })
                 ] }) })
               ] }),
-              generateGeometryFigure && /* @__PURE__ */ jsxRuntime.jsx(AiFigurePrompt, { generator: generateGeometryFigure, onGenerated: loadAiFigure }),
+              generateGeometryFigure && /* @__PURE__ */ jsxRuntime.jsx(AiFigurePrompt, { generator: generateGeometryFigure, onGenerated: loadAiFigure, currentState: currentSceneState }),
               /* @__PURE__ */ jsxRuntime.jsx("div", { className: "flex min-h-0 flex-1", children: /* @__PURE__ */ jsxRuntime.jsx("div", { className: "flex-1", children: /* @__PURE__ */ jsxRuntime.jsx(
                 MiniBoard2D,
                 {
@@ -7853,6 +9100,116 @@ var init_useStampStore = __esm({
   }
 });
 
+// src/stamps/geometry-2d/dsl/describeDsl.ts
+function describeEntity(e) {
+  switch (e.kind) {
+    case "free":
+      return `${e.name} = (${e.x}, ${e.y})`;
+    case "midpoint":
+      return `${e.name} = trung \u0111i\u1EC3m ${e.p1}${e.p2}`;
+    case "onSegment":
+      return `${e.name} \u2208 \u0111o\u1EA1n ${e.segmentId} (t = ${e.t})`;
+    case "onLine":
+      return `${e.name} \u2208 \u0111\u01B0\u1EDDng ${e.lineId} (t = ${e.t})`;
+    case "onCircle":
+      return `${e.name} \u2208 \u0111\u01B0\u1EDDng tr\xF2n ${e.circleId} (\u03B8 = ${e.theta})`;
+    case "perpFoot":
+      return `${e.name} = ch\xE2n vu\xF4ng g\xF3c t\u1EEB ${e.from} xu\u1ED1ng ${e.onLine}`;
+    case "circumcenter":
+      return `${e.name} = t\xE2m ngo\u1EA1i ti\u1EBFp ${e.vertices.join("")}`;
+    case "incenter":
+      return `${e.name} = t\xE2m n\u1ED9i ti\u1EBFp ${e.vertices.join("")}`;
+    case "centroid":
+      return `${e.name} = tr\u1ECDng t\xE2m ${e.vertices.join("")}`;
+    case "orthocenter":
+      return `${e.name} = tr\u1EF1c t\xE2m ${e.vertices.join("")}`;
+    case "intersection": {
+      const branch = "branch" in e && e.branch !== void 0 ? ` (nh\xE1nh ${e.branch})` : "";
+      return `${e.name} = ${e.ref1} \u2229 ${e.ref2}${branch}`;
+    }
+    case "segment":
+      return `${e.name} = \u0111o\u1EA1n ${e.p1}${e.p2}`;
+    case "line":
+      return `${e.name} = \u0111\u01B0\u1EDDng th\u1EB3ng ${e.p1}${e.p2}`;
+    case "ray":
+      return `${e.name} = tia ${e.origin}${e.through}`;
+    case "polygon":
+      return `${e.name} = \u0111a gi\xE1c ${e.vertices.join("")}`;
+    case "perpendicular":
+      return `${e.name} \u27C2 ${e.toLine} qua ${e.throughPoint}`;
+    case "parallel":
+      return `${e.name} \u2225 ${e.toLine} qua ${e.throughPoint}`;
+    case "perpBisector":
+      return `${e.name} = trung tr\u1EF1c ${e.p1}${e.p2}`;
+    case "angleBisector":
+      return `${e.name} = ph\xE2n gi\xE1c \u2220${e.p1}${e.vertex}${e.p2}`;
+    case "tangent": {
+      const branch = "branch" in e && e.branch !== void 0 ? ` (nh\xE1nh ${e.branch})` : "";
+      return `${e.name} = ti\u1EBFp tuy\u1EBFn ${e.toCircle} qua ${e.throughPoint}${branch}`;
+    }
+    case "circleCP":
+      return `${e.name} = (${e.center}; ${e.center}${e.surfacePoint})`;
+    case "circle3":
+      return `${e.name} = \u0111\u01B0\u1EDDng tr\xF2n qua ${e.p1}${e.p2}${e.p3}`;
+    default: {
+      return "";
+    }
+  }
+}
+function describeDsl(obj, state) {
+  const r = serializeObject(obj, state);
+  if (r.ok) return describeEntity(r.entity);
+  let base;
+  try {
+    base = getKind(obj.kind).describe(obj, state);
+  } catch {
+    base = `${obj.kind} ${obj.label}`;
+  }
+  return `${base} (kh\xF4ng h\u1ED7 tr\u1EE3 DSL)`;
+}
+var init_describeDsl = __esm({
+  "src/stamps/geometry-2d/dsl/describeDsl.ts"() {
+    init_registry();
+    init_serialize2();
+  }
+});
+function makeDslRenderRow(store) {
+  return function renderDslRow(obj, defaults) {
+    const state = store.getState();
+    const noop = () => {
+    };
+    return /* @__PURE__ */ jsxRuntime.jsx(
+      ObjectRow,
+      {
+        obj,
+        state,
+        selected: defaults.selected,
+        onSelect: defaults.onClick,
+        onToggleVisible: (id) => {
+          const o = state.objects[id];
+          if (!o) return;
+          store.dispatch({ type: "UPDATE", payload: { id, patch: { visible: !o.visible } } });
+        },
+        onToggleLocked: (id) => {
+          const o = state.objects[id];
+          if (!o) return;
+          store.dispatch({ type: "UPDATE", payload: { id, patch: { locked: !o.locked } } });
+        },
+        onRename: noop,
+        onChangeColor: noop,
+        onDelete: (id) => store.dispatch({ type: "DELETE", payload: { id } }),
+        describe: describeDsl
+      }
+    );
+  };
+}
+var init_dslRenderRow = __esm({
+  "src/stamps/geometry-2d/editor/dslRenderRow.tsx"() {
+    init_ObjectRow();
+    init_describeDsl();
+  }
+});
+
 // src/stamps/geometry-2d/host.tsx
 var host_exports = {};
 __export(host_exports, {
@@ -7877,6 +9234,7 @@ var init_host = __esm({
     init_scene();
     init_useIsMobile();
     init_useStampStore();
+    init_dslRenderRow();
     GeometryStampHost = React18.forwardRef(
       function GeometryStampHost2({ api, editingElement, onClose, isDark, generateGeometryFigure }, ref) {
         const panelRef = React18.useRef(null);
@@ -7903,6 +9261,7 @@ var init_host = __esm({
           onSelect: (key) => setSelectedTool(key),
           enabled: !isMobile
         });
+        const renderRow = React18.useMemo(() => makeDslRenderRow(sceneStore), [sceneStore]);
         const handleInsert = React18.useCallback(
           async (jsonState, svgString) => {
             if (!api) return;
@@ -7964,7 +9323,8 @@ var init_host = __esm({
                 onObjectSelect: (id) => {
                   setSelectedObjectId(id ?? void 0);
                   panelRef.current?.selectObject(id);
-                }
+                },
+                renderRow
               },
               isMobile,
               drawerOpen,
@@ -8052,7 +9412,7 @@ function isLatexCustomData(data) {
   const d = data;
   return d.kind === "latex" && d.version === 1 && typeof d.src === "string";
 }
-var init_types4 = __esm({
+var init_types5 = __esm({
   "src/stamps/latex/types.ts"() {
   }
 });
@@ -8461,7 +9821,7 @@ var init_host2 = __esm({
     init_EditorPopover();
     init_insertImage();
     init_useIsMobile();
-    init_types4();
+    init_types5();
     LatexStampHost = React18.forwardRef(
       function LatexStampHost2({ api, editingElement, onClose }, ref) {
         const editorRef = React18.useRef(null);
@@ -8557,7 +9917,7 @@ function serializeBoard3D(state, view) {
 function deserializeBoard3D(raw) {
   return deserializeScene("3d", raw);
 }
-var init_serialize2 = __esm({
+var init_serialize3 = __esm({
   "src/stamps/geometry-3d/serialize.ts"() {
     init_serializeScene();
   }
@@ -8565,7 +9925,7 @@ var init_serialize2 = __esm({
 
 // src/core/scene/render/types.ts
 var DEFAULT_THEME_3D;
-var init_types5 = __esm({
+var init_types6 = __esm({
   "src/core/scene/render/types.ts"() {
     DEFAULT_THEME_3D = {
       point: { size: 4, color: "#1e40af" },
@@ -8580,7 +9940,7 @@ var JxgRenderer3D;
 var init_JxgRenderer3D = __esm({
   "src/core/scene/render/JxgRenderer3D.ts"() {
     init_registry();
-    init_types5();
+    init_types6();
     JxgRenderer3D = class {
       constructor(store, view, options = {}) {
         this.elements = /* @__PURE__ */ new Map();
@@ -8943,7 +10303,7 @@ var OUTPUT_WIDTH, OUTPUT_HEIGHT, BBOX_2D;
 var init_render3 = __esm({
   "src/stamps/geometry-3d/render.ts"() {
     "use client";
-    init_serialize2();
+    init_serialize3();
     init_scene();
     init_types();
     init_JxgRenderer3D();
@@ -9074,7 +10434,7 @@ function buildVector(args, store) {
   if (!from || !to || from === to) return null;
   return addDerived(store, "vector3d", "v", { from, to });
 }
-var init_segment2 = __esm({
+var init_segment3 = __esm({
   "src/stamps/geometry-3d/editor/tools/handlers/segment.ts"() {
     init_scene();
     init_ensurePoint();
@@ -9101,7 +10461,7 @@ function buildPolygon(args, store) {
   store.dispatch({ type: "ADD", payload: { obj } });
   return id;
 }
-var init_polygon3 = __esm({
+var init_polygon4 = __esm({
   "src/stamps/geometry-3d/editor/tools/handlers/polygon.ts"() {
     init_scene();
     init_ensurePoint();
@@ -9214,8 +10574,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 z = center[2] + radius * Math.cos(c.phi);
-      return [x, y, z];
+      const z25 = center[2] + radius * Math.cos(c.phi);
+      return [x, y, z25];
     }
   }
 }
@@ -9618,8 +10978,8 @@ var stubBuild, ALL_SURFACES, OBJECT_ONLY, NO_SURFACE, TOOLS2;
 var init_spec = __esm({
   "src/stamps/geometry-3d/editor/tools/spec.ts"() {
     init_point3();
-    init_segment2();
-    init_polygon3();
+    init_segment3();
+    init_polygon4();
     init_plane();
     init_pyramid();
     init_prism();
@@ -10911,7 +12271,7 @@ var init_EditorPanel2 = __esm({
     init_StatusHint();
     init_usePointDrag();
     init_editorHelpers();
-    init_serialize2();
+    init_serialize3();
     init_render3();
     init_constants();
     init_Toast2();
@@ -11403,7 +12763,7 @@ var init_host3 = __esm({
     init_insertImage();
     init_useIsMobile();
     init_useStampStore();
-    init_serialize2();
+    init_serialize3();
     Geom3DIconHeader = /* @__PURE__ */ jsxRuntime.jsxs("svg", { width: "18", height: "18", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "1.6", strokeLinecap: "round", strokeLinejoin: "round", "aria-hidden": "true", children: [
       /* @__PURE__ */ jsxRuntime.jsx("path", { d: "M4 9 L4 20 L14 20 L14 9 Z" }),
       /* @__PURE__ */ jsxRuntime.jsx("path", { d: "M4 9 L10 4 L20 4 L14 9 Z" }),
@@ -11620,7 +12980,7 @@ function isGraph2DCustomData(data) {
   const d = data;
   return d.kind === "graph2d" && d.version === 2 && typeof d.jsonState === "string";
 }
-var init_types6 = __esm({
+var init_types7 = __esm({
   "src/stamps/graph-2d/types.ts"() {
   }
 });
@@ -11651,7 +13011,7 @@ function parseSceneState(json) {
   if (!v.objects || typeof v.objects !== "object") return null;
   return raw;
 }
-var init_serialize3 = __esm({
+var init_serialize4 = __esm({
   "src/stamps/graph-2d/serialize.ts"() {
     init_serializeScene();
   }
@@ -12186,7 +13546,7 @@ var init_EditorPanel3 = __esm({
           void (async () => {
             try {
               const { renderGraphSvgFromState: renderGraphSvgFromState2 } = await Promise.resolve().then(() => (init_render4(), render_exports));
-              const { stringifySceneState: stringifySceneState2 } = await Promise.resolve().then(() => (init_serialize3(), serialize_exports));
+              const { stringifySceneState: stringifySceneState2 } = await Promise.resolve().then(() => (init_serialize4(), serialize_exports));
               const jsonState = stringifySceneState2(state);
               const svgString = await renderGraphSvgFromState2(state, !!isDark);
               onInsert(jsonState, svgString);
@@ -12662,8 +14022,8 @@ var init_host4 = __esm({
     init_insertImage();
     init_useIsMobile();
     init_useStampStore();
-    init_types6();
-    init_serialize3();
+    init_types7();
+    init_serialize4();
     init_tools2();
     init_FunctionRow();
     init_ParameterRow();
@@ -12911,7 +14271,7 @@ var geometryStamp = {
 
 // src/stamps/latex/index.tsx
 init_render2();
-init_types4();
+init_types5();
 var LatexStampHost3 = React18.lazy(
   () => Promise.resolve().then(() => (init_host2(), host_exports2)).then((m) => ({ default: m.LatexStampHost }))
 );
@@ -12944,7 +14304,7 @@ var latexStamp = {
 };
 
 // src/stamps/geometry-3d/index.tsx
-init_serialize2();
+init_serialize3();
 init_render3();
 init_svgToStampFile();
 var Geometry3DStampHost3 = React18.lazy(
@@ -13001,8 +14361,8 @@ var geometry3dStamp = {
 
 // src/stamps/graph-2d/index.tsx
 init_render4();
-init_types6();
-init_serialize3();
+init_types7();
+init_serialize4();
 init_svgToStampFile();
 var Graph2DStampHost3 = React18.lazy(
   () => Promise.resolve().then(() => (init_host4(), host_exports4)).then((m) => ({ default: m.Graph2DStampHost }))
@@ -14641,7 +16001,7 @@ async function readFiles(storageKey) {
   try {
     return await withStore(
       "readonly",
-      (store, setResult, fail) => {
+      (store, setResult, fail2) => {
         const out = {};
         const req = store.index("storageKey").openCursor(IDBKeyRange.only(validKey));
         req.onsuccess = () => {
@@ -14658,7 +16018,7 @@ async function readFiles(storageKey) {
           };
           cursor.continue();
         };
-        req.onerror = () => fail(req.error);
+        req.onerror = () => fail2(req.error);
       },
       {}
     );
@@ -14674,7 +16034,7 @@ async function writeFiles(storageKey, files) {
   try {
     await withStore(
       "readwrite",
-      (store, setResult, fail) => {
+      (store, setResult, fail2) => {
         let pending = entries.length;
         const finishOne = () => {
           pending -= 1;
@@ -14699,9 +16059,9 @@ async function writeFiles(storageKey, files) {
             };
             const putReq = store.put(rec);
             putReq.onsuccess = finishOne;
-            putReq.onerror = () => fail(putReq.error);
+            putReq.onerror = () => fail2(putReq.error);
           };
-          getReq.onerror = () => fail(getReq.error);
+          getReq.onerror = () => fail2(getReq.error);
         }
         ;
       },
@@ -14716,7 +16076,7 @@ async function pruneFiles(storageKey, keepIds) {
   try {
     await withStore(
       "readwrite",
-      (store, setResult, fail) => {
+      (store, setResult, fail2) => {
         const req = store.index("storageKey").openCursor(IDBKeyRange.only(validKey));
         req.onsuccess = () => {
           const cursor = req.result;
@@ -14731,9 +16091,9 @@ async function pruneFiles(storageKey, keepIds) {
           }
           const deleteReq = cursor.delete();
           deleteReq.onsuccess = () => cursor.continue();
-          deleteReq.onerror = () => fail(deleteReq.error);
+          deleteReq.onerror = () => fail2(deleteReq.error);
         };
-        req.onerror = () => fail(req.error);
+        req.onerror = () => fail2(req.error);
       },
       void 0
     );