@xom11/whiteboard 0.25.0 → 0.27.0

package/dist/{chunk-VNCCIV6O.mjs → chunk-AJAHD35N.mjs}

@@ -2,6 +2,79 @@
 import { getKind } from './chunk-B4NJJZFR.mjs';
 import { z } from 'zod';
 
+// src/stamps/geometry-2d/ai/vision/preprocess.ts
+var MAX_EDGE_PX = 2048;
+var MAX_RAW_BYTES = 10 * 1024 * 1024;
+var MAX_ENCODED_BYTES = 3 * 1024 * 1024;
+var ALLOWED_TYPES = ["image/png", "image/jpeg", "image/webp"];
+function inferMediaType(file) {
+  const t = file.type.toLowerCase();
+  if (ALLOWED_TYPES.includes(t)) return t;
+  return null;
+}
+function validateFile(file) {
+  const mt = inferMediaType(file);
+  if (mt == null) {
+    return {
+      ok: false,
+      code: "invalid-format",
+      message: "Ch\u1EC9 h\u1ED7 tr\u1EE3 PNG, JPEG, WEBP."
+    };
+  }
+  if (file.size > MAX_RAW_BYTES) {
+    return {
+      ok: false,
+      code: "too-large",
+      message: `\u1EA2nh qu\xE1 l\u1EDBn (> ${Math.round(MAX_RAW_BYTES / 1024 / 1024)} MB). Crop ho\u1EB7c resize tr\u01B0\u1EDBc.`
+    };
+  }
+  return { ok: true, mediaType: mt };
+}
+async function fileToImagePart(file) {
+  const v = validateFile(file);
+  if (!v.ok) throw new Error(v.message);
+  const bitmap = await createImageBitmap(file);
+  const { width, height } = bitmap;
+  const maxEdge = Math.max(width, height);
+  const scale = maxEdge > MAX_EDGE_PX ? MAX_EDGE_PX / maxEdge : 1;
+  const targetW = Math.round(width * scale);
+  const targetH = Math.round(height * scale);
+  const canvas = typeof OffscreenCanvas !== "undefined" ? new OffscreenCanvas(targetW, targetH) : Object.assign(document.createElement("canvas"), { width: targetW, height: targetH });
+  const ctx = canvas.getContext("2d");
+  if (!ctx) throw new Error("Kh\xF4ng t\u1EA1o \u0111\u01B0\u1EE3c canvas 2D context");
+  ctx.drawImage(bitmap, 0, 0, targetW, targetH);
+  bitmap.close();
+  let outputType = v.mediaType === "image/png" ? "image/png" : "image/jpeg";
+  let finalBlob = await canvasToBlob(canvas, outputType, 0.92);
+  if (finalBlob.size > MAX_ENCODED_BYTES) {
+    outputType = "image/jpeg";
+    finalBlob = await canvasToBlob(canvas, "image/jpeg", 0.7);
+  }
+  const base64 = await blobToBase64(finalBlob);
+  return { mediaType: outputType, base64 };
+}
+async function canvasToBlob(canvas, type, quality) {
+  if ("convertToBlob" in canvas) {
+    return canvas.convertToBlob({ type, quality });
+  }
+  return new Promise((resolve, reject) => {
+    canvas.toBlob(
+      (b) => b ? resolve(b) : reject(new Error("Canvas encode fail")),
+      type,
+      quality
+    );
+  });
+}
+async function blobToBase64(blob) {
+  const buf = await blob.arrayBuffer();
+  let binary = "";
+  const bytes = new Uint8Array(buf);
+  const chunk = 32768;
+  for (let i = 0; i < bytes.length; i += chunk) {
+    binary += String.fromCharCode(...bytes.subarray(i, i + chunk));
+  }
+  return typeof btoa === "function" ? btoa(binary) : Buffer.from(binary, "binary").toString("base64");
+}
 var NameZ = z.string().regex(/^[A-Za-z][A-Za-z0-9_'₀-₉]{0,11}$/);
 
 // src/stamps/geometry-2d/dsl/kinds/_types.ts
@@ -16,12 +89,13 @@ var POINT_BASE_FIELDS = {
   layer: "default",
   schemaVersion: 1
 };
-function emitPointObject(id, name, constraint) {
+function emitPointObject(id, name, constraint, visible = true) {
   return {
     id,
     kind: "point",
     label: name,
     ...POINT_BASE_FIELDS,
+    visible,
     attrs: { constraint }
   };
 }
@@ -62,7 +136,8 @@ var midpointModule = defineModule({
     name: NameZ,
     kind: z.literal("midpoint"),
     p1: NameZ,
-    p2: NameZ
+    p2: NameZ,
+    visible: z.boolean().optional()
   }),
   collectRefs: (e) => [e.p1, e.p2],
   emit: (e, ctx) => [{
@@ -70,7 +145,8 @@ var midpointModule = defineModule({
     object: emitPointObject(
       ctx.resolveId(e.name),
       e.name,
-      { kind: "midpoint", p1: ctx.resolveId(e.p1), p2: ctx.resolveId(e.p2) }
+      { kind: "midpoint", p1: ctx.resolveId(e.p1), p2: ctx.resolveId(e.p2) },
+      e.visible ?? true
     )
   }]
 });
@@ -465,6 +541,67 @@ var angleBisectorModule = defineModule({
     }
   }]
 });
+var lineThroughModule = defineModule({
+  kind: "lineThrough",
+  role: "lineConstruction",
+  category: "lines",
+  prefix: "l",
+  schema: z.object({
+    name: NameZ,
+    kind: z.literal("lineThrough"),
+    points: z.array(NameZ).min(2)
+  }),
+  collectRefs: (e) => [...e.points],
+  refSpecs: [{ field: "points", role: "point", many: true }],
+  emit: (e, ctx) => [{
+    role: "primary",
+    object: {
+      id: ctx.resolveId(e.name),
+      kind: "line",
+      label: e.name,
+      ...SHAPE_BASE_FIELDS,
+      attrs: {
+        construction: {
+          kind: "lineThrough",
+          points: e.points.map((p) => ctx.resolveId(p))
+        }
+      }
+    }
+  }]
+});
+var radicalAxisModule = defineModule({
+  kind: "radicalAxis",
+  role: "lineConstruction",
+  category: "lines",
+  prefix: "l",
+  schema: z.object({
+    name: NameZ,
+    kind: z.literal("radicalAxis"),
+    circle1: NameZ,
+    circle2: NameZ
+  }),
+  collectRefs: (e) => [e.circle1, e.circle2],
+  refSpecs: [
+    { field: "circle1", role: "circle" },
+    { field: "circle2", role: "circle" }
+  ],
+  emit: (e, ctx) => [{
+    role: "primary",
+    object: {
+      id: ctx.resolveId(e.name),
+      kind: "line",
+      label: e.name,
+      ...SHAPE_BASE_FIELDS,
+      attrs: {
+        construction: {
+          kind: "radicalAxis",
+          circle1: ctx.resolveId(e.circle1),
+          circle2: ctx.resolveId(e.circle2)
+        }
+      }
+    }
+  }]
+});
 var tangentModule = defineModule({
   kind: "tangent",
   role: "lineConstruction",
@@ -528,7 +665,8 @@ var circleCPModule = defineModule({
     name: NameZ,
     kind: z.literal("circleCP"),
     center: NameZ,
-    surfacePoint: NameZ
+    surfacePoint: NameZ,
+    visible: z.boolean().optional()
   }),
   collectRefs: (e) => [e.center, e.surfacePoint],
   emit: (e, ctx) => [{
@@ -538,6 +676,7 @@ var circleCPModule = defineModule({
       kind: "circle",
       label: e.name,
       ...SHAPE_BASE_FIELDS,
+      visible: e.visible ?? true,
       attrs: { center: ctx.resolveId(e.center), surfacePoint: ctx.resolveId(e.surfacePoint) }
     }
   }]
@@ -573,6 +712,411 @@ var circle3Module = defineModule({
     }
   }]
 });
+var circleDiameterModule = defineModule({
+  kind: "circleDiameter",
+  role: "circle",
+  category: "circles",
+  prefix: "c",
+  schema: z.object({
+    name: NameZ,
+    kind: z.literal("circleDiameter"),
+    p1: NameZ,
+    p2: NameZ,
+    visible: z.boolean().optional()
+  }),
+  collectRefs: (e) => [e.p1, e.p2],
+  emit: (e, ctx) => [{
+    role: "primary",
+    object: {
+      id: ctx.resolveId(e.name),
+      kind: "circle",
+      label: e.name,
+      ...SHAPE_BASE_FIELDS,
+      visible: e.visible ?? true,
+      attrs: {
+        construction: {
+          kind: "diameter",
+          p1: ctx.resolveId(e.p1),
+          p2: ctx.resolveId(e.p2)
+        }
+      }
+    }
+  }]
+});
+var secondIntersectionModule = defineModule({
+  kind: "secondIntersection",
+  role: "point",
+  category: "points",
+  prefix: "p",
+  schema: z.object({
+    name: NameZ,
+    kind: z.literal("secondIntersection"),
+    line: NameZ,
+    circle: NameZ,
+    other: NameZ
+  }),
+  collectRefs: (e) => [e.line, e.circle, e.other],
+  refSpecs: [
+    { field: "line", role: "line-like" },
+    { field: "circle", role: "circle" },
+    { field: "other", role: "point" }
+  ],
+  emit: (e, ctx) => [{
+    role: "primary",
+    object: emitPointObject(
+      ctx.resolveId(e.name),
+      e.name,
+      {
+        kind: "secondIntersection",
+        line: ctx.resolveId(e.line),
+        circle: ctx.resolveId(e.circle),
+        other: ctx.resolveId(e.other)
+      }
+    )
+  }]
+});
+var circleIntersectionModule = defineModule({
+  kind: "circleIntersection",
+  role: "point",
+  category: "points",
+  prefix: "p",
+  schema: z.object({
+    name: NameZ,
+    kind: z.literal("circleIntersection"),
+    c1: NameZ,
+    c2: NameZ,
+    which: z.union([z.literal(0), z.literal(1)])
+  }),
+  collectRefs: (e) => [e.c1, e.c2],
+  refSpecs: [
+    { field: "c1", role: "circle" },
+    { field: "c2", role: "circle" }
+  ],
+  emit: (e, ctx) => [{
+    role: "primary",
+    object: emitPointObject(
+      ctx.resolveId(e.name),
+      e.name,
+      {
+        kind: "circleIntersection",
+        c1: ctx.resolveId(e.c1),
+        c2: ctx.resolveId(e.c2),
+        which: e.which
+      }
+    )
+  }]
+});
+var circleSecondIntersectionModule = defineModule({
+  kind: "circleSecondIntersection",
+  role: "point",
+  category: "points",
+  prefix: "p",
+  schema: z.object({
+    name: NameZ,
+    kind: z.literal("circleSecondIntersection"),
+    c1: NameZ,
+    c2: NameZ,
+    exclude: NameZ
+  }),
+  collectRefs: (e) => [e.c1, e.c2, e.exclude],
+  refSpecs: [
+    { field: "c1", role: "circle" },
+    { field: "c2", role: "circle" },
+    { field: "exclude", role: "point" }
+  ],
+  emit: (e, ctx) => [{
+    role: "primary",
+    object: emitPointObject(
+      ctx.resolveId(e.name),
+      e.name,
+      {
+        kind: "circleSecondIntersection",
+        c1: ctx.resolveId(e.c1),
+        c2: ctx.resolveId(e.c2),
+        exclude: ctx.resolveId(e.exclude)
+      }
+    )
+  }]
+});
+var tangencyPointModule = defineModule({
+  kind: "tangencyPoint",
+  role: "point",
+  category: "points",
+  prefix: "p",
+  schema: z.object({
+    name: NameZ,
+    kind: z.literal("tangencyPoint"),
+    circle: NameZ,
+    onLine: NameZ
+  }),
+  collectRefs: (e) => [e.circle, e.onLine],
+  refSpecs: [
+    { field: "circle", role: "circle" },
+    { field: "onLine", role: "line-like" }
+  ],
+  emit: (e, ctx) => [{
+    role: "primary",
+    object: emitPointObject(
+      ctx.resolveId(e.name),
+      e.name,
+      {
+        kind: "tangencyPoint",
+        circle: ctx.resolveId(e.circle),
+        onLine: ctx.resolveId(e.onLine)
+      }
+    )
+  }]
+});
+var tangentPointExtModule = defineModule({
+  kind: "tangentPointExt",
+  role: "point",
+  category: "points",
+  prefix: "p",
+  schema: z.object({
+    name: NameZ,
+    kind: z.literal("tangentPointExt"),
+    from: NameZ,
+    circle: NameZ,
+    which: z.union([z.literal(0), z.literal(1)])
+  }),
+  collectRefs: (e) => [e.from, e.circle],
+  refSpecs: [
+    { field: "from", role: "point" },
+    { field: "circle", role: "circle" }
+  ],
+  emit: (e, ctx) => [{
+    role: "primary",
+    object: emitPointObject(
+      ctx.resolveId(e.name),
+      e.name,
+      {
+        kind: "tangentPointExt",
+        from: ctx.resolveId(e.from),
+        circle: ctx.resolveId(e.circle),
+        which: e.which
+      }
+    )
+  }]
+});
+var circleCRModule = defineModule({
+  kind: "circleCR",
+  role: "circle",
+  category: "circles",
+  prefix: "c",
+  schema: z.object({
+    name: NameZ,
+    kind: z.literal("circleCR"),
+    center: NameZ,
+    radius: z.number().positive()
+  }),
+  collectRefs: (e) => [e.center],
+  refSpecs: [{ field: "center", role: "point" }],
+  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), radius: e.radius }
+    }
+  }]
+});
+var incircleModule = defineModule({
+  kind: "incircle",
+  role: "circle",
+  category: "circles",
+  prefix: "c",
+  schema: z.object({
+    name: NameZ,
+    kind: z.literal("incircle"),
+    vertices: z.tuple([NameZ, NameZ, NameZ])
+  }),
+  collectRefs: (e) => [...e.vertices],
+  refSpecs: [{ field: "vertices", role: "point", many: true }],
+  emit: (e, ctx) => [{
+    role: "primary",
+    object: {
+      id: ctx.resolveId(e.name),
+      kind: "circle",
+      label: e.name,
+      ...SHAPE_BASE_FIELDS,
+      attrs: {
+        kind: "incircle",
+        vertices: [
+          ctx.resolveId(e.vertices[0]),
+          ctx.resolveId(e.vertices[1]),
+          ctx.resolveId(e.vertices[2])
+        ]
+      }
+    }
+  }]
+});
+var excircleModule = defineModule({
+  kind: "excircle",
+  role: "circle",
+  category: "circles",
+  prefix: "c",
+  schema: z.object({
+    name: NameZ,
+    kind: z.literal("excircle"),
+    vertices: z.tuple([NameZ, NameZ, NameZ]),
+    opposite: NameZ
+  }),
+  collectRefs: (e) => [...e.vertices],
+  refSpecs: [
+    { field: "vertices", role: "point", many: true },
+    { field: "opposite", role: "point" }
+  ],
+  emit: (e, ctx) => [{
+    role: "primary",
+    object: {
+      id: ctx.resolveId(e.name),
+      kind: "circle",
+      label: e.name,
+      ...SHAPE_BASE_FIELDS,
+      attrs: {
+        construction: {
+          kind: "excircle",
+          p1: ctx.resolveId(e.vertices[0]),
+          p2: ctx.resolveId(e.vertices[1]),
+          p3: ctx.resolveId(e.vertices[2]),
+          opposite: ctx.resolveId(e.opposite)
+        }
+      }
+    }
+  }]
+});
+var arcMidpointModule = defineModule({
+  kind: "arcMidpoint",
+  role: "point",
+  category: "points",
+  prefix: "p",
+  schema: z.object({
+    name: NameZ,
+    kind: z.literal("arcMidpoint"),
+    circle: NameZ,
+    a: NameZ,
+    b: NameZ,
+    notContaining: NameZ
+  }),
+  collectRefs: (e) => [e.circle, e.a, e.b, e.notContaining],
+  emit: (e, ctx) => [{
+    role: "primary",
+    object: emitPointObject(ctx.resolveId(e.name), e.name, {
+      kind: "arcMidpoint",
+      circle: ctx.resolveId(e.circle),
+      a: ctx.resolveId(e.a),
+      b: ctx.resolveId(e.b),
+      notContaining: ctx.resolveId(e.notContaining)
+    })
+  }]
+});
+var excenterModule = defineModule({
+  kind: "excenter",
+  role: "point",
+  category: "points",
+  prefix: "p",
+  schema: z.object({
+    name: NameZ,
+    kind: z.literal("excenter"),
+    vertices: z.tuple([NameZ, NameZ, NameZ]),
+    opposite: NameZ
+  }),
+  collectRefs: (e) => [...e.vertices],
+  emit: (e, ctx) => [{
+    role: "primary",
+    object: emitPointObject(ctx.resolveId(e.name), e.name, {
+      kind: "excenter",
+      vertices: resolveTriangleVertices(ctx, e.vertices),
+      opposite: ctx.resolveId(e.opposite)
+    })
+  }]
+});
+var reflectPointModule = defineModule({
+  kind: "reflectPoint",
+  role: "point",
+  category: "points",
+  prefix: "p",
+  schema: z.object({ name: NameZ, kind: z.literal("reflectPoint"), of: NameZ, through: NameZ }),
+  collectRefs: (e) => [e.of, e.through],
+  emit: (e, ctx) => [{
+    role: "primary",
+    object: emitPointObject(ctx.resolveId(e.name), e.name, {
+      kind: "transformed",
+      source: ctx.resolveId(e.of),
+      transform: { kind: "reflectPoint", center: ctx.resolveId(e.through) }
+    })
+  }]
+});
+var reflectLineModule = defineModule({
+  kind: "reflectLine",
+  role: "point",
+  category: "points",
+  prefix: "p",
+  schema: z.object({ name: NameZ, kind: z.literal("reflectLine"), of: NameZ, through: NameZ }),
+  collectRefs: (e) => [e.of, e.through],
+  emit: (e, ctx) => [{
+    role: "primary",
+    object: emitPointObject(ctx.resolveId(e.name), e.name, {
+      kind: "transformed",
+      source: ctx.resolveId(e.of),
+      transform: { kind: "reflectLine", line: ctx.resolveId(e.through) }
+    })
+  }]
+});
+var ScaleOffsetZ = {
+  scale: z.number().positive().optional(),
+  offset: z.number().optional()
+};
+var DistanceZ = z.discriminatedUnion("kind", [
+  z.object({ kind: z.literal("circleRadius"), circle: NameZ, ...ScaleOffsetZ }),
+  z.object({ kind: z.literal("segmentLength"), p1: NameZ, p2: NameZ, ...ScaleOffsetZ }),
+  z.object({ kind: z.literal("literal"), value: z.number().positive(), ...ScaleOffsetZ })
+]);
+function withScaleOffset(base, d) {
+  const out = { ...base };
+  if (d.scale !== void 0) out.scale = d.scale;
+  if (d.offset !== void 0) out.offset = d.offset;
+  return out;
+}
+var pointAtDistanceModule = defineModule({
+  kind: "pointAtDistance",
+  role: "point",
+  category: "points",
+  prefix: "p",
+  schema: z.object({
+    name: NameZ,
+    kind: z.literal("pointAtDistance"),
+    from: NameZ,
+    through: NameZ,
+    distance: DistanceZ
+  }),
+  collectRefs: (e) => {
+    const d = e.distance;
+    const extra = d.kind === "circleRadius" ? [d.circle] : d.kind === "segmentLength" ? [d.p1, d.p2] : [];
+    return [e.from, e.through, ...extra];
+  },
+  // TODO(Mức 1 defer): distance.{circle,p1,p2} là nested trong `distance` — refSpec
+  // phẳng đọc top-level không với tới, validate riêng nếu cần. Hiện validate from/through.
+  refSpecs: [
+    { field: "from", role: "point" },
+    { field: "through", role: "point" }
+  ],
+  emit: (e, ctx) => {
+    const d = e.distance;
+    const distance = d.kind === "circleRadius" ? withScaleOffset({ kind: "circleRadius", circle: ctx.resolveId(d.circle) }, d) : d.kind === "segmentLength" ? withScaleOffset({ kind: "segmentLength", p1: ctx.resolveId(d.p1), p2: ctx.resolveId(d.p2) }, d) : withScaleOffset({ kind: "literal", value: d.value }, d);
+    return [{
+      role: "primary",
+      object: emitPointObject(ctx.resolveId(e.name), e.name, {
+        kind: "pointAtDistance",
+        from: ctx.resolveId(e.from),
+        through: ctx.resolveId(e.through),
+        distance
+      })
+    }];
+  }
+});
 
 // src/stamps/geometry-2d/dsl/registry.ts
 var ALL_MODULES = [
@@ -587,6 +1131,12 @@ var ALL_MODULES = [
   centroidModule,
   orthocenterModule,
   intersectionModule,
+  // NEW Tier 4+5 points
+  secondIntersectionModule,
+  circleIntersectionModule,
+  circleSecondIntersectionModule,
+  tangencyPointModule,
+  tangentPointExtModule,
   segmentModule,
   lineModule,
   rayModule,
@@ -594,10 +1144,24 @@ var ALL_MODULES = [
   parallelModule,
   perpBisectorModule,
   angleBisectorModule,
+  lineThroughModule,
+  radicalAxisModule,
   tangentModule,
   polygonModule,
   circleCPModule,
-  circle3Module
+  circle3Module,
+  circleDiameterModule,
+  // NEW Tier 4+5 circles
+  circleCRModule,
+  incircleModule,
+  excircleModule,
+  // Cụm A points
+  arcMidpointModule,
+  excenterModule,
+  reflectPointModule,
+  reflectLineModule,
+  // Cụm B points
+  pointAtDistanceModule
 ];
 var KIND_REGISTRY = new Map(ALL_MODULES.map((m) => [m.kind, m]));
 var POINT_KINDS = new Set(
@@ -683,10 +1247,107 @@ function serializePoint(obj, state) {
         }
       };
     }
+    case "tangentPointExt": {
+      const refs = resolveRefs([c.from, c.circle], state);
+      if (!refs) return fail("unresolved-ref", `${c.from},${c.circle}`);
+      return {
+        ok: true,
+        entity: {
+          name: obj.label,
+          kind: "tangentPointExt",
+          from: refs[0],
+          circle: refs[1],
+          which: c.which
+        }
+      };
+    }
+    case "circleIntersection": {
+      const refs = resolveRefs([c.c1, c.c2], state);
+      if (!refs) return fail("unresolved-ref", `${c.c1},${c.c2}`);
+      return {
+        ok: true,
+        entity: { name: obj.label, kind: "circleIntersection", c1: refs[0], c2: refs[1], which: c.which }
+      };
+    }
+    case "circleSecondIntersection": {
+      const refs = resolveRefs([c.c1, c.c2, c.exclude], state);
+      if (!refs) return fail("unresolved-ref", `${c.c1},${c.c2},${c.exclude}`);
+      return {
+        ok: true,
+        entity: { name: obj.label, kind: "circleSecondIntersection", c1: refs[0], c2: refs[1], exclude: refs[2] }
+      };
+    }
+    case "secondIntersection": {
+      const refs = resolveRefs([c.line, c.circle, c.other], state);
+      if (!refs) return fail("unresolved-ref", `${c.line},${c.circle},${c.other}`);
+      return {
+        ok: true,
+        entity: { name: obj.label, kind: "secondIntersection", line: refs[0], circle: refs[1], other: refs[2] }
+      };
+    }
+    case "tangencyPoint": {
+      const refs = resolveRefs([c.circle, c.onLine], state);
+      if (!refs) return fail("unresolved-ref", `${c.circle},${c.onLine}`);
+      return {
+        ok: true,
+        entity: { name: obj.label, kind: "tangencyPoint", circle: refs[0], onLine: refs[1] }
+      };
+    }
+    case "arcMidpoint": {
+      const refs = resolveRefs([c.circle, c.a, c.b, c.notContaining], state);
+      if (!refs) return fail("unresolved-ref", `${c.circle},${c.a},${c.b},${c.notContaining}`);
+      return {
+        ok: true,
+        entity: {
+          name: obj.label,
+          kind: "arcMidpoint",
+          circle: refs[0],
+          a: refs[1],
+          b: refs[2],
+          notContaining: refs[3]
+        }
+      };
+    }
+    case "excenter": {
+      const refs = resolveRefs([c.vertices[0], c.vertices[1], c.vertices[2], c.opposite], state);
+      if (!refs) return fail("unresolved-ref", `${c.vertices.join(",")},${c.opposite}`);
+      return {
+        ok: true,
+        entity: {
+          name: obj.label,
+          kind: "excenter",
+          vertices: [refs[0], refs[1], refs[2]],
+          opposite: refs[3]
+        }
+      };
+    }
+    case "pointAtDistance": {
+      const d = c.distance;
+      const distRefIds = d.kind === "circleRadius" ? [d.circle] : d.kind === "segmentLength" ? [d.p1, d.p2] : [];
+      const refs = resolveRefs([c.from, c.through, ...distRefIds], state);
+      if (!refs) return fail("unresolved-ref", [c.from, c.through, ...distRefIds].join(","));
+      let distance;
+      if (d.kind === "circleRadius") {
+        distance = { kind: "circleRadius", circle: refs[2] };
+      } else if (d.kind === "segmentLength") {
+        distance = { kind: "segmentLength", p1: refs[2], p2: refs[3] };
+      } else {
+        distance = { kind: "literal", value: d.value };
+      }
+      if (d.scale !== void 0) distance.scale = d.scale;
+      if (d.offset !== void 0) distance.offset = d.offset;
+      return {
+        ok: true,
+        entity: { name: obj.label, kind: "pointAtDistance", from: refs[0], through: refs[1], distance }
+      };
+    }
     // Out of DSL v1:
     case "onAxis":
     case "onPolygon":
     case "transformed":
+    case "onPerpendicular":
+    case "onPerpBisector":
+    case "onCircleAroundPoint":
       return fail("unsupported-constraint", c.kind);
     default: {
       return fail("unsupported-constraint");
@@ -771,6 +1432,16 @@ function serializeLine(obj, state) {
       } : { name: obj.label, kind: "tangent", throughPoint: refs[0], toCircle: refs[1] };
       return { ok: true, entity };
     }
+    case "lineThrough": {
+      const refs = resolveRefs(c.points, state);
+      if (!refs) return fail("unresolved-ref", c.points.join(","));
+      return { ok: true, entity: { name: obj.label, kind: "lineThrough", points: refs } };
+    }
+    case "radicalAxis": {
+      const refs = resolveRefs([c.circle1, c.circle2], state);
+      if (!refs) return fail("unresolved-ref", `${c.circle1},${c.circle2}`);
+      return { ok: true, entity: { name: obj.label, kind: "radicalAxis", circle1: refs[0], circle2: refs[1] } };
+    }
     case "angleBisectorLines":
       return fail("unsupported-construction", "angleBisectorLines");
     default: {
@@ -790,8 +1461,45 @@ function serializePolygon(obj, state) {
 }
 function serializeCircle(obj, state) {
   const a = obj.attrs;
-  const c = a.construction;
+  const c = (() => {
+    if (a.construction) return a.construction;
+    const raw = a;
+    if (raw.kind === "incircle" && raw.vertices) {
+      return {
+        kind: "incircle",
+        p1: raw.vertices[0],
+        p2: raw.vertices[1],
+        p3: raw.vertices[2]
+      };
+    }
+    if (raw.kind === "excircle" && raw.vertices && raw.opposite) {
+      return {
+        kind: "excircle",
+        p1: raw.vertices[0],
+        p2: raw.vertices[1],
+        p3: raw.vertices[2],
+        opposite: raw.opposite
+      };
+    }
+    if (raw.kind === "circleDiameter" && raw.p1 && raw.p2) {
+      return {
+        kind: "diameter",
+        p1: raw.p1,
+        p2: raw.p2
+      };
+    }
+    return void 0;
+  })();
   if (!c) {
+    if (typeof a.radius === "number") {
+      if (!a.center) return fail("unsupported-construction", "missing center");
+      const refs2 = resolveRefs([a.center], state);
+      if (!refs2) return fail("unresolved-ref", `${a.center}`);
+      return {
+        ok: true,
+        entity: { name: obj.label, kind: "circleCR", center: refs2[0], radius: a.radius }
+      };
+    }
     if (!a.center || !a.surfacePoint) {
       return fail("unsupported-construction", "missing center/surfacePoint");
     }
@@ -810,6 +1518,30 @@ function serializeCircle(obj, state) {
       entity: { name: obj.label, kind: "circle3", p1: refs[0], p2: refs[1], p3: refs[2] }
     };
   }
+  if (c.kind === "incircle") {
+    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: "incircle", vertices: [refs[0], refs[1], refs[2]] }
+    };
+  }
+  if (c.kind === "excircle") {
+    const refs = resolveRefs([c.p1, c.p2, c.p3, c.opposite], state);
+    if (!refs) return fail("unresolved-ref", `${c.p1},${c.p2},${c.p3},${c.opposite}`);
+    return {
+      ok: true,
+      entity: { name: obj.label, kind: "excircle", vertices: [refs[0], refs[1], refs[2]], opposite: refs[3] }
+    };
+  }
+  if (c.kind === "diameter") {
+    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: "circleDiameter", p1: refs[0], p2: refs[1] }
+    };
+  }
   return fail("unsupported-construction");
 }
 function serializeObject(obj, state) {
@@ -908,6 +1640,10 @@ function describeEntity(e) {
       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 "lineThrough":
+      return `${e.name} = \u0111\u01B0\u1EDDng qua ${e.points.join("")}`;
+    case "radicalAxis":
+      return `${e.name} = tr\u1EE5c \u0111\u1EB3ng ph\u01B0\u01A1ng ${e.circle1} & ${e.circle2}`;
     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}`;
@@ -916,6 +1652,40 @@ function describeEntity(e) {
       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}`;
+    case "circleDiameter":
+      return `${e.name} = \u0111\u01B0\u1EDDng tr\xF2n \u0111\u01B0\u1EDDng k\xEDnh ${e.p1}${e.p2}`;
+    // NEW Tier 4+5
+    case "secondIntersection":
+      return `${e.name} = giao th\u1EE9 hai c\u1EE7a ${e.line} v\xE0 ${e.circle} (kh\xE1c ${e.other})`;
+    case "circleIntersection":
+      return `${e.name} = giao ${e.c1} \u2229 ${e.c2} (nh\xE1nh ${e.which})`;
+    case "circleSecondIntersection":
+      return `${e.name} = giao th\u1EE9 hai ${e.c1} \u2229 ${e.c2} (kh\xE1c ${e.exclude})`;
+    case "tangencyPoint":
+      return `${e.name} = ti\u1EBFp \u0111i\u1EC3m c\u1EE7a ${e.circle} tr\xEAn ${e.onLine}`;
+    case "tangentPointExt":
+      return `${e.name} = ti\u1EBFp \u0111i\u1EC3m t\u1EEB ${e.from} l\xEAn ${e.circle} (nh\xE1nh ${e.which})`;
+    case "circleCR":
+      return `${e.name} = \u0111\u01B0\u1EDDng tr\xF2n (${e.center}; r=${e.radius})`;
+    case "incircle":
+      return `${e.name} = \u0111\u01B0\u1EDDng tr\xF2n n\u1ED9i ti\u1EBFp ${e.vertices.join("")}`;
+    case "excircle":
+      return `${e.name} = \u0111\u01B0\u1EDDng tr\xF2n b\xE0ng ti\u1EBFp ${e.vertices.join("")} \u0111\u1ED1i di\u1EC7n ${e.opposite}`;
+    // Cụm A
+    case "arcMidpoint":
+      return `${e.name} = trung \u0111i\u1EC3m cung ${e.a}${e.b} (kh\xF4ng ch\u1EE9a ${e.notContaining}) tr\xEAn ${e.circle}`;
+    case "excenter":
+      return `${e.name} = t\xE2m b\xE0ng ti\u1EBFp ${e.vertices.join("")} \u0111\u1ED1i di\u1EC7n ${e.opposite}`;
+    case "reflectPoint":
+      return `${e.name} = \u0111\u1ED1i x\u1EE9ng ${e.of} qua \u0111i\u1EC3m ${e.through}`;
+    case "reflectLine":
+      return `${e.name} = \u0111\u1ED1i x\u1EE9ng ${e.of} qua \u0111\u01B0\u1EDDng ${e.through}`;
+    // Cụm B
+    case "pointAtDistance": {
+      const d = e.distance;
+      const distStr = d.kind === "circleRadius" ? `r(${d.circle})` : d.kind === "segmentLength" ? `|${d.p1}${d.p2}|` : `${d.value}`;
+      return `${e.name} = \u0111i\u1EC3m tr\xEAn tia ${e.from}${e.through} c\xE1ch ${e.through} m\u1ED9t kho\u1EA3ng ${distStr}`;
+    }
     default: {
       return "";
     }
@@ -933,6 +1703,6 @@ function describeDsl(obj, state) {
   return `${base} (kh\xF4ng h\u1ED7 tr\u1EE3 DSL)`;
 }
 
-export { CIRCLE_KINDS, KIND_REGISTRY, LINE_LIKE_SHAPE_KINDS, POINT_KINDS, describeDsl, serializeState };
-//# sourceMappingURL=chunk-VNCCIV6O.mjs.map
-//# sourceMappingURL=chunk-VNCCIV6O.mjs.map
+export { CIRCLE_KINDS, KIND_REGISTRY, LINE_LIKE_SHAPE_KINDS, MAX_EDGE_PX, MAX_ENCODED_BYTES, MAX_RAW_BYTES, POINT_KINDS, describeDsl, fileToImagePart, inferMediaType, serializeState, validateFile };
+//# sourceMappingURL=chunk-AJAHD35N.mjs.map
+//# sourceMappingURL=chunk-AJAHD35N.mjs.map