@xom11/whiteboard 0.24.2 → 0.25.0

package/dist/ai.js

@@ -1,8 +1,8 @@
 'use strict';
 
 var zod = require('zod');
-var Anthropic = require('@anthropic-ai/sdk');
 var zodToJsonSchema = require('zod-to-json-schema');
+var Anthropic = require('@anthropic-ai/sdk');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
@@ -10,143 +10,628 @@ var Anthropic__default = /*#__PURE__*/_interopDefault(Anthropic);
 
 // src/stamps/geometry-2d/dsl/schema.ts
 var NameZ = zod.z.string().regex(/^[A-Za-z][A-Za-z0-9_'₀-₉]{0,11}$/);
-var DslPoint = zod.z.discriminatedUnion("kind", [
-  zod.z.object({
+
+// src/stamps/geometry-2d/dsl/kinds/_types.ts
+function defineModule(m) {
+  return m;
+}
+
+// src/stamps/geometry-2d/dsl/kinds/_shared.ts
+var POINT_BASE_FIELDS = {
+  visible: true,
+  locked: false,
+  layer: "default",
+  schemaVersion: 1
+};
+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 SHAPE_BASE_FIELDS = {
+  visible: true,
+  locked: false,
+  layer: "default",
+  schemaVersion: 1
+};
+
+// src/stamps/geometry-2d/dsl/kinds/points/free.ts
+var 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()
   }),
-  zod.z.object({
+  collectRefs: () => [],
+  emit: (e, ctx) => [{
+    role: "primary",
+    object: emitPointObject(ctx.resolveId(e.name), e.name, { kind: "free", x: e.x, y: e.y })
+  }]
+});
+var 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
   }),
-  zod.z.object({
+  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 = 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)
   }),
-  zod.z.object({
+  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 = 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()
   }),
-  zod.z.object({
+  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 = 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()
   }),
-  zod.z.object({
+  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 = defineModule({
+  kind: "perpFoot",
+  role: "point",
+  category: "points",
+  prefix: "p",
+  schema: zod.z.object({
     name: NameZ,
     kind: zod.z.literal("perpFoot"),
     from: NameZ,
     onLine: NameZ
   }),
-  zod.z.object({
+  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 = 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])
   }),
-  zod.z.object({
+  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 = 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])
   }),
-  zod.z.object({
+  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 = 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])
   }),
-  zod.z.object({
+  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 = 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])
   }),
-  zod.z.object({
+  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 = 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()
-  })
-]);
-var DslShape = zod.z.discriminatedUnion("kind", [
-  zod.z.object({
+  }),
+  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 = defineModule({
+  kind: "segment",
+  role: "segment",
+  category: "lines",
+  prefix: "s",
+  schema: zod.z.object({
     name: NameZ,
     kind: zod.z.literal("segment"),
     p1: NameZ,
     p2: NameZ
   }),
-  zod.z.object({
+  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 = defineModule({
+  kind: "line",
+  role: "line",
+  category: "lines",
+  prefix: "l",
+  schema: zod.z.object({
     name: NameZ,
     kind: zod.z.literal("line"),
     p1: NameZ,
     p2: NameZ
   }),
-  zod.z.object({
+  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 = defineModule({
+  kind: "ray",
+  role: "ray",
+  category: "lines",
+  prefix: "r",
+  schema: zod.z.object({
     name: NameZ,
     kind: zod.z.literal("ray"),
     origin: NameZ,
     through: NameZ
   }),
-  zod.z.object({
-    name: NameZ,
-    kind: zod.z.literal("polygon"),
-    vertices: zod.z.array(NameZ).min(3)
-  }),
-  // Line constructions
-  zod.z.object({
+  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 = defineModule({
+  kind: "perpendicular",
+  role: "lineConstruction",
+  category: "lines",
+  prefix: "l",
+  schema: zod.z.object({
     name: NameZ,
     kind: zod.z.literal("perpendicular"),
     throughPoint: NameZ,
     toLine: NameZ
   }),
-  zod.z.object({
+  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 = defineModule({
+  kind: "parallel",
+  role: "lineConstruction",
+  category: "lines",
+  prefix: "l",
+  schema: zod.z.object({
     name: NameZ,
     kind: zod.z.literal("parallel"),
     throughPoint: NameZ,
     toLine: NameZ
   }),
-  zod.z.object({
+  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 = defineModule({
+  kind: "perpBisector",
+  role: "lineConstruction",
+  category: "lines",
+  prefix: "l",
+  schema: zod.z.object({
     name: NameZ,
     kind: zod.z.literal("perpBisector"),
     p1: NameZ,
     p2: NameZ
   }),
-  zod.z.object({
+  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 = 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
   }),
-  zod.z.object({
+  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 = 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()
   }),
-  // Circle constructions
-  zod.z.object({
+  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 = 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 = defineModule({
+  kind: "circleCP",
+  role: "circle",
+  category: "circles",
+  prefix: "c",
+  schema: zod.z.object({
     name: NameZ,
     kind: zod.z.literal("circleCP"),
     center: NameZ,
     surfacePoint: NameZ
   }),
-  zod.z.object({
+  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 = 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)
+        }
+      }
+    }
+  }]
+});
+
+// src/stamps/geometry-2d/dsl/registry.ts
+var ALL_MODULES = [
+  freeModule,
+  midpointModule,
+  onSegmentModule,
+  onLineModule,
+  onCircleModule,
+  perpFootModule,
+  circumcenterModule,
+  incenterModule,
+  centroidModule,
+  orthocenterModule,
+  intersectionModule,
+  segmentModule,
+  lineModule,
+  rayModule,
+  perpendicularModule,
+  parallelModule,
+  perpBisectorModule,
+  angleBisectorModule,
+  tangentModule,
+  polygonModule,
+  circleCPModule,
+  circle3Module
+];
+var KIND_REGISTRY = new Map(ALL_MODULES.map((m) => [m.kind, m]));
+var POINT_KINDS = new Set(
+  ALL_MODULES.filter((m) => m.role === "point").map((m) => m.kind)
+);
+var LINE_LIKE_SHAPE_KINDS = new Set(
+  ALL_MODULES.filter(
+    (m) => m.role === "segment" || m.role === "line" || m.role === "ray" || m.role === "lineConstruction"
+  ).map((m) => m.kind)
+);
+var CIRCLE_KINDS = 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/schema.ts
+function asTuple(arr) {
+  if (arr.length < 2) throw new Error("schema: need at least 2 variants for discriminatedUnion");
+  return arr;
+}
+var pointSchemas = Array.from(KIND_REGISTRY.values()).filter((m) => POINT_KINDS.has(m.kind)).map((m) => m.schema);
+var shapeSchemas = Array.from(KIND_REGISTRY.values()).filter((m) => !POINT_KINDS.has(m.kind)).map((m) => m.schema);
+var DslPoint = zod.z.discriminatedUnion("kind", asTuple(pointSchemas));
+var DslShape = zod.z.discriminatedUnion("kind", asTuple(shapeSchemas));
 var DslInput = zod.z.object({
   version: zod.z.literal(1),
   points: zod.z.array(DslPoint),
@@ -215,17 +700,6 @@ function buildSymbols(dsl) {
 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);
@@ -340,50 +814,9 @@ function validateRefs(dsl, symbols) {
   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 [];
+  const mod = KIND_REGISTRY.get(entity.kind);
+  if (!mod) throw new Error(`collectRefs: no registry entry for kind "${entity.kind}"`);
+  return mod.collectRefs(entity);
 }
 
 // src/stamps/geometry-2d/dsl/transpile/cycles.ts
@@ -441,229 +874,45 @@ function detectCycles(symbols) {
 }
 
 // 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 counters = /* @__PURE__ */ new Map();
   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]}`);
+    const mod = KIND_REGISTRY.get(sym.entity.kind);
+    if (!mod) throw new Error(`assignIds: no registry entry for kind "${sym.entity.kind}"`);
+    const prefix = mod.prefix;
+    counters.set(prefix, (counters.get(prefix) ?? 0) + 1);
+    ids.set(name, `${prefix}${counters.get(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";
+  const mod = KIND_REGISTRY.get(entity.kind);
+  if (!mod) throw new Error(`hintOf: no registry entry for kind "${entity.kind}"`);
+  return mod.role === "polygon" ? "point" : mod.role;
+}
+function buildEmitContext(ids, kindHints) {
+  const auxCounters = /* @__PURE__ */ new Map();
+  return {
+    resolveId(name) {
+      const id = ids.get(name);
+      if (!id) throw new Error(`emit: id not assigned for "${name}"`);
+      return id;
+    },
+    hintOf(name) {
+      const hint = kindHints.get(name);
+      if (!hint) throw new Error(`emit: hint not assigned for "${name}"`);
+      return hint;
+    },
+    mintAuxId(parentName, suffix) {
+      const key = `${parentName}.${suffix}`;
+      auxCounters.set(key, (auxCounters.get(key) ?? 0) + 1);
+      const seq = auxCounters.get(key);
+      return `aux_${parentName}_${suffix}${seq}`;
     }
-  }
-  return "point";
+  };
 }
 function transpile(dslRaw) {
   const parsed = DslInput.safeParse(dslRaw);
@@ -686,16 +935,18 @@ function transpile(dslRaw) {
   }
   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 ctx = buildEmitContext(ids, kindHints);
+  const emitEntity = (entity) => {
+    const mod = KIND_REGISTRY.get(entity.kind);
+    if (!mod) throw new Error(`emit: no registry entry for kind "${entity.kind}"`);
+    const emitted = mod.emit(entity, ctx);
+    for (const ent of emitted) {
+      objects[ent.object.id] = ent.object;
+      order.push(ent.object.id);
+    }
+  };
+  for (const p of dsl.points) emitEntity(p);
+  for (const s of dsl.shapes) emitEntity(s);
   const empty = createEmptyState("2d");
   const state = {
     objects,
@@ -705,20 +956,29 @@ function transpile(dslRaw) {
   };
   return { ok: true, state };
 }
-async function callProvider(args) {
-  const client = new Anthropic__default.default({ apiKey: args.apiKey });
-  const resp = await client.messages.create(
-    {
-      model: args.model,
-      max_tokens: args.maxTokens,
-      system: args.system,
-      tools: args.tools,
-      tool_choice: args.toolChoice,
-      messages: args.messages
-    },
-    args.signal ? { signal: args.signal } : void 0
-  );
-  return resp;
+var FigureEnvelopeZ = zod.z.object({
+  decision: zod.z.enum(["build", "refuse"]),
+  // figure: DslInput khi build; bỏ qua khi refuse.
+  figure: DslInput.optional(),
+  // reason: lý do từ chối (Việt) khi refuse; bỏ qua khi build.
+  reason: zod.z.string().optional()
+}).refine(
+  (e) => e.decision === "build" ? e.figure != null : e.reason != null && e.reason.length > 0,
+  {
+    message: "decision=build c\u1EA7n `figure`; decision=refuse c\u1EA7n `reason` kh\xF4ng r\u1ED7ng"
+  }
+);
+function envelopeJsonSchema() {
+  return zodToJsonSchema.zodToJsonSchema(FigureEnvelopeZ, {
+    target: "jsonSchema7",
+    $refStrategy: "none"
+  });
+}
+function envelopeBuildDsl(env) {
+  if (env.decision !== "build" || env.figure == null) {
+    throw new Error("envelopeBuildDsl: envelope kh\xF4ng ph\u1EA3i decision=build ho\u1EB7c thi\u1EBFu figure");
+  }
+  return env.figure;
 }
 
 // src/stamps/geometry-2d/dsl/fixtures/triangle-equilateral.ts
@@ -886,62 +1146,267 @@ var fixture9 = {
   }
 };
 
+// src/stamps/geometry-2d/dsl/fixtures/triangle-angle-bisector.ts
+var fixture10 = {
+  problem: "Tam gi\xE1c ABC, AD l\xE0 ph\xE2n gi\xE1c g\xF3c A (D thu\u1ED9c BC).",
+  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 },
+      // D = giao của đường phân giác góc A với BC. KHÔNG dùng segment AD
+      // vì AD lại tham chiếu D → cycle.
+      { name: "D", kind: "intersection", ref1: "bisA", ref2: "BC" }
+    ],
+    shapes: [
+      { name: "ABC", kind: "polygon", vertices: ["A", "B", "C"] },
+      { name: "BC", kind: "segment", p1: "B", p2: "C" },
+      // Đường phân giác (line construction), chứ không phải segment.
+      { name: "bisA", kind: "angleBisector", p1: "B", vertex: "A", p2: "C" },
+      // Sau khi đã có D, mới dựng được segment AD.
+      { name: "AD", kind: "segment", p1: "A", p2: "D" }
+    ]
+  }
+};
+
+// src/stamps/geometry-2d/dsl/fixtures/triangle-median-altitude.ts
+var fixture11 = {
+  problem: "Tam gi\xE1c ABC, M l\xE0 trung \u0111i\u1EC3m BC v\xE0 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 },
+      // M = trung điểm B và C. KHÔNG dùng perpFoot ở đây — đó là H.
+      { name: "M", kind: "midpoint", p1: "B", p2: "C" },
+      // H = chân đường vuông góc từ A xuống cạnh BC.
+      { 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: "AM", kind: "segment", p1: "A", p2: "M" },
+      { name: "AH", kind: "segment", p1: "A", p2: "H" }
+    ]
+  }
+};
+
+// src/stamps/geometry-2d/dsl/fixtures/trapezoid.ts
+var fixture12 = {
+  problem: "H\xECnh thang ABCD c\xF3 AB song song CD.",
+  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: 3 },
+      { name: "D", kind: "free", x: -1, y: 3 }
+    ],
+    shapes: [
+      { name: "ABCD", kind: "polygon", vertices: ["A", "B", "C", "D"] }
+    ]
+  }
+};
+
+// src/stamps/geometry-2d/dsl/fixtures/rhombus.ts
+var fixture13 = {
+  problem: "H\xECnh thoi 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: 2 },
+      { name: "B", kind: "free", x: 3, y: 0 },
+      { name: "C", kind: "free", x: 0, y: -2 },
+      { name: "D", kind: "free", x: -3, y: 0 },
+      { 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/right-triangle-altitude.ts
+var fixture14 = {
+  problem: "Tam gi\xE1c ABC vu\xF4ng t\u1EA1i A, AH l\xE0 \u0111\u01B0\u1EDDng cao xu\u1ED1ng c\u1EA1nh huy\u1EC1n BC.",
+  dsl: {
+    version: 1,
+    points: [
+      { name: "A", kind: "free", x: 0, y: 0 },
+      { name: "B", kind: "free", x: 0, y: 3 },
+      { name: "C", kind: "free", x: 4, 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/tangent-from-point.ts
+var fixture15 = {
+  problem: "T\u1EEB \u0111i\u1EC3m M ngo\xE0i \u0111\u01B0\u1EDDng tr\xF2n (O), k\u1EBB hai ti\u1EBFp tuy\u1EBFn t\u1EDBi (O).",
+  dsl: {
+    version: 1,
+    points: [
+      { name: "O", kind: "free", x: 0, y: 0 },
+      // P là điểm trên đường tròn dùng để định bán kính.
+      { name: "P", kind: "free", x: 2, y: 0 },
+      { name: "M", kind: "free", x: 5, y: 0 }
+    ],
+    shapes: [
+      { name: "k", kind: "circleCP", center: "O", surfacePoint: "P" },
+      { name: "t1", kind: "tangent", throughPoint: "M", toCircle: "k", branch: 0 },
+      { name: "t2", kind: "tangent", throughPoint: "M", toCircle: "k", branch: 1 }
+    ]
+  }
+};
+
+// src/stamps/geometry-2d/dsl/fixtures/internal-external-bisector.ts
+var fixture16 = {
+  problem: "Tam gi\xE1c ABC, v\u1EBD tia ph\xE2n gi\xE1c trong v\xE0 ph\xE2n gi\xE1c ngo\xE0i t\u1EA1i \u0111\u1EC9nh A.",
+  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 }
+    ],
+    shapes: [
+      { name: "ABC", kind: "polygon", vertices: ["A", "B", "C"] },
+      { name: "bisIn", kind: "angleBisector", p1: "B", vertex: "A", p2: "C" },
+      // Phân giác ngoài = vuông góc với phân giác trong tại đỉnh A.
+      { name: "bisExt", kind: "perpendicular", throughPoint: "A", toLine: "bisIn" }
+    ]
+  }
+};
+
 // src/stamps/geometry-2d/ai/prompt.ts
-var FIXTURES = [fixture, fixture2, fixture3, fixture4, fixture5, fixture6, fixture7, fixture8, fixture9];
+var FIXTURES = [
+  fixture,
+  fixture2,
+  fixture3,
+  fixture4,
+  fixture5,
+  fixture6,
+  fixture7,
+  fixture10,
+  fixture11,
+  fixture14,
+  fixture16,
+  fixture15,
+  fixture8,
+  fixture13,
+  fixture12,
+  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)}
-\`\`\``
+**Output:**
+${JSON.stringify({ decision: "build", figure: 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.
+\u0110\u1ECDc \u0111\u1EC1 b\xE0i ti\u1EBFng Vi\u1EC7t \u2192 emit JSON envelope m\xF4 t\u1EA3 h\xECnh. H\u1EC7 th\u1ED1ng s\u1EBD render h\xECnh t\u1EEB DSL.
+
+## Output format (CH\u1EC8 JSON, kh\xF4ng markdown, kh\xF4ng text kh\xE1c)
+{ "decision": "build", "figure": { /* DSL */ } }
+ho\u1EB7c
+{ "decision": "refuse", "reason": "l\xFD do ti\u1EBFng Vi\u1EC7t" }
 
 ## 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.
+1. V\u1EBD \u0111\u01B0\u1EE3c \u2192 decision="build" + figure \u0111\u1EA7y \u0111\u1EE7 DSL.
+2. \u0110\u1EC1 ngo\xE0i ph\u1EA1m vi \u2192 decision="refuse" + reason ti\u1EBFng Vi\u1EC7t c\u1EE5 th\u1EC3. Bao g\u1ED3m:
+   - T\xEDnh to\xE1n \u0111\u1EA1i s\u1ED1 / l\u01B0\u1EE3ng gi\xE1c / gi\u1EA3i ph\u01B0\u01A1ng tr\xECnh (kh\xF4ng y\xEAu c\u1EA7u v\u1EBD).
+   - H\xECnh 3D, l\u1EADp th\u1EC3, kh\xF4ng gian.
+   - Ph\xE9p bi\u1EBFn h\xECnh affine / t\u1ECBnh ti\u1EBFn / v\u1ECB t\u1EF1 / quay (l\u1EDBp 11+).
+   - \u0110\u1EC1 m\xF4 t\u1EA3 kh\xF4ng \u0111\u1EE7 th\xF4ng tin \u0111\u1EC3 d\u1EF1ng (vd "\u0111i\u1EC3m M b\u1EA5t k\u1EF3 tr\xEAn m\u1EB7t ph\u1EB3ng").
+3. **\u01AFu ti\xEAn derived points** (midpoint, perpFoot, intersection, circumcenter, \u2026) thay v\xEC t\u1EF1 compute to\u1EA1 \u0111\u1ED9. Ch\u1EC9 d\xF9ng \`free\` cho \u0111i\u1EC3m g\u1ED1c t\u1EF1 do (A, B, C c\u1EE7a tam gi\xE1c \u2014 \u0111\u1EB7t coord -5..5).
+4. **\u0110\u01B0\u1EDDng cao**: d\xF9ng \`perpFoot\` cho ch\xE2n, KH\xD4NG free anchor.
+5. **Ph\xE2n gi\xE1c g\xF3c A \u0111\u1EBFn BC**: emit line \`angleBisector\` (B, A, C) + segment BC + point D = \`intersection\` c\u1EE7a 2 line \u0111\xF3. KH\xD4NG emit \`onSegment\` v\u1EDBi segmentId ch\xEDnh l\xE0 segment \u0111ang d\u1EF1ng (cycle).
+6. **\u0110\u01B0\u1EDDng tr\xF2n ngo\u1EA1i ti\u1EBFp**: d\xF9ng \`circle3\` (3 \u0111i\u1EC3m), kh\xF4ng ph\u1EA3i \`polygon\`.
+7. **\u0110\u01B0\u1EDDng tr\xF2n n\u1ED9i ti\u1EBFp / ti\u1EBFp x\xFAc**: t\xE2m b\u1EB1ng \`incenter\`, \u0111i\u1EC3m ti\u1EBFp x\xFAc b\u1EB1ng \`perpFoot\` t\u1EEB t\xE2m xu\u1ED1ng c\u1EA1nh t\u01B0\u01A1ng \u1EE9ng, r\u1ED3i \`circleCP\`.
+8. **\u0110\u01B0\u1EDDng tr\xF2n (O; R) b\xE1n k\xEDnh s\u1ED1**: emit free 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).
+9. **\u0110\u1EC1 gh\xE9p nhi\u1EC1u y\xEAu c\u1EA7u** (vd "trung \u0111i\u1EC3m M v\xE0 \u0111\u01B0\u1EDDng cao AH"): m\u1ED7i y\xEAu c\u1EA7u l\xE0 1 derived point ri\xEAng v\u1EDBi kind \u0111\xFAng. KH\xD4NG \u0111\u1EB7t chung 1 point tho\u1EA3 nhi\u1EC1u r\xE0ng bu\u1ED9c. V\u1EBD th\xEAm segment cho t\u1EEBng y\xEAu c\u1EA7u (AM, AH, ...) khi \u0111\u1EC1 m\xF4 t\u1EA3 "d\u1EF1ng" ho\u1EB7c "v\u1EBD".
+
+## Anti-pattern (B\u1EAET BU\u1ED8C tr\xE1nh)
+- **Cycle / forward-ref**: KH\xD4NG \u0111\u01B0\u1EE3c tham chi\u1EBFu ch\xE9o. N\u1EBFu point D \u2208 segment AD \u2192 cycle (AD c\u1EA7n D, D c\u1EA7n AD). \u0110\xFAng pattern: D = intersection c\u1EE7a line n\xE0o \u0111\xF3 v\u1EDBi BC, sau \u0111\xF3 AD = segment(A, D).
+- **M\u1ECDi name b\u1ECB reference ph\u1EA3i \u0111\u01B0\u1EE3c \u0111\u1ECBnh ngh\u0129a tr\u01B0\u1EDBc** (DSL topological sort: free \u2192 derived \u2192 shape).
+- **\u0110a gi\xE1c polygon KH\xD4NG thay th\u1EBF cho \u0111\u01B0\u1EDDng tr\xF2n**: n\u1EBFu \u0111\u1EC1 n\xF3i "\u0111\u01B0\u1EDDng tr\xF2n qua 3 \u0111i\u1EC3m" m\xE0 b\u1EA1n emit polygon th\xEC sai.
 
 ## 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
+## ${FIXTURES.length} 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").`;
+Tr\u1EA3 v\u1EC1 CH\u1EC8 1 JSON object \u0111\xFAng schema. Kh\xF4ng c\xF3 l\u1EDDi d\u1EABn, kh\xF4ng markdown fence.`;
 }
-var BUILD_FIGURE_TOOL = {
-  name: "build_figure",
-  description: "V\u1EBD h\xECnh h\u1ECDc 2D theo \u0111\u1EC1 b\xE0i. Emit DSL JSON m\xF4 t\u1EA3 c\xE1c \u0111i\u1EC3m v\xE0 h\xECnh.",
-  input_schema: zodToJsonSchema.zodToJsonSchema(DslInput, {
-    target: "jsonSchema7",
-    $refStrategy: "none"
-  })
-};
-var RefuseInputZ = zod.z.object({
-  reason: zod.z.string().min(1).describe("L\xFD do kh\xF4ng v\u1EBD \u0111\u01B0\u1EE3c (ti\u1EBFng Vi\u1EC7t)")
-});
-var REFUSE_TOOL = {
-  name: "refuse",
-  description: "T\u1EEB ch\u1ED1i khi kh\xF4ng v\u1EBD \u0111\u01B0\u1EE3c ho\u1EB7c \u0111\u1EC1 ngo\xE0i ph\u1EA1m vi (3D, l\u01B0\u1EE3ng gi\xE1c, l\u1EDBp 11+).",
-  input_schema: zodToJsonSchema.zodToJsonSchema(RefuseInputZ, { target: "jsonSchema7" })
+var TOOL_NAME = "emit_figure_envelope";
+var AnthropicProvider = class {
+  constructor(opts) {
+    this.opts = opts;
+    this.name = "anthropic";
+    this.defaultModel = "claude-opus-4-7";
+    if (!opts.apiKey) throw new Error("AnthropicProvider: apiKey b\u1EAFt bu\u1ED9c");
+  }
+  async call(req) {
+    const enableCaching = this.opts.enableCaching !== false;
+    const systemBlock = enableCaching ? { type: "text", text: req.systemPrompt, cache_control: { type: "ephemeral" } } : { type: "text", text: req.systemPrompt };
+    const tool = {
+      name: TOOL_NAME,
+      description: 'Emit envelope JSON cho ph\xE9p v\u1EBD h\xECnh ho\u1EB7c t\u1EEB ch\u1ED1i. decision="build" k\xE8m figure (DSL h\xECnh h\u1ECDc); decision="refuse" k\xE8m reason.',
+      input_schema: req.schema
+    };
+    const client = new Anthropic__default.default({ apiKey: this.opts.apiKey });
+    let resp;
+    try {
+      resp = await client.messages.create(
+        {
+          model: req.model,
+          max_tokens: req.maxTokens,
+          system: [systemBlock],
+          tools: [tool],
+          tool_choice: { type: "tool", name: TOOL_NAME },
+          messages: [{ role: "user", content: req.userPrompt }]
+        },
+        req.signal ? { signal: req.signal } : void 0
+      );
+    } catch (e) {
+      const err = e;
+      return {
+        kind: "error",
+        message: err.message ?? "L\u1ED7i g\u1ECDi Anthropic API",
+        ...err.status !== void 0 ? { status: err.status } : {}
+      };
+    }
+    const usage = toUsage(resp.usage);
+    const toolUse = resp.content.find((c) => c.type === "tool_use");
+    if (!toolUse || toolUse.type !== "tool_use") {
+      return {
+        kind: "error",
+        message: "Claude kh\xF4ng g\u1ECDi tool. stop_reason=" + resp.stop_reason
+      };
+    }
+    if (toolUse.name !== TOOL_NAME) {
+      return {
+        kind: "error",
+        message: `Tool kh\xF4ng x\xE1c \u0111\u1ECBnh: "${toolUse.name}"`
+      };
+    }
+    return { kind: "json", data: toolUse.input, usage };
+  }
 };
-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,
@@ -950,87 +1415,742 @@ function toUsage(u) {
     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" };
+
+// src/stamps/geometry-2d/ai/providers/ollama.ts
+var DEFAULT_BASE_URL = "http://localhost:11434";
+var DEFAULT_MODEL = "gemma3:4b";
+var OllamaProvider = class {
+  constructor(opts = {}) {
+    this.name = "ollama";
+    this.baseUrl = (opts.baseUrl ?? DEFAULT_BASE_URL).replace(/\/$/, "");
+    this.defaultModel = opts.defaultModel ?? DEFAULT_MODEL;
+    this.fetchImpl = opts.fetchImpl ?? null;
+  }
+  resolveFetch() {
+    if (this.fetchImpl) return this.fetchImpl;
+    if (typeof fetch === "undefined") {
+      throw new Error(
+        "OllamaProvider: global `fetch` kh\xF4ng kh\u1EA3 d\u1EE5ng. Truy\u1EC1n `fetchImpl` qua constructor ho\u1EB7c ch\u1EA1y \u1EDF Node 18+ / browser."
+      );
+    }
+    return fetch;
+  }
+  async call(req) {
+    const body = {
+      model: req.model,
+      messages: [
+        { role: "system", content: req.systemPrompt },
+        { role: "user", content: req.userPrompt }
+      ],
+      // Ollama v0.5+ structured outputs: model bị constrain emit JSON đúng schema.
+      format: req.schema,
+      stream: false,
+      options: {
+        // num_predict ≈ max_tokens
+        num_predict: req.maxTokens,
+        // temperature thấp cho output deterministic hơn (DSL cần consistent).
+        temperature: 0.2
+      }
+    };
+    let resp;
+    let doFetch;
+    try {
+      doFetch = this.resolveFetch();
+    } catch (e) {
+      const err = e;
+      return { kind: "error", message: err.message ?? "fetch kh\xF4ng kh\u1EA3 d\u1EE5ng" };
+    }
+    try {
+      resp = await doFetch(`${this.baseUrl}/api/chat`, {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify(body),
+        signal: req.signal
+      });
+    } catch (e) {
+      const err = e;
+      return {
+        kind: "error",
+        message: err.message ?? `Kh\xF4ng k\u1EBFt n\u1ED1i \u0111\u01B0\u1EE3c Ollama \u1EDF ${this.baseUrl}`
+      };
+    }
+    if (!resp.ok) {
+      let detail = "";
+      try {
+        detail = await resp.text();
+      } catch {
+      }
+      return {
+        kind: "error",
+        message: `Ollama HTTP ${resp.status}: ${detail || resp.statusText}`,
+        status: resp.status
+      };
+    }
+    let json;
+    try {
+      json = await resp.json();
+    } catch (e) {
+      const err = e;
+      return { kind: "error", message: "Ollama response kh\xF4ng ph\u1EA3i JSON: " + (err.message ?? "?") };
+    }
+    const content = json.message?.content?.trim();
+    if (!content) {
+      return { kind: "error", message: "Ollama tr\u1EA3 message.content r\u1ED7ng" };
+    }
+    let data;
+    try {
+      data = JSON.parse(content);
+    } catch (e) {
+      const err = e;
+      return {
+        kind: "error",
+        message: "Ollama content kh\xF4ng parse \u0111\u01B0\u1EE3c JSON: " + (err.message ?? "?")
+      };
+    }
+    const usage = {
+      inputTokens: json.prompt_eval_count ?? 0,
+      outputTokens: json.eval_count ?? 0,
+      cacheReadTokens: 0,
+      cacheCreationTokens: 0
+    };
+    return { kind: "json", data, usage };
+  }
+};
+
+// src/stamps/geometry-2d/ai/providers/index.ts
+function selectProvider(opts = {}) {
+  if (opts.provider) return opts.provider;
+  if (opts.apiKey) {
+    return new AnthropicProvider({
+      apiKey: opts.apiKey,
+      enableCaching: opts.enableCaching
+    });
+  }
+  const env = opts.env ?? readEnv();
+  const wanted = (env.WHITEBOARD_AI_PROVIDER ?? "ollama").toLowerCase();
+  if (wanted === "anthropic") {
+    const key = env.ANTHROPIC_API_KEY;
+    if (!key) {
+      throw new Error(
+        "selectProvider: WHITEBOARD_AI_PROVIDER=anthropic nh\u01B0ng thi\u1EBFu env ANTHROPIC_API_KEY"
+      );
+    }
+    return new AnthropicProvider({ apiKey: key, enableCaching: opts.enableCaching });
+  }
+  if (wanted === "ollama") {
+    return new OllamaProvider({
+      baseUrl: opts.ollamaBaseUrl ?? env.OLLAMA_BASE_URL,
+      defaultModel: opts.ollamaDefaultModel ?? env.OLLAMA_DEFAULT_MODEL
+    });
+  }
+  throw new Error(`selectProvider: WHITEBOARD_AI_PROVIDER="${wanted}" kh\xF4ng h\u1EE3p l\u1EC7 (anthropic|ollama)`);
+}
+function readEnv() {
+  if (typeof process !== "undefined" && process.env) {
+    return process.env;
   }
+  return {};
+}
+
+// src/stamps/geometry-2d/ai/buildFigure.ts
+var DEFAULT_MAX_TOKENS = 8192;
+async function generateFigure(problem, opts = {}) {
   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;
+  let provider;
   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
-    });
+    provider = selectProvider(opts);
   } catch (e) {
     const err = e;
+    return { ok: false, reason: "api_error", message: err.message ?? "Kh\xF4ng ch\u1ECDn \u0111\u01B0\u1EE3c provider" };
+  }
+  const systemPrompt = buildSystemPrompt();
+  const schema = envelopeJsonSchema();
+  const out = await provider.call({
+    systemPrompt,
+    userPrompt: problem,
+    schema,
+    model: opts.model ?? provider.defaultModel,
+    maxTokens: opts.maxTokens ?? DEFAULT_MAX_TOKENS,
+    signal: opts.signal
+  });
+  if (out.kind === "error") {
     return {
       ok: false,
       reason: "api_error",
-      message: err.message ?? "L\u1ED7i g\u1ECDi Claude API",
-      ...err.status !== void 0 ? { status: err.status } : {}
+      message: out.message,
+      ...out.status !== void 0 ? { status: out.status } : {},
+      provider: provider.name
     };
   }
-  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)";
+  const usage = toUsage2(out.usage);
+  const parsed = FigureEnvelopeZ.safeParse(out.data);
+  if (!parsed.success) {
     return {
       ok: false,
       reason: "parse_error",
-      message: "AI kh\xF4ng g\u1ECDi tool n\xE0o. Response: " + textStr,
-      raw: response.content,
-      usage
+      message: "Envelope kh\xF4ng kh\u1EDBp schema: " + parsed.error.issues.map((i) => i.message).join("; "),
+      raw: out.data,
+      usage,
+      provider: provider.name
     };
   }
-  if (toolUse.name === "refuse") {
-    const input = toolUse.input;
+  const env = parsed.data;
+  if (env.decision === "refuse") {
     return {
       ok: false,
       reason: "refused",
-      message: input.reason ?? "AI t\u1EEB ch\u1ED1i kh\xF4ng n\xEAu l\xFD do",
-      usage
+      message: env.reason ?? "AI t\u1EEB ch\u1ED1i kh\xF4ng n\xEAu l\xFD do",
+      usage,
+      provider: provider.name
+    };
+  }
+  const dsl = envelopeBuildDsl(env);
+  const tResult = transpile(dsl);
+  if (!tResult.ok) {
+    return {
+      ok: false,
+      reason: "transpile_error",
+      message: "DSL t\u1EEB AI kh\xF4ng h\u1EE3p l\u1EC7",
+      errors: tResult.errors,
+      dsl,
+      usage,
+      provider: provider.name
+    };
+  }
+  return {
+    ok: true,
+    state: tResult.state,
+    dsl,
+    usage,
+    provider: provider.name
+  };
+}
+function toUsage2(u) {
+  return {
+    inputTokens: u?.inputTokens ?? 0,
+    outputTokens: u?.outputTokens ?? 0,
+    cacheReadTokens: u?.cacheReadTokens ?? 0,
+    cacheCreationTokens: u?.cacheCreationTokens ?? 0
+  };
+}
+
+// src/stamps/geometry-2d/ai/handleGenerateFigure.ts
+var DEFAULT_MAX_ATTEMPTS = 2;
+async function handleGenerateFigure(input, opts = {}) {
+  const { onResult, maxAttempts: rawMax, ...generateOpts } = opts;
+  const maxAttempts = clampAttempts(rawMax ?? DEFAULT_MAX_ATTEMPTS);
+  let lastResult = null;
+  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+    const result = await generateFigure(input.problem, generateOpts);
+    lastResult = result;
+    if (onResult) {
+      try {
+        onResult(result, attempt);
+      } catch {
+      }
+    }
+    if (result.ok) {
+      return { ok: true, state: result.state };
+    }
+    if (result.reason === "transpile_error" && attempt < maxAttempts) {
+      continue;
+    }
+    break;
+  }
+  return mapErrorToUi(lastResult);
+}
+function clampAttempts(n) {
+  if (!Number.isFinite(n)) return DEFAULT_MAX_ATTEMPTS;
+  return Math.max(1, Math.min(5, Math.floor(n)));
+}
+function mapErrorToUi(result) {
+  if (result.ok) return { ok: true, state: result.state };
+  switch (result.reason) {
+    case "refused":
+      return { ok: false, message: result.message };
+    case "parse_error":
+      return {
+        ok: false,
+        message: "AI tr\u1EA3 v\u1EC1 d\u1EEF li\u1EC7u kh\xF4ng h\u1EE3p l\u1EC7. Vui l\xF2ng th\u1EED l\u1EA1i ho\u1EB7c di\u1EC5n \u0111\u1EA1t l\u1EA1i \u0111\u1EC1 b\xE0i."
+      };
+    case "transpile_error":
+      return {
+        ok: false,
+        message: "AI t\u1EA1o h\xECnh kh\xF4ng h\u1EE3p l\u1EC7 (\u0111\xE3 th\u1EED l\u1EA1i). Vui l\xF2ng t\xE1ch th\xE0nh 1 y\xEAu c\u1EA7u/l\u1EA7n ho\u1EB7c di\u1EC5n \u0111\u1EA1t kh\xE1c."
+      };
+    case "api_error":
+    default:
+      return { ok: false, message: result.message };
+  }
+}
+var FigureRefineEnvelopeZ = zod.z.object({
+  decision: zod.z.enum(["add", "replace", "refuse"]),
+  figure: DslInput.optional(),
+  reason: zod.z.string().optional()
+}).refine(
+  (e) => e.decision === "refuse" ? e.reason != null && e.reason.length > 0 : e.figure != null,
+  {
+    message: "decision=add/replace c\u1EA7n `figure`; decision=refuse c\u1EA7n `reason` kh\xF4ng r\u1ED7ng"
+  }
+);
+function refineEnvelopeJsonSchema() {
+  return zodToJsonSchema.zodToJsonSchema(FigureRefineEnvelopeZ, {
+    target: "jsonSchema7",
+    $refStrategy: "none"
+  });
+}
+
+// src/stamps/geometry-2d/ai/refineFixtures.ts
+var triangleABC = {
+  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 }
+  ],
+  shapes: [{ name: "ABC", kind: "polygon", vertices: ["A", "B", "C"] }]
+};
+var rightTriangleAtA = {
+  version: 1,
+  points: [
+    { name: "A", kind: "free", x: 0, y: 0 },
+    { name: "B", kind: "free", x: 4, y: 0 },
+    { name: "C", kind: "free", x: 0, y: 3 }
+  ],
+  shapes: [{ name: "ABC", kind: "polygon", vertices: ["A", "B", "C"] }]
+};
+var parallelogramABCD = {
+  version: 1,
+  points: [
+    { name: "A", kind: "free", x: -2, y: 0 },
+    { name: "B", kind: "free", x: 3, y: 0 },
+    { name: "C", kind: "free", x: 4, y: 2 },
+    { name: "D", kind: "free", x: -1, y: 2 }
+  ],
+  shapes: [{ name: "ABCD", kind: "polygon", vertices: ["A", "B", "C", "D"] }]
+};
+var circleOnA = {
+  version: 1,
+  points: [
+    { name: "O", kind: "free", x: 0, y: 0 },
+    { name: "A", kind: "free", x: 3, y: 0 }
+  ],
+  shapes: [{ name: "omega", kind: "circleCP", center: "O", surfacePoint: "A" }]
+};
+var REFINE_FIXTURES = [
+  {
+    name: "triangle-add-midpoint",
+    currentDsl: triangleABC,
+    instruction: "Th\xEAm trung \u0111i\u1EC3m M c\u1EE7a BC",
+    expectedEnvelope: {
+      decision: "add",
+      figure: {
+        version: 1,
+        points: [{ name: "M", kind: "midpoint", p1: "B", p2: "C" }],
+        shapes: [{ name: "AM", kind: "segment", p1: "A", p2: "M" }]
+      }
+    }
+  },
+  {
+    name: "triangle-add-altitude",
+    currentDsl: triangleABC,
+    instruction: "D\u1EF1ng \u0111\u01B0\u1EDDng cao AH xu\u1ED1ng BC",
+    expectedEnvelope: {
+      decision: "add",
+      figure: {
+        version: 1,
+        points: [{ name: "H", kind: "perpFoot", from: "A", onLine: "BC_line" }],
+        shapes: [
+          { name: "BC_line", kind: "line", p1: "B", p2: "C" },
+          { name: "AH", kind: "segment", p1: "A", p2: "H" }
+        ]
+      }
+    }
+  },
+  {
+    name: "triangle-add-circumcircle",
+    currentDsl: triangleABC,
+    instruction: "V\u1EBD \u0111\u01B0\u1EDDng tr\xF2n ngo\u1EA1i ti\u1EBFp tam gi\xE1c ABC",
+    expectedEnvelope: {
+      decision: "add",
+      figure: {
+        version: 1,
+        points: [{ name: "O", kind: "circumcenter", vertices: ["A", "B", "C"] }],
+        shapes: [{ name: "omega", kind: "circle3", p1: "A", p2: "B", p3: "C" }]
+      }
+    }
+  },
+  {
+    name: "right-triangle-add-centroid",
+    currentDsl: rightTriangleAtA,
+    instruction: "Th\xEAm tr\u1ECDng t\xE2m G c\u1EE7a tam gi\xE1c",
+    expectedEnvelope: {
+      decision: "add",
+      figure: {
+        version: 1,
+        points: [{ name: "G", kind: "centroid", vertices: ["A", "B", "C"] }],
+        shapes: []
+      }
+    }
+  },
+  {
+    name: "parallelogram-add-diagonals",
+    currentDsl: parallelogramABCD,
+    instruction: "V\u1EBD hai \u0111\u01B0\u1EDDng ch\xE9o AC, BD v\xE0 giao \u0111i\u1EC3m O",
+    expectedEnvelope: {
+      decision: "add",
+      figure: {
+        version: 1,
+        points: [{ name: "O", kind: "intersection", ref1: "AC", ref2: "BD" }],
+        shapes: [
+          { name: "AC", kind: "segment", p1: "A", p2: "C" },
+          { name: "BD", kind: "segment", p1: "B", p2: "D" }
+        ]
+      }
+    }
+  },
+  {
+    name: "circle-add-tangent",
+    currentDsl: circleOnA,
+    instruction: "K\u1EBB ti\u1EBFp tuy\u1EBFn t\u1EA1i A c\u1EE7a \u0111\u01B0\u1EDDng tr\xF2n",
+    expectedEnvelope: {
+      decision: "add",
+      figure: {
+        version: 1,
+        points: [],
+        shapes: [{ name: "t", kind: "tangent", throughPoint: "A", toCircle: "omega" }]
+      }
+    }
+  },
+  {
+    name: "triangle-replace-equilateral",
+    currentDsl: triangleABC,
+    instruction: "B\u1ECF tam gi\xE1c n\xE0y, v\u1EBD tam gi\xE1c \u0111\u1EC1u ABC thay v\xE0o",
+    expectedEnvelope: {
+      decision: "replace",
+      figure: {
+        version: 1,
+        points: [
+          { name: "A", kind: "free", x: 0, y: 2 },
+          { name: "B", kind: "free", x: -1.732, y: -1 },
+          { name: "C", kind: "free", x: 1.732, y: -1 }
+        ],
+        shapes: [{ name: "ABC", kind: "polygon", vertices: ["A", "B", "C"] }]
+      }
+    }
+  },
+  {
+    name: "triangle-replace-rhombus",
+    currentDsl: triangleABC,
+    instruction: "\u0110\u1ED5i sang h\xECnh thoi ABCD",
+    expectedEnvelope: {
+      decision: "replace",
+      figure: {
+        version: 1,
+        points: [
+          { name: "A", kind: "free", x: -2, y: 0 },
+          { name: "B", kind: "free", x: 0, y: 1.5 },
+          { name: "C", kind: "free", x: 2, y: 0 },
+          { name: "D", kind: "free", x: 0, y: -1.5 }
+        ],
+        shapes: [{ name: "ABCD", kind: "polygon", vertices: ["A", "B", "C", "D"] }]
+      }
+    }
+  },
+  {
+    name: "refuse-calculation",
+    currentDsl: triangleABC,
+    instruction: "T\xEDnh di\u1EC7n t\xEDch tam gi\xE1c ABC",
+    expectedEnvelope: {
+      decision: "refuse",
+      reason: "Y\xEAu c\u1EA7u t\xEDnh to\xE1n, kh\xF4ng ph\u1EA3i v\u1EBD h\xECnh."
+    }
+  },
+  {
+    name: "refuse-3d",
+    currentDsl: triangleABC,
+    instruction: "V\u1EBD h\xECnh ch\xF3p SABC v\u1EDBi S n\u1EB1m tr\xEAn tam gi\xE1c",
+    expectedEnvelope: {
+      decision: "refuse",
+      reason: "H\xECnh 3D ngo\xE0i ph\u1EA1m vi geometry-2d."
+    }
+  }
+];
+var REFINE_PROMPT_FIXTURES = REFINE_FIXTURES.slice(0, 8);
+
+// src/stamps/geometry-2d/ai/refinePrompt.ts
+function namesOf(dsl) {
+  return {
+    points: dsl.points.map((p) => p.name),
+    shapes: dsl.shapes.map((s) => s.name)
+  };
+}
+function buildRefineSystemPrompt(currentDsl) {
+  const names = namesOf(currentDsl);
+  const examples = REFINE_PROMPT_FIXTURES.map((f, i) => {
+    const env = f.expectedEnvelope;
+    return `### V\xED d\u1EE5 ${i + 1}
+**H\xECnh hi\u1EC7n t\u1EA1i:**
+${JSON.stringify(f.currentDsl, null, 2)}
+**Y\xEAu c\u1EA7u ch\u1EC9nh s\u1EEDa:** ${f.instruction}
+**Output:**
+${JSON.stringify(env, null, 2)}`;
+  }).join("\n\n");
+  return `B\u1EA1n l\xE0 tr\u1EE3 l\xFD v\u1EBD h\xECnh h\u1ECDc 2D. H\u1ECDc sinh \u0111\xE3 c\xF3 H\xCCNH HI\u1EC6N T\u1EA0I v\xE0 mu\u1ED1n TH\xCAM/S\u1EECA.
+
+## H\xECnh hi\u1EC7n t\u1EA1i (DSL JSON)
+${JSON.stringify(currentDsl, null, 2)}
+
+## T\xEAn \u0111\xE3 d\xF9ng (KH\xD4NG \u0111\u01B0\u1EE3c redefine)
+points: ${names.points.join(", ") || "(ch\u01B0a c\xF3)"}
+shapes: ${names.shapes.join(", ") || "(ch\u01B0a c\xF3)"}
+
+## Nhi\u1EC7m v\u1EE5
+\u0110\u1ECDc Y\xCAU C\u1EA6U CH\u1EC8NH S\u1EECA \u2192 emit JSON envelope \u0111\xFAng 1 trong 3 d\u1EA1ng:
+
+  { "decision": "add",     "figure": <DSL ch\u1EC9 ch\u1EE9a entity M\u1EDAI> }
+  { "decision": "replace", "figure": <DSL ho\xE0n ch\u1EC9nh thay th\u1EBF h\xECnh c\u0169> }
+  { "decision": "refuse",  "reason": "l\xFD do ti\u1EBFng Vi\u1EC7t" }
+
+## Khi n\xE0o d\xF9ng decision n\xE0o?
+- **"add"**: user mu\u1ED1n TH\xCAM primitive v\xE0o h\xECnh hi\u1EC7n t\u1EA1i (vd: "th\xEAm trung \u0111i\u1EC3m M c\u1EE7a BC", "d\u1EF1ng \u0111\u01B0\u1EDDng cao AH").
+  \u2192 figure ch\u1EC9 ch\u1EE9a point/shape M\u1EDAI. Ref t\xEAn c\u0169 (A, B, C, \u2026) l\xE0 OK. KH\xD4NG redefine t\xEAn c\u0169.
+- **"replace"**: user mu\u1ED1n v\u1EBD L\u1EA0I ho\u1EB7c \u0111\u1ED5i sang h\xECnh kh\xE1c h\u1EB3n (vd: "v\u1EBD tam gi\xE1c \u0111\u1EC1u thay v\xE0o", "b\u1ECF tam gi\xE1c, d\u1EF1ng h\xECnh thoi").
+  \u2192 figure \u0111\u1EA7y \u0111\u1EE7 nh\u01B0 prompt m\u1EDBi (gi\u1ED1ng mode build).
+- **"refuse"**: y\xEAu c\u1EA7u ngo\xE0i ph\u1EA1m vi (3D, l\u01B0\u1EE3ng gi\xE1c, bi\u1EBFn h\xECnh l\u1EDBp 11+, t\xEDnh to\xE1n \u0111\u1EA1i s\u1ED1).
+
+## Quy t\u1EAFc decision=add
+1. M\u1ECDi name M\u1EDAI KH\xD4NG \u0111\u01B0\u1EE3c tr\xF9ng v\u1EDBi t\xEAn \u0111\xE3 d\xF9ng \u1EDF tr\xEAn. Tr\xF9ng \u2192 \u0111\u1EB7t kh\xE1c (M', M1, \u2026).
+2. \u01AFU TI\xCAN derived points: midpoint, perpFoot, intersection, circumcenter, incenter, centroid, orthocenter.
+3. Ref t\u1EDBi t\xEAn c\u0169 (A, B, C) l\xE0 OK \u2014 AI bi\u1EBFt c\xE1c t\xEAn \u0111\xF3 t\u1ED3n t\u1EA1i.
+4. KH\xD4NG copy l\u1EA1i entity c\u0169 v\xE0o figure delta (delta ch\u1EC9 ch\u1EE9a c\xE1i M\u1EDAI).
+
+## Anti-pattern (B\u1EAET BU\u1ED8C tr\xE1nh)
+- KH\xD4NG redefine t\xEAn \u0111\xE3 d\xF9ng (A, B, C \u0111\xE3 c\xF3 \u2192 KH\xD4NG \u0111\u1EB7t l\u1EA1i).
+- KH\xD4NG ref t\u1EDBi t\xEAn ch\u01B0a c\xF3 ngo\xE0i "T\xEAn \u0111\xE3 d\xF9ng" + t\xEAn v\u1EEBa \u0111\u1ECBnh ngh\u0129a trong delta.
+- KH\xD4NG emit add v\u1EDBi figure ch\u1EE9a c\u1EA3 entity c\u0169 (\u0111\xF3 l\xE0 replace).
+
+## 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
+
+## ${REFINE_PROMPT_FIXTURES.length} v\xED d\u1EE5
+
+${examples}
+
+Tr\u1EA3 v\u1EC1 CH\u1EC8 1 JSON object \u0111\xFAng schema. Kh\xF4ng c\xF3 l\u1EDDi d\u1EABn, kh\xF4ng markdown fence.`;
+}
+
+// src/stamps/geometry-2d/ai/buildFigureDelta.ts
+var DEFAULT_MAX_TOKENS2 = 8192;
+async function generateFigureDelta(input, opts = {}) {
+  const { problem, currentDsl } = input;
+  if (!problem || !problem.trim()) {
+    return { ok: false, reason: "api_error", message: "\u0110\u1EC1 b\xE0i r\u1ED7ng" };
+  }
+  let provider;
+  try {
+    provider = selectProvider(opts);
+  } catch (e) {
+    const err = e;
+    return { ok: false, reason: "api_error", message: err.message ?? "Kh\xF4ng ch\u1ECDn \u0111\u01B0\u1EE3c provider" };
+  }
+  const systemPrompt = buildRefineSystemPrompt(currentDsl);
+  const schema = refineEnvelopeJsonSchema();
+  const out = await provider.call({
+    systemPrompt,
+    userPrompt: problem,
+    schema,
+    model: opts.model ?? provider.defaultModel,
+    maxTokens: opts.maxTokens ?? DEFAULT_MAX_TOKENS2,
+    signal: opts.signal
+  });
+  if (out.kind === "error") {
+    return {
+      ok: false,
+      reason: "api_error",
+      message: out.message,
+      ...out.status !== void 0 ? { status: out.status } : {},
+      provider: provider.name
     };
   }
-  if (toolUse.name !== "build_figure") {
+  const usage = toUsage3(out.usage);
+  const parsed = FigureRefineEnvelopeZ.safeParse(out.data);
+  if (!parsed.success) {
     return {
       ok: false,
       reason: "parse_error",
-      message: `Tool kh\xF4ng x\xE1c \u0111\u1ECBnh: "${toolUse.name}"`,
-      raw: toolUse,
-      usage
+      message: "Envelope kh\xF4ng kh\u1EDBp schema: " + parsed.error.issues.map((i) => i.message).join("; "),
+      raw: out.data,
+      usage,
+      provider: provider.name
     };
   }
-  const tResult = transpile(toolUse.input);
-  if (!tResult.ok) {
+  const env = parsed.data;
+  if (env.decision === "refuse") {
     return {
       ok: false,
-      reason: "transpile_error",
-      message: "DSL t\u1EEB AI kh\xF4ng h\u1EE3p l\u1EC7",
-      errors: tResult.errors,
-      dsl: toolUse.input,
-      usage
+      reason: "refused",
+      message: env.reason ?? "AI t\u1EEB ch\u1ED1i kh\xF4ng n\xEAu l\xFD do",
+      usage,
+      provider: provider.name
+    };
+  }
+  if (env.decision === "replace") {
+    const figure = env.figure;
+    const tResult2 = transpile(figure);
+    if (!tResult2.ok) {
+      return liftTranspileError(tResult2.errors, figure, usage, provider.name);
+    }
+    return {
+      ok: true,
+      state: tResult2.state,
+      mergedDsl: figure,
+      mode: "replace",
+      usage,
+      provider: provider.name
     };
   }
+  const delta = env.figure;
+  const merged = {
+    version: 1,
+    points: [...currentDsl.points, ...delta.points],
+    shapes: [...currentDsl.shapes, ...delta.shapes]
+  };
+  const tResult = transpile(merged);
+  if (!tResult.ok) {
+    return liftTranspileError(tResult.errors, merged, usage, provider.name);
+  }
   return {
     ok: true,
     state: tResult.state,
-    dsl: toolUse.input,
-    usage
+    mergedDsl: merged,
+    mode: "add",
+    usage,
+    provider: provider.name
+  };
+}
+function liftTranspileError(errors, dsl, usage, providerName) {
+  const dupes = errors.filter((e) => e.code === "DUPLICATE_NAME");
+  if (dupes.length > 0) {
+    const collisions = Array.from(new Set(dupes.flatMap((e) => e.path ?? []).filter(Boolean)));
+    return {
+      ok: false,
+      reason: "name_collision",
+      message: "AI t\u1EA1o entity tr\xF9ng t\xEAn v\u1EDBi h\xECnh hi\u1EC7n t\u1EA1i: " + (collisions.length > 0 ? collisions.join(", ") : "kh\xF4ng x\xE1c \u0111\u1ECBnh"),
+      collisions,
+      errors,
+      dsl,
+      usage,
+      provider: providerName
+    };
+  }
+  const unresolved = errors.filter((e) => e.code === "UNKNOWN_REF");
+  if (unresolved.length > 0) {
+    const refs = Array.from(new Set(unresolved.flatMap((e) => e.path ?? []).filter(Boolean)));
+    return {
+      ok: false,
+      reason: "unresolved_ref",
+      message: "AI tham chi\u1EBFu t\xEAn kh\xF4ng c\xF3: " + (refs.length > 0 ? refs.join(", ") : "kh\xF4ng x\xE1c \u0111\u1ECBnh"),
+      refs,
+      errors,
+      dsl,
+      usage,
+      provider: providerName
+    };
+  }
+  return {
+    ok: false,
+    reason: "transpile_error",
+    message: "DSL t\u1EEB AI kh\xF4ng h\u1EE3p l\u1EC7",
+    errors,
+    dsl,
+    usage,
+    provider: providerName
   };
 }
+function toUsage3(u) {
+  return {
+    inputTokens: u?.inputTokens ?? 0,
+    outputTokens: u?.outputTokens ?? 0,
+    cacheReadTokens: u?.cacheReadTokens ?? 0,
+    cacheCreationTokens: u?.cacheCreationTokens ?? 0
+  };
+}
+
+// src/stamps/geometry-2d/ai/handleGenerateFigureDelta.ts
+var DEFAULT_MAX_ATTEMPTS2 = 2;
+async function handleGenerateFigureDelta(input, opts = {}) {
+  const { onResult, maxAttempts: rawMax, ...generateOpts } = opts;
+  const maxAttempts = clampAttempts2(rawMax ?? DEFAULT_MAX_ATTEMPTS2);
+  let lastResult = null;
+  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+    const result = await generateFigureDelta(input, generateOpts);
+    lastResult = result;
+    if (onResult) {
+      try {
+        onResult(result, attempt);
+      } catch {
+      }
+    }
+    if (result.ok) {
+      return { ok: true, state: result.state };
+    }
+    if (result.reason === "transpile_error" && attempt < maxAttempts) {
+      continue;
+    }
+    break;
+  }
+  return mapErrorToUi2(lastResult);
+}
+function clampAttempts2(n) {
+  if (!Number.isFinite(n)) return DEFAULT_MAX_ATTEMPTS2;
+  return Math.max(1, Math.min(5, Math.floor(n)));
+}
+function mapErrorToUi2(result) {
+  if (result.ok) return { ok: true, state: result.state };
+  switch (result.reason) {
+    case "refused":
+      return { ok: false, message: result.message };
+    case "parse_error":
+      return {
+        ok: false,
+        message: "AI tr\u1EA3 v\u1EC1 d\u1EEF li\u1EC7u kh\xF4ng h\u1EE3p l\u1EC7. Vui l\xF2ng th\u1EED l\u1EA1i ho\u1EB7c di\u1EC5n \u0111\u1EA1t l\u1EA1i."
+      };
+    case "transpile_error":
+      return {
+        ok: false,
+        message: "AI t\u1EA1o h\xECnh kh\xF4ng h\u1EE3p l\u1EC7 (\u0111\xE3 th\u1EED l\u1EA1i). Vui l\xF2ng t\xE1ch th\xE0nh 1 y\xEAu c\u1EA7u/l\u1EA7n ho\u1EB7c di\u1EC5n \u0111\u1EA1t kh\xE1c."
+      };
+    case "name_collision":
+      return {
+        ok: false,
+        message: `AI t\u1EA1o \u0111i\u1EC3m tr\xF9ng t\xEAn v\u1EDBi h\xECnh hi\u1EC7n t\u1EA1i (${result.collisions.join(", ")}). Vui l\xF2ng di\u1EC5n \u0111\u1EA1t l\u1EA1i.`
+      };
+    case "unresolved_ref":
+      return {
+        ok: false,
+        message: `AI tham chi\u1EBFu sai t\xEAn \u0111\u1ED1i t\u01B0\u1EE3ng (${result.refs.join(", ")}). Vui l\xF2ng di\u1EC5n \u0111\u1EA1t l\u1EA1i.`
+      };
+    case "api_error":
+    default:
+      return { ok: false, message: result.message };
+  }
+}
 
+exports.AnthropicProvider = AnthropicProvider;
+exports.FigureEnvelopeZ = FigureEnvelopeZ;
+exports.FigureRefineEnvelopeZ = FigureRefineEnvelopeZ;
+exports.OllamaProvider = OllamaProvider;
+exports.envelopeBuildDsl = envelopeBuildDsl;
+exports.envelopeJsonSchema = envelopeJsonSchema;
 exports.generateFigure = generateFigure;
+exports.generateFigureDelta = generateFigureDelta;
+exports.handleGenerateFigure = handleGenerateFigure;
+exports.handleGenerateFigureDelta = handleGenerateFigureDelta;
+exports.refineEnvelopeJsonSchema = refineEnvelopeJsonSchema;
+exports.selectProvider = selectProvider;
 //# sourceMappingURL=ai.js.map
 //# sourceMappingURL=ai.js.map