@xom11/whiteboard 0.24.2 → 0.27.0

package/dist/chunk-AJAHD35N.mjs

@@ -0,0 +1,1708 @@
+"use client";
+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
+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, visible = true) {
+  return {
+    id,
+    kind: "point",
+    label: name,
+    ...POINT_BASE_FIELDS,
+    visible,
+    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: z.object({
+    name: NameZ,
+    kind: z.literal("free"),
+    x: z.number().finite(),
+    y: z.number().finite()
+  }),
+  collectRefs: () => [],
+  emit: (e, ctx) => [{
+    role: "primary",
+    object: emitPointObject(ctx.resolveId(e.name), e.name, { kind: "free", x: e.x, y: e.y })
+  }]
+});
+var midpointModule = defineModule({
+  kind: "midpoint",
+  role: "point",
+  category: "points",
+  prefix: "p",
+  schema: z.object({
+    name: NameZ,
+    kind: z.literal("midpoint"),
+    p1: NameZ,
+    p2: NameZ,
+    visible: z.boolean().optional()
+  }),
+  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) },
+      e.visible ?? true
+    )
+  }]
+});
+var onSegmentModule = defineModule({
+  kind: "onSegment",
+  role: "point",
+  category: "points",
+  prefix: "p",
+  schema: z.object({
+    name: NameZ,
+    kind: z.literal("onSegment"),
+    segmentId: NameZ,
+    t: z.number().min(0).max(1)
+  }),
+  collectRefs: (e) => [e.segmentId],
+  emit: (e, ctx) => [{
+    role: "primary",
+    object: emitPointObject(
+      ctx.resolveId(e.name),
+      e.name,
+      { kind: "onSegment", segmentId: ctx.resolveId(e.segmentId), t: e.t }
+    )
+  }]
+});
+var onLineModule = defineModule({
+  kind: "onLine",
+  role: "point",
+  category: "points",
+  prefix: "p",
+  schema: z.object({
+    name: NameZ,
+    kind: z.literal("onLine"),
+    lineId: NameZ,
+    t: z.number().finite()
+  }),
+  collectRefs: (e) => [e.lineId],
+  emit: (e, ctx) => [{
+    role: "primary",
+    object: emitPointObject(
+      ctx.resolveId(e.name),
+      e.name,
+      { kind: "onLine", lineId: ctx.resolveId(e.lineId), t: e.t }
+    )
+  }]
+});
+var onCircleModule = defineModule({
+  kind: "onCircle",
+  role: "point",
+  category: "points",
+  prefix: "p",
+  schema: z.object({
+    name: NameZ,
+    kind: z.literal("onCircle"),
+    circleId: NameZ,
+    theta: z.number().finite()
+  }),
+  collectRefs: (e) => [e.circleId],
+  emit: (e, ctx) => [{
+    role: "primary",
+    object: emitPointObject(
+      ctx.resolveId(e.name),
+      e.name,
+      { kind: "onCircle", circleId: ctx.resolveId(e.circleId), theta: e.theta }
+    )
+  }]
+});
+var perpFootModule = defineModule({
+  kind: "perpFoot",
+  role: "point",
+  category: "points",
+  prefix: "p",
+  schema: z.object({
+    name: NameZ,
+    kind: z.literal("perpFoot"),
+    from: NameZ,
+    onLine: NameZ
+  }),
+  collectRefs: (e) => [e.from, e.onLine],
+  emit: (e, ctx) => [{
+    role: "primary",
+    object: emitPointObject(
+      ctx.resolveId(e.name),
+      e.name,
+      { kind: "perpFoot", from: ctx.resolveId(e.from), onLine: ctx.resolveId(e.onLine) }
+    )
+  }]
+});
+var circumcenterModule = defineModule({
+  kind: "circumcenter",
+  role: "point",
+  category: "points",
+  prefix: "p",
+  schema: z.object({
+    name: NameZ,
+    kind: z.literal("circumcenter"),
+    vertices: z.tuple([NameZ, NameZ, NameZ])
+  }),
+  collectRefs: (e) => [...e.vertices],
+  emit: (e, ctx) => [{
+    role: "primary",
+    object: emitPointObject(
+      ctx.resolveId(e.name),
+      e.name,
+      { kind: "circumcenter", vertices: resolveTriangleVertices(ctx, e.vertices) }
+    )
+  }]
+});
+var incenterModule = defineModule({
+  kind: "incenter",
+  role: "point",
+  category: "points",
+  prefix: "p",
+  schema: z.object({
+    name: NameZ,
+    kind: z.literal("incenter"),
+    vertices: z.tuple([NameZ, NameZ, NameZ])
+  }),
+  collectRefs: (e) => [...e.vertices],
+  emit: (e, ctx) => [{
+    role: "primary",
+    object: emitPointObject(
+      ctx.resolveId(e.name),
+      e.name,
+      { kind: "incenter", vertices: resolveTriangleVertices(ctx, e.vertices) }
+    )
+  }]
+});
+var centroidModule = defineModule({
+  kind: "centroid",
+  role: "point",
+  category: "points",
+  prefix: "p",
+  schema: z.object({
+    name: NameZ,
+    kind: z.literal("centroid"),
+    vertices: z.tuple([NameZ, NameZ, NameZ])
+  }),
+  collectRefs: (e) => [...e.vertices],
+  emit: (e, ctx) => [{
+    role: "primary",
+    object: emitPointObject(
+      ctx.resolveId(e.name),
+      e.name,
+      { kind: "centroid", vertices: resolveTriangleVertices(ctx, e.vertices) }
+    )
+  }]
+});
+var orthocenterModule = defineModule({
+  kind: "orthocenter",
+  role: "point",
+  category: "points",
+  prefix: "p",
+  schema: z.object({
+    name: NameZ,
+    kind: z.literal("orthocenter"),
+    vertices: z.tuple([NameZ, NameZ, NameZ])
+  }),
+  collectRefs: (e) => [...e.vertices],
+  emit: (e, ctx) => [{
+    role: "primary",
+    object: emitPointObject(
+      ctx.resolveId(e.name),
+      e.name,
+      { kind: "orthocenter", vertices: resolveTriangleVertices(ctx, e.vertices) }
+    )
+  }]
+});
+var intersectionModule = defineModule({
+  kind: "intersection",
+  role: "point",
+  category: "points",
+  prefix: "i",
+  schema: z.object({
+    name: NameZ,
+    kind: z.literal("intersection"),
+    ref1: NameZ,
+    ref2: NameZ,
+    branch: z.union([z.literal(0), z.literal(1)]).optional()
+  }),
+  collectRefs: (e) => [e.ref1, e.ref2],
+  emit: (e, ctx) => {
+    const r1IsCircle = ctx.hintOf(e.ref1) === "circle";
+    const r2IsCircle = ctx.hintOf(e.ref2) === "circle";
+    let intersectKind;
+    if (r1IsCircle && r2IsCircle) intersectKind = "circleCircle";
+    else if (r1IsCircle || r2IsCircle) intersectKind = "lineCircle";
+    else intersectKind = "lineLine";
+    const attrs = {
+      kind: intersectKind,
+      ref1: ctx.resolveId(e.ref1),
+      ref2: ctx.resolveId(e.ref2)
+    };
+    if (intersectKind !== "lineLine") {
+      attrs.branch = e.branch ?? 0;
+    }
+    return [{
+      role: "primary",
+      object: {
+        id: ctx.resolveId(e.name),
+        kind: "intersection",
+        label: e.name,
+        ...POINT_BASE_FIELDS,
+        attrs
+      }
+    }];
+  }
+});
+var segmentModule = defineModule({
+  kind: "segment",
+  role: "segment",
+  category: "lines",
+  prefix: "s",
+  schema: z.object({
+    name: NameZ,
+    kind: z.literal("segment"),
+    p1: NameZ,
+    p2: NameZ
+  }),
+  collectRefs: (e) => [e.p1, e.p2],
+  emit: (e, ctx) => [{
+    role: "primary",
+    object: {
+      id: ctx.resolveId(e.name),
+      kind: "segment",
+      label: e.name,
+      ...SHAPE_BASE_FIELDS,
+      attrs: { p1: ctx.resolveId(e.p1), p2: ctx.resolveId(e.p2) }
+    }
+  }]
+});
+var lineModule = defineModule({
+  kind: "line",
+  role: "line",
+  category: "lines",
+  prefix: "l",
+  schema: z.object({
+    name: NameZ,
+    kind: z.literal("line"),
+    p1: NameZ,
+    p2: NameZ
+  }),
+  collectRefs: (e) => [e.p1, e.p2],
+  emit: (e, ctx) => [{
+    role: "primary",
+    object: {
+      id: ctx.resolveId(e.name),
+      kind: "line",
+      label: e.name,
+      ...SHAPE_BASE_FIELDS,
+      attrs: { p1: ctx.resolveId(e.p1), p2: ctx.resolveId(e.p2) }
+    }
+  }]
+});
+var rayModule = defineModule({
+  kind: "ray",
+  role: "ray",
+  category: "lines",
+  prefix: "r",
+  schema: z.object({
+    name: NameZ,
+    kind: z.literal("ray"),
+    origin: NameZ,
+    through: NameZ
+  }),
+  collectRefs: (e) => [e.origin, e.through],
+  emit: (e, ctx) => [{
+    role: "primary",
+    object: {
+      id: ctx.resolveId(e.name),
+      kind: "ray",
+      label: e.name,
+      ...SHAPE_BASE_FIELDS,
+      attrs: { origin: ctx.resolveId(e.origin), through: ctx.resolveId(e.through) }
+    }
+  }]
+});
+var perpendicularModule = defineModule({
+  kind: "perpendicular",
+  role: "lineConstruction",
+  category: "lines",
+  prefix: "l",
+  schema: z.object({
+    name: NameZ,
+    kind: z.literal("perpendicular"),
+    throughPoint: NameZ,
+    toLine: NameZ
+  }),
+  collectRefs: (e) => [e.throughPoint, e.toLine],
+  emit: (e, ctx) => [{
+    role: "primary",
+    object: {
+      id: ctx.resolveId(e.name),
+      kind: "line",
+      label: e.name,
+      ...SHAPE_BASE_FIELDS,
+      attrs: {
+        construction: {
+          kind: "perpendicular",
+          throughPoint: ctx.resolveId(e.throughPoint),
+          toLine: ctx.resolveId(e.toLine)
+        }
+      }
+    }
+  }]
+});
+var parallelModule = defineModule({
+  kind: "parallel",
+  role: "lineConstruction",
+  category: "lines",
+  prefix: "l",
+  schema: z.object({
+    name: NameZ,
+    kind: z.literal("parallel"),
+    throughPoint: NameZ,
+    toLine: NameZ
+  }),
+  collectRefs: (e) => [e.throughPoint, e.toLine],
+  emit: (e, ctx) => [{
+    role: "primary",
+    object: {
+      id: ctx.resolveId(e.name),
+      kind: "line",
+      label: e.name,
+      ...SHAPE_BASE_FIELDS,
+      attrs: {
+        construction: {
+          kind: "parallel",
+          throughPoint: ctx.resolveId(e.throughPoint),
+          toLine: ctx.resolveId(e.toLine)
+        }
+      }
+    }
+  }]
+});
+var perpBisectorModule = defineModule({
+  kind: "perpBisector",
+  role: "lineConstruction",
+  category: "lines",
+  prefix: "l",
+  schema: z.object({
+    name: NameZ,
+    kind: z.literal("perpBisector"),
+    p1: NameZ,
+    p2: NameZ
+  }),
+  collectRefs: (e) => [e.p1, e.p2],
+  emit: (e, ctx) => [{
+    role: "primary",
+    object: {
+      id: ctx.resolveId(e.name),
+      kind: "line",
+      label: e.name,
+      ...SHAPE_BASE_FIELDS,
+      attrs: {
+        construction: {
+          kind: "perpBisector",
+          p1: ctx.resolveId(e.p1),
+          p2: ctx.resolveId(e.p2)
+        }
+      }
+    }
+  }]
+});
+var angleBisectorModule = defineModule({
+  kind: "angleBisector",
+  role: "lineConstruction",
+  category: "lines",
+  prefix: "l",
+  schema: z.object({
+    name: NameZ,
+    kind: z.literal("angleBisector"),
+    p1: NameZ,
+    vertex: NameZ,
+    p2: NameZ
+  }),
+  collectRefs: (e) => [e.p1, e.vertex, e.p2],
+  emit: (e, ctx) => [{
+    role: "primary",
+    object: {
+      id: ctx.resolveId(e.name),
+      kind: "line",
+      label: e.name,
+      ...SHAPE_BASE_FIELDS,
+      attrs: {
+        construction: {
+          kind: "angleBisector",
+          p1: ctx.resolveId(e.p1),
+          vertex: ctx.resolveId(e.vertex),
+          p2: ctx.resolveId(e.p2)
+        }
+      }
+    }
+  }]
+});
+var 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",
+  category: "lines",
+  prefix: "l",
+  schema: z.object({
+    name: NameZ,
+    kind: z.literal("tangent"),
+    throughPoint: NameZ,
+    toCircle: NameZ,
+    branch: z.union([z.literal(0), z.literal(1), z.literal("on")]).optional()
+  }),
+  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: z.object({
+    name: NameZ,
+    kind: z.literal("polygon"),
+    vertices: 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: z.object({
+    name: NameZ,
+    kind: z.literal("circleCP"),
+    center: NameZ,
+    surfacePoint: NameZ,
+    visible: z.boolean().optional()
+  }),
+  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,
+      visible: e.visible ?? true,
+      attrs: { center: ctx.resolveId(e.center), surfacePoint: ctx.resolveId(e.surfacePoint) }
+    }
+  }]
+});
+var circle3Module = defineModule({
+  kind: "circle3",
+  role: "circle",
+  category: "circles",
+  prefix: "c",
+  schema: z.object({
+    name: NameZ,
+    kind: z.literal("circle3"),
+    p1: NameZ,
+    p2: NameZ,
+    p3: NameZ
+  }),
+  collectRefs: (e) => [e.p1, e.p2, e.p3],
+  emit: (e, ctx) => [{
+    role: "primary",
+    object: {
+      id: ctx.resolveId(e.name),
+      kind: "circle",
+      label: e.name,
+      ...SHAPE_BASE_FIELDS,
+      attrs: {
+        construction: {
+          kind: "circumscribed",
+          p1: ctx.resolveId(e.p1),
+          p2: ctx.resolveId(e.p2),
+          p3: ctx.resolveId(e.p3)
+        }
+      }
+    }
+  }]
+});
+var 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 = [
+  freeModule,
+  midpointModule,
+  onSegmentModule,
+  onLineModule,
+  onCircleModule,
+  perpFootModule,
+  circumcenterModule,
+  incenterModule,
+  centroidModule,
+  orthocenterModule,
+  intersectionModule,
+  // NEW Tier 4+5 points
+  secondIntersectionModule,
+  circleIntersectionModule,
+  circleSecondIntersectionModule,
+  tangencyPointModule,
+  tangentPointExtModule,
+  segmentModule,
+  lineModule,
+  rayModule,
+  perpendicularModule,
+  parallelModule,
+  perpBisectorModule,
+  angleBisectorModule,
+  lineThroughModule,
+  radicalAxisModule,
+  tangentModule,
+  polygonModule,
+  circleCPModule,
+  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(
+  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)
+);
+z.discriminatedUnion(
+  "kind",
+  ALL_MODULES.map((m) => m.schema)
+);
+
+// src/stamps/geometry-2d/dsl/serialize.ts
+var NAME_REGEX = /^[A-Za-z][A-Za-z0-9_'₀-₉]{0,11}$/;
+function isValidName(s) {
+  return NAME_REGEX.test(s);
+}
+function labelOf(id, state) {
+  const obj = state.objects[id];
+  return obj ? obj.label : null;
+}
+function resolveRefs(ids, state) {
+  const out = [];
+  for (const id of ids) {
+    const lab = labelOf(id, state);
+    if (lab == null || !isValidName(lab)) return null;
+    out.push(lab);
+  }
+  return out;
+}
+function fail(reason, detail) {
+  return { ok: false, reason, detail };
+}
+function serializePoint(obj, state) {
+  const c = obj.attrs?.constraint;
+  if (!c) return fail("unsupported-constraint", "missing");
+  switch (c.kind) {
+    case "free":
+      return { ok: true, entity: { name: obj.label, kind: "free", x: c.x, y: c.y } };
+    case "midpoint": {
+      const refs = resolveRefs([c.p1, c.p2], state);
+      if (!refs) return fail("unresolved-ref", `${c.p1},${c.p2}`);
+      return { ok: true, entity: { name: obj.label, kind: "midpoint", p1: refs[0], p2: refs[1] } };
+    }
+    case "onSegment": {
+      const refs = resolveRefs([c.segmentId], state);
+      if (!refs) return fail("unresolved-ref", c.segmentId);
+      return { ok: true, entity: { name: obj.label, kind: "onSegment", segmentId: refs[0], t: c.t } };
+    }
+    case "onLine": {
+      const refs = resolveRefs([c.lineId], state);
+      if (!refs) return fail("unresolved-ref", c.lineId);
+      return { ok: true, entity: { name: obj.label, kind: "onLine", lineId: refs[0], t: c.t } };
+    }
+    case "onCircle": {
+      const refs = resolveRefs([c.circleId], state);
+      if (!refs) return fail("unresolved-ref", c.circleId);
+      return { ok: true, entity: { name: obj.label, kind: "onCircle", circleId: refs[0], theta: c.theta } };
+    }
+    case "perpFoot": {
+      const refs = resolveRefs([c.from, c.onLine], state);
+      if (!refs) return fail("unresolved-ref", `${c.from},${c.onLine}`);
+      return { ok: true, entity: { name: obj.label, kind: "perpFoot", from: refs[0], onLine: refs[1] } };
+    }
+    case "circumcenter":
+    case "incenter":
+    case "centroid":
+    case "orthocenter": {
+      const refs = resolveRefs(c.vertices, state);
+      if (!refs || refs.length !== 3) return fail("unresolved-ref", c.vertices.join(","));
+      return {
+        ok: true,
+        entity: {
+          name: obj.label,
+          kind: c.kind,
+          vertices: [refs[0], refs[1], refs[2]]
+        }
+      };
+    }
+    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");
+    }
+  }
+}
+function serializeIntersection(obj, state) {
+  const a = obj.attrs;
+  const refs = resolveRefs([a.ref1, a.ref2], state);
+  if (!refs) return fail("unresolved-ref", `${a.ref1},${a.ref2}`);
+  if (a.kind === "lineLine") {
+    return { ok: true, entity: { name: obj.label, kind: "intersection", ref1: refs[0], ref2: refs[1] } };
+  }
+  return {
+    ok: true,
+    entity: {
+      name: obj.label,
+      kind: "intersection",
+      ref1: refs[0],
+      ref2: refs[1],
+      branch: a.branch
+    }
+  };
+}
+function serializeSegment(obj, state) {
+  const refs = resolveRefs([obj.attrs.p1, obj.attrs.p2], state);
+  if (!refs) return fail("unresolved-ref", `${obj.attrs.p1},${obj.attrs.p2}`);
+  return { ok: true, entity: { name: obj.label, kind: "segment", p1: refs[0], p2: refs[1] } };
+}
+function serializeRay(obj, state) {
+  const refs = resolveRefs([obj.attrs.origin, obj.attrs.through], state);
+  if (!refs) return fail("unresolved-ref", `${obj.attrs.origin},${obj.attrs.through}`);
+  return { ok: true, entity: { name: obj.label, kind: "ray", origin: refs[0], through: refs[1] } };
+}
+function serializeLine(obj, state) {
+  const a = obj.attrs;
+  const c = a.construction;
+  if (!c) {
+    if (!a.p1 || !a.p2) return fail("unsupported-construction", "missing p1/p2");
+    const refs = resolveRefs([a.p1, a.p2], state);
+    if (!refs) return fail("unresolved-ref", `${a.p1},${a.p2}`);
+    return { ok: true, entity: { name: obj.label, kind: "line", p1: refs[0], p2: refs[1] } };
+  }
+  switch (c.kind) {
+    case "perpendicular":
+    case "parallel": {
+      const refs = resolveRefs([c.throughPoint, c.toLine], state);
+      if (!refs) return fail("unresolved-ref", `${c.throughPoint},${c.toLine}`);
+      return {
+        ok: true,
+        entity: { name: obj.label, kind: c.kind, throughPoint: refs[0], toLine: refs[1] }
+      };
+    }
+    case "perpBisector": {
+      const refs = resolveRefs([c.p1, c.p2], state);
+      if (!refs) return fail("unresolved-ref", `${c.p1},${c.p2}`);
+      return { ok: true, entity: { name: obj.label, kind: "perpBisector", p1: refs[0], p2: refs[1] } };
+    }
+    case "angleBisector": {
+      const refs = resolveRefs([c.p1, c.vertex, c.p2], state);
+      if (!refs) return fail("unresolved-ref", `${c.p1},${c.vertex},${c.p2}`);
+      return {
+        ok: true,
+        entity: {
+          name: obj.label,
+          kind: "angleBisector",
+          p1: refs[0],
+          vertex: refs[1],
+          p2: refs[2]
+        }
+      };
+    }
+    case "tangent": {
+      const refs = resolveRefs([c.throughPoint, c.toCircle], state);
+      if (!refs) return fail("unresolved-ref", `${c.throughPoint},${c.toCircle}`);
+      const entity = c.branch !== void 0 ? {
+        name: obj.label,
+        kind: "tangent",
+        throughPoint: refs[0],
+        toCircle: refs[1],
+        branch: c.branch
+      } : { name: obj.label, kind: "tangent", throughPoint: refs[0], toCircle: refs[1] };
+      return { ok: true, entity };
+    }
+    case "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: {
+      return fail("unsupported-construction");
+    }
+  }
+}
+function serializePolygon(obj, state) {
+  const a = obj.attrs;
+  if (a.construction) return fail("unsupported-construction", a.construction.kind);
+  if (!Array.isArray(a.vertices) || a.vertices.length < 3) {
+    return fail("unsupported-construction", "missing vertices");
+  }
+  const refs = resolveRefs(a.vertices, state);
+  if (!refs) return fail("unresolved-ref", a.vertices.join(","));
+  return { ok: true, entity: { name: obj.label, kind: "polygon", vertices: refs } };
+}
+function serializeCircle(obj, state) {
+  const a = obj.attrs;
+  const c = (() => {
+    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");
+    }
+    const refs = resolveRefs([a.center, a.surfacePoint], state);
+    if (!refs) return fail("unresolved-ref", `${a.center},${a.surfacePoint}`);
+    return {
+      ok: true,
+      entity: { name: obj.label, kind: "circleCP", center: refs[0], surfacePoint: refs[1] }
+    };
+  }
+  if (c.kind === "circumscribed") {
+    const refs = resolveRefs([c.p1, c.p2, c.p3], state);
+    if (!refs) return fail("unresolved-ref", `${c.p1},${c.p2},${c.p3}`);
+    return {
+      ok: true,
+      entity: { name: obj.label, kind: "circle3", p1: refs[0], p2: refs[1], p3: refs[2] }
+    };
+  }
+  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) {
+  if (!isValidName(obj.label)) {
+    return fail("invalid-label", obj.label);
+  }
+  switch (obj.kind) {
+    case "point":
+      return serializePoint(obj, state);
+    case "segment":
+      return serializeSegment(obj, state);
+    case "ray":
+      return serializeRay(obj, state);
+    case "line":
+      return serializeLine(obj, state);
+    case "polygon":
+      return serializePolygon(obj, state);
+    case "circle":
+      return serializeCircle(obj, state);
+    case "intersection":
+      return serializeIntersection(obj, state);
+    default:
+      return fail("unsupported-kind", obj.kind);
+  }
+}
+function serializeState(state) {
+  const points = [];
+  const shapes = [];
+  const unsupported = [];
+  for (const id of state.order) {
+    const obj = state.objects[id];
+    if (!obj) continue;
+    const r = serializeObject(obj, state);
+    if (!r.ok) {
+      unsupported.push({
+        id: obj.id,
+        label: obj.label,
+        kind: obj.kind,
+        reason: r.reason,
+        detail: r.detail
+      });
+      continue;
+    }
+    if (POINT_KINDS.has(r.entity.kind)) {
+      points.push(r.entity);
+    } else {
+      shapes.push(r.entity);
+    }
+  }
+  return {
+    dsl: { version: 1, points, shapes },
+    unsupported
+  };
+}
+
+// src/stamps/geometry-2d/dsl/describeDsl.ts
+function describeEntity(e) {
+  switch (e.kind) {
+    case "free":
+      return `${e.name} = (${e.x}, ${e.y})`;
+    case "midpoint":
+      return `${e.name} = trung \u0111i\u1EC3m ${e.p1}${e.p2}`;
+    case "onSegment":
+      return `${e.name} \u2208 \u0111o\u1EA1n ${e.segmentId} (t = ${e.t})`;
+    case "onLine":
+      return `${e.name} \u2208 \u0111\u01B0\u1EDDng ${e.lineId} (t = ${e.t})`;
+    case "onCircle":
+      return `${e.name} \u2208 \u0111\u01B0\u1EDDng tr\xF2n ${e.circleId} (\u03B8 = ${e.theta})`;
+    case "perpFoot":
+      return `${e.name} = ch\xE2n vu\xF4ng g\xF3c t\u1EEB ${e.from} xu\u1ED1ng ${e.onLine}`;
+    case "circumcenter":
+      return `${e.name} = t\xE2m ngo\u1EA1i ti\u1EBFp ${e.vertices.join("")}`;
+    case "incenter":
+      return `${e.name} = t\xE2m n\u1ED9i ti\u1EBFp ${e.vertices.join("")}`;
+    case "centroid":
+      return `${e.name} = tr\u1ECDng t\xE2m ${e.vertices.join("")}`;
+    case "orthocenter":
+      return `${e.name} = tr\u1EF1c t\xE2m ${e.vertices.join("")}`;
+    case "intersection": {
+      const branch = "branch" in e && e.branch !== void 0 ? ` (nh\xE1nh ${e.branch})` : "";
+      return `${e.name} = ${e.ref1} \u2229 ${e.ref2}${branch}`;
+    }
+    case "segment":
+      return `${e.name} = \u0111o\u1EA1n ${e.p1}${e.p2}`;
+    case "line":
+      return `${e.name} = \u0111\u01B0\u1EDDng th\u1EB3ng ${e.p1}${e.p2}`;
+    case "ray":
+      return `${e.name} = tia ${e.origin}${e.through}`;
+    case "polygon":
+      return `${e.name} = \u0111a gi\xE1c ${e.vertices.join("")}`;
+    case "perpendicular":
+      return `${e.name} \u27C2 ${e.toLine} qua ${e.throughPoint}`;
+    case "parallel":
+      return `${e.name} \u2225 ${e.toLine} qua ${e.throughPoint}`;
+    case "perpBisector":
+      return `${e.name} = trung tr\u1EF1c ${e.p1}${e.p2}`;
+    case "angleBisector":
+      return `${e.name} = ph\xE2n gi\xE1c \u2220${e.p1}${e.vertex}${e.p2}`;
+    case "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}`;
+    }
+    case "circleCP":
+      return `${e.name} = (${e.center}; ${e.center}${e.surfacePoint})`;
+    case "circle3":
+      return `${e.name} = \u0111\u01B0\u1EDDng tr\xF2n qua ${e.p1}${e.p2}${e.p3}`;
+    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 "";
+    }
+  }
+}
+function describeDsl(obj, state) {
+  const r = serializeObject(obj, state);
+  if (r.ok) return describeEntity(r.entity);
+  let base;
+  try {
+    base = getKind(obj.kind).describe(obj, state);
+  } catch {
+    base = `${obj.kind} ${obj.label}`;
+  }
+  return `${base} (kh\xF4ng h\u1ED7 tr\u1EE3 DSL)`;
+}
+
+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