@xom11/whiteboard 0.24.1 → 0.25.0

package/dist/chunk-VNCCIV6O.mjs

@@ -0,0 +1,938 @@
+"use client";
+import { getKind } from './chunk-B4NJJZFR.mjs';
+import { z } from 'zod';
+
+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) {
+  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: 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
+  }),
+  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: 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 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
+  }),
+  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: 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)
+        }
+      }
+    }
+  }]
+});
+
+// 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)
+);
+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]]
+        }
+      };
+    }
+    // Out of DSL v1:
+    case "onAxis":
+    case "onPolygon":
+    case "transformed":
+      return fail("unsupported-constraint", c.kind);
+    default: {
+      return fail("unsupported-constraint");
+    }
+  }
+}
+function serializeIntersection(obj, state) {
+  const a = obj.attrs;
+  const refs = resolveRefs([a.ref1, a.ref2], state);
+  if (!refs) return fail("unresolved-ref", `${a.ref1},${a.ref2}`);
+  if (a.kind === "lineLine") {
+    return { ok: true, entity: { name: obj.label, kind: "intersection", ref1: refs[0], ref2: refs[1] } };
+  }
+  return {
+    ok: true,
+    entity: {
+      name: obj.label,
+      kind: "intersection",
+      ref1: refs[0],
+      ref2: refs[1],
+      branch: a.branch
+    }
+  };
+}
+function serializeSegment(obj, state) {
+  const refs = resolveRefs([obj.attrs.p1, obj.attrs.p2], state);
+  if (!refs) return fail("unresolved-ref", `${obj.attrs.p1},${obj.attrs.p2}`);
+  return { ok: true, entity: { name: obj.label, kind: "segment", p1: refs[0], p2: refs[1] } };
+}
+function serializeRay(obj, state) {
+  const refs = resolveRefs([obj.attrs.origin, obj.attrs.through], state);
+  if (!refs) return fail("unresolved-ref", `${obj.attrs.origin},${obj.attrs.through}`);
+  return { ok: true, entity: { name: obj.label, kind: "ray", origin: refs[0], through: refs[1] } };
+}
+function serializeLine(obj, state) {
+  const a = obj.attrs;
+  const c = a.construction;
+  if (!c) {
+    if (!a.p1 || !a.p2) return fail("unsupported-construction", "missing p1/p2");
+    const refs = resolveRefs([a.p1, a.p2], state);
+    if (!refs) return fail("unresolved-ref", `${a.p1},${a.p2}`);
+    return { ok: true, entity: { name: obj.label, kind: "line", p1: refs[0], p2: refs[1] } };
+  }
+  switch (c.kind) {
+    case "perpendicular":
+    case "parallel": {
+      const refs = resolveRefs([c.throughPoint, c.toLine], state);
+      if (!refs) return fail("unresolved-ref", `${c.throughPoint},${c.toLine}`);
+      return {
+        ok: true,
+        entity: { name: obj.label, kind: c.kind, throughPoint: refs[0], toLine: refs[1] }
+      };
+    }
+    case "perpBisector": {
+      const refs = resolveRefs([c.p1, c.p2], state);
+      if (!refs) return fail("unresolved-ref", `${c.p1},${c.p2}`);
+      return { ok: true, entity: { name: obj.label, kind: "perpBisector", p1: refs[0], p2: refs[1] } };
+    }
+    case "angleBisector": {
+      const refs = resolveRefs([c.p1, c.vertex, c.p2], state);
+      if (!refs) return fail("unresolved-ref", `${c.p1},${c.vertex},${c.p2}`);
+      return {
+        ok: true,
+        entity: {
+          name: obj.label,
+          kind: "angleBisector",
+          p1: refs[0],
+          vertex: refs[1],
+          p2: refs[2]
+        }
+      };
+    }
+    case "tangent": {
+      const refs = resolveRefs([c.throughPoint, c.toCircle], state);
+      if (!refs) return fail("unresolved-ref", `${c.throughPoint},${c.toCircle}`);
+      const entity = c.branch !== void 0 ? {
+        name: obj.label,
+        kind: "tangent",
+        throughPoint: refs[0],
+        toCircle: refs[1],
+        branch: c.branch
+      } : { name: obj.label, kind: "tangent", throughPoint: refs[0], toCircle: refs[1] };
+      return { ok: true, entity };
+    }
+    case "angleBisectorLines":
+      return fail("unsupported-construction", "angleBisectorLines");
+    default: {
+      return fail("unsupported-construction");
+    }
+  }
+}
+function serializePolygon(obj, state) {
+  const a = obj.attrs;
+  if (a.construction) return fail("unsupported-construction", a.construction.kind);
+  if (!Array.isArray(a.vertices) || a.vertices.length < 3) {
+    return fail("unsupported-construction", "missing vertices");
+  }
+  const refs = resolveRefs(a.vertices, state);
+  if (!refs) return fail("unresolved-ref", a.vertices.join(","));
+  return { ok: true, entity: { name: obj.label, kind: "polygon", vertices: refs } };
+}
+function serializeCircle(obj, state) {
+  const a = obj.attrs;
+  const c = a.construction;
+  if (!c) {
+    if (!a.center || !a.surfacePoint) {
+      return fail("unsupported-construction", "missing center/surfacePoint");
+    }
+    const refs = resolveRefs([a.center, a.surfacePoint], state);
+    if (!refs) return fail("unresolved-ref", `${a.center},${a.surfacePoint}`);
+    return {
+      ok: true,
+      entity: { name: obj.label, kind: "circleCP", center: refs[0], surfacePoint: refs[1] }
+    };
+  }
+  if (c.kind === "circumscribed") {
+    const refs = resolveRefs([c.p1, c.p2, c.p3], state);
+    if (!refs) return fail("unresolved-ref", `${c.p1},${c.p2},${c.p3}`);
+    return {
+      ok: true,
+      entity: { name: obj.label, kind: "circle3", p1: refs[0], p2: refs[1], p3: refs[2] }
+    };
+  }
+  return fail("unsupported-construction");
+}
+function serializeObject(obj, state) {
+  if (!isValidName(obj.label)) {
+    return fail("invalid-label", obj.label);
+  }
+  switch (obj.kind) {
+    case "point":
+      return serializePoint(obj, state);
+    case "segment":
+      return serializeSegment(obj, state);
+    case "ray":
+      return serializeRay(obj, state);
+    case "line":
+      return serializeLine(obj, state);
+    case "polygon":
+      return serializePolygon(obj, state);
+    case "circle":
+      return serializeCircle(obj, state);
+    case "intersection":
+      return serializeIntersection(obj, state);
+    default:
+      return fail("unsupported-kind", obj.kind);
+  }
+}
+function serializeState(state) {
+  const points = [];
+  const shapes = [];
+  const unsupported = [];
+  for (const id of state.order) {
+    const obj = state.objects[id];
+    if (!obj) continue;
+    const r = serializeObject(obj, state);
+    if (!r.ok) {
+      unsupported.push({
+        id: obj.id,
+        label: obj.label,
+        kind: obj.kind,
+        reason: r.reason,
+        detail: r.detail
+      });
+      continue;
+    }
+    if (POINT_KINDS.has(r.entity.kind)) {
+      points.push(r.entity);
+    } else {
+      shapes.push(r.entity);
+    }
+  }
+  return {
+    dsl: { version: 1, points, shapes },
+    unsupported
+  };
+}
+
+// src/stamps/geometry-2d/dsl/describeDsl.ts
+function describeEntity(e) {
+  switch (e.kind) {
+    case "free":
+      return `${e.name} = (${e.x}, ${e.y})`;
+    case "midpoint":
+      return `${e.name} = trung \u0111i\u1EC3m ${e.p1}${e.p2}`;
+    case "onSegment":
+      return `${e.name} \u2208 \u0111o\u1EA1n ${e.segmentId} (t = ${e.t})`;
+    case "onLine":
+      return `${e.name} \u2208 \u0111\u01B0\u1EDDng ${e.lineId} (t = ${e.t})`;
+    case "onCircle":
+      return `${e.name} \u2208 \u0111\u01B0\u1EDDng tr\xF2n ${e.circleId} (\u03B8 = ${e.theta})`;
+    case "perpFoot":
+      return `${e.name} = ch\xE2n vu\xF4ng g\xF3c t\u1EEB ${e.from} xu\u1ED1ng ${e.onLine}`;
+    case "circumcenter":
+      return `${e.name} = t\xE2m ngo\u1EA1i ti\u1EBFp ${e.vertices.join("")}`;
+    case "incenter":
+      return `${e.name} = t\xE2m n\u1ED9i ti\u1EBFp ${e.vertices.join("")}`;
+    case "centroid":
+      return `${e.name} = tr\u1ECDng t\xE2m ${e.vertices.join("")}`;
+    case "orthocenter":
+      return `${e.name} = tr\u1EF1c t\xE2m ${e.vertices.join("")}`;
+    case "intersection": {
+      const branch = "branch" in e && e.branch !== void 0 ? ` (nh\xE1nh ${e.branch})` : "";
+      return `${e.name} = ${e.ref1} \u2229 ${e.ref2}${branch}`;
+    }
+    case "segment":
+      return `${e.name} = \u0111o\u1EA1n ${e.p1}${e.p2}`;
+    case "line":
+      return `${e.name} = \u0111\u01B0\u1EDDng th\u1EB3ng ${e.p1}${e.p2}`;
+    case "ray":
+      return `${e.name} = tia ${e.origin}${e.through}`;
+    case "polygon":
+      return `${e.name} = \u0111a gi\xE1c ${e.vertices.join("")}`;
+    case "perpendicular":
+      return `${e.name} \u27C2 ${e.toLine} qua ${e.throughPoint}`;
+    case "parallel":
+      return `${e.name} \u2225 ${e.toLine} qua ${e.throughPoint}`;
+    case "perpBisector":
+      return `${e.name} = trung tr\u1EF1c ${e.p1}${e.p2}`;
+    case "angleBisector":
+      return `${e.name} = ph\xE2n gi\xE1c \u2220${e.p1}${e.vertex}${e.p2}`;
+    case "tangent": {
+      const branch = "branch" in e && e.branch !== void 0 ? ` (nh\xE1nh ${e.branch})` : "";
+      return `${e.name} = ti\u1EBFp tuy\u1EBFn ${e.toCircle} qua ${e.throughPoint}${branch}`;
+    }
+    case "circleCP":
+      return `${e.name} = (${e.center}; ${e.center}${e.surfacePoint})`;
+    case "circle3":
+      return `${e.name} = \u0111\u01B0\u1EDDng tr\xF2n qua ${e.p1}${e.p2}${e.p3}`;
+    default: {
+      return "";
+    }
+  }
+}
+function describeDsl(obj, state) {
+  const r = serializeObject(obj, state);
+  if (r.ok) return describeEntity(r.entity);
+  let base;
+  try {
+    base = getKind(obj.kind).describe(obj, state);
+  } catch {
+    base = `${obj.kind} ${obj.label}`;
+  }
+  return `${base} (kh\xF4ng h\u1ED7 tr\u1EE3 DSL)`;
+}
+
+export { CIRCLE_KINDS, KIND_REGISTRY, LINE_LIKE_SHAPE_KINDS, POINT_KINDS, describeDsl, serializeState };
+//# sourceMappingURL=chunk-VNCCIV6O.mjs.map
+//# sourceMappingURL=chunk-VNCCIV6O.mjs.map