@xom11/whiteboard 0.31.0 → 0.33.0

package/dist/ai.js

@@ -15,6 +15,11 @@ var GEOMETRY_KEYWORDS = [
   "h\xECnh thoi",
   "h\xECnh thang",
   "t\u1EE9 gi\xE1c",
+  // Đa giác ≥5 đỉnh: "Cho lục giác ABCDEF …" — thiếu các từ này thì clause chỉ
+  // có tên đa giác (không "ngoại/nội tiếp") bị coi văn xuôi → hexagonRule miss.
+  "ng\u0169 gi\xE1c",
+  "l\u1EE5c gi\xE1c",
+  "\u0111a gi\xE1c",
   // Triangle variants
   "vu\xF4ng t\u1EA1i",
   "c\xE2n t\u1EA1i",
@@ -96,6 +101,13 @@ var GEOMETRY_KEYWORDS = [
   "c\u1EAFt",
   "\u0111\u01B0\u1EDDng th\u1EB3ng",
   "\u0111\u01B0\u01A1ng th\u1EB3ng",
+  // "thẳng hàng" — "Cho 3 điểm A, B, C thẳng hàng theo thứ tự" (C41): clause GIỚI
+  // THIỆU bộ điểm thẳng hàng (collinearPointsRule dựng A,B,C) NHƯNG không có keyword
+  // nào khác → hasGeometry=false → clause bị lọc khỏi rule engine → A,B,C KHÔNG dựng
+  // → cascade làm sụp tiếp tuyến/trung điểm phụ thuộc chúng. "thẳng hàng" (≥8 ký tự,
+  // phân biệt) đánh dấu geo-clause. Clause CHỨNG MINH ("Chứng minh A,B,C thẳng hàng")
+  // vẫn non-geo nhờ guard proofOnly (startsProofSection) — không bị ảnh hưởng.
+  "th\u1EB3ng h\xE0ng",
   // Ký hiệu (symbol-only phrasing tương đương từ chữ): "⊥" ≡ "vuông góc".
   // perpFoot rule đã nhận "⊥" ở tầng construct (PERP_DRAW), nhưng gate
   // hasGeometry trước đây CHỈ nhận chữ "vuông góc" → clause mà "⊥" là tín hiệu
@@ -211,17 +223,18 @@ function countGeometryKeywords(text) {
 var MASK_SEMI = "
";
 var MASK_DOT = "";
 var MASK_COMMA = "";
+var MASK_SEMI_LIST = "";
 function maskNonBoundaryPunct(s) {
   return s.replace(
     /\(([^()\n]{1,40})\)/g,
     (m) => m.replace(/;/g, MASK_SEMI).replace(/\./g, MASK_DOT).replace(/,/g, MASK_COMMA)
   ).replace(
-    /;(?=\s*[A-Z][A-Z]?['′]?\d?\s*(?:[;,]|cắt nhau|đồng quy))/gu,
-    MASK_SEMI
-  );
+    /;(?=\s*[A-Z][A-Z]?['′]?\d?\s*(?:[;,]|lần lượt|cắt nhau|đồng quy|đôi một))/gu,
+    MASK_SEMI_LIST
+  ).replace(/;(?=\s*[A-Z][A-Z]?['′]?\d?\s*(?:[;,.]|$))/gu, MASK_SEMI_LIST);
 }
 function unmask(s) {
-  return s.replace(/\u0001/g, ";").replace(/\u0002/g, ".").replace(/\u0003/g, ",");
+  return s.replace(/\u0001/g, ";").replace(/\u0002/g, ".").replace(/\u0003/g, ",").replace(/\u0004/g, ",");
 }
 function segmentClauses(problem) {
   let proofMode = false;
@@ -230,7 +243,7 @@ function segmentClauses(problem) {
     // giờ khớp trước space → split chết im lặng (bug class \b+tiếng Việt).
     /[.;\n]+|,\s*(?=(?:Gọi|Vẽ|Kẻ|Cho|Lấy|Dựng|trên|với|Let|Draw|Mark|Take|Construct|Join)(?!\p{L}))/u
   ).map((s) => unmask(s).trim()).filter((s) => s.length > 0).map((text, id) => {
-    const hasGeometryKeyword = countGeometryKeywords(text) > 0;
+    const hasGeometryKeyword = countGeometryKeywords(text) > 0 || NAMED_LINE_PICK.test(text) || BARE_SEG_PICK.test(text) && !/tia\s+đối/u.test(text);
     const proofOnly = isProofOnlyClause(text, proofMode);
     if (startsProofSection(text)) proofMode = true;
     const locusOnly = LOCUS_CLAUSE.test(text) && !CONSTRUCTION_LEAD.test(text);
@@ -239,6 +252,8 @@ function segmentClauses(problem) {
 }
 var ENUM_PREFIX = "(?:[0-9]+\\s*[.)]?\\s*|[a-zA-Z]\\s*[.)]\\s*)*";
 var LOCUS_CLAUSE = /(?:di\s*chuyển|di\s*động)\s+trên\s+(?:\(|đường\s*tròn|đương\s*tròn|cung|nửa)/u;
+var NAMED_LINE_PICK = /(?:[Tt]rên|[Tt]huộc)\s+(?:đường\s*thẳng\s+)?[a-z]{1,2}[0-9]?(?![\p{L}])\s+(?:[Ll]ấy|có)|[Ll]ấy\s+điểm\s+[A-Z]['′]?[0-9]?\s+(?:trên|thuộc)\s+(?:đường\s*thẳng\s+)?[a-z]{1,2}[0-9]?(?![\p{L}])/u;
+var BARE_SEG_PICK = /[Ll]ấy\s+(?:điểm\s+)?[A-Z]['′]?(?:\s*,\s*[A-Z]['′]?)?\s+(?:bất\s*k[iìyỳ]\s+)?(?:trên|thuộc)\s+(?:cạnh\s+|đoạn\s+|tia\s+)?[A-Z]{2}(?![A-Z])|[Tt]rên\s+(?:cạnh\s+|đoạn\s+|tia\s+)?[A-Z]{2}(?:\s*,\s*[A-Z]{2})*\s+(?:(?:theo\s+)?thứ\s+tự\s+|lần\s*lượt\s+)?lấy\s+(?:các\s+)?(?:điểm\s+)?[A-Z]/u;
 var PROOF_SECTION_START = new RegExp(
   `^${ENUM_PREFIX}(?:[Cc]h\u1EE9ng\\s*minh|C/m|CMR|[Tt]\xEDnh|[Tt]\xECm|[Xx]\xE1c\\s*\u0111\u1ECBnh|[Hh]\xE3y\\s+x\xE1c\\s*\u0111\u1ECBnh)(?!\\p{L})`,
   "u"
@@ -307,6 +322,9 @@ function pairFromToken(token) {
   return m ? [m[1], m[2]] : [];
 }
 var SIDE_PREFIX = "(?:c\u1EA1nh(?:\\s+huy\u1EC1n)?\\s+|\u0111o\u1EA1n(?:\\s+th\u1EB3ng)?\\s+|d\xE2y(?:\\s+cung)?\\s+)?";
+function escapeRe(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
 var DUONG_KW = "[\u0110\u0111]\u01B0[\u1EDD\u01A1]ng";
 var CIRCLE_KW = DUONG_KW + "\\s*tr\xF2n";
 
@@ -475,44 +493,44 @@ var QUAD = "([A-Z])([A-Z])([A-Z])([A-Z])(?![A-Z])";
 var KINDS = [
   // hình thang cân / vuông (modifier TRƯỚC đỉnh) — phải match trước thang chung
   {
-    name: new RegExp("h\xECnh\\s+thang\\s+c\xE2n\\s+" + QUAD, "gu"),
+    name: new RegExp("[Hh]\xECnh\\s+thang\\s+c\xE2n\\s+" + QUAD, "gu"),
     shape: "trapezoid",
     variant: "isoceles"
   },
   {
-    name: new RegExp("h\xECnh\\s+thang\\s+vu\xF4ng\\s+" + QUAD, "gu"),
+    name: new RegExp("[Hh]\xECnh\\s+thang\\s+vu\xF4ng\\s+" + QUAD, "gu"),
     shape: "trapezoid",
     variant: "right"
   },
   // hình thang chung — sau đó dò modifier 'vuông'/'cân' đứng SAU đỉnh
   // ("hình thang ABCD vuông tại A" → right; "...cân" → isoceles).
   {
-    name: new RegExp("h\xECnh\\s+thang\\s+" + QUAD, "gu"),
+    name: new RegExp("[Hh]\xECnh\\s+thang\\s+" + QUAD, "gu"),
     shape: "trapezoid",
     variant: "general"
   },
   {
-    name: new RegExp("h\xECnh\\s+vu\xF4ng\\s+" + QUAD, "gu"),
+    name: new RegExp("[Hh]\xECnh\\s+vu\xF4ng\\s+" + QUAD, "gu"),
     shape: "square",
     variant: "standard"
   },
   {
-    name: new RegExp("h\xECnh\\s+ch\u1EEF\\s+nh\u1EADt\\s+" + QUAD, "gu"),
+    name: new RegExp("[Hh]\xECnh\\s+ch\u1EEF\\s+nh\u1EADt\\s+" + QUAD, "gu"),
     shape: "rectangle",
     variant: "wide"
   },
   {
-    name: new RegExp("h\xECnh\\s+b\xECnh\\s+h\xE0nh\\s+" + QUAD, "gu"),
+    name: new RegExp("[Hh]\xECnh\\s+b\xECnh\\s+h\xE0nh\\s+" + QUAD, "gu"),
     shape: "parallelogram",
     variant: "standard"
   },
   {
-    name: new RegExp("h\xECnh\\s+thoi\\s+" + QUAD, "gu"),
+    name: new RegExp("[Hh]\xECnh\\s+thoi\\s+" + QUAD, "gu"),
     shape: "rhombus",
     variant: "standard"
   },
   {
-    name: new RegExp("t\u1EE9\\s+gi\xE1c(?:\\s+l\u1ED3i)?\\s+" + QUAD, "gu"),
+    name: new RegExp("[Tt]\u1EE9\\s+gi\xE1c(?:\\s+l\u1ED3i)?\\s+" + QUAD, "gu"),
     shape: "quadrilateral",
     variant: "any"
   },
@@ -562,10 +580,10 @@ var KINDS = [
     variant: "any"
   }
 ];
-var PREFILTER = /hình\s+(?:vuông|chữ\s+nhật|bình\s+hành|thoi|thang)|tứ\s+giác|[Ss]quare|[Rr]ectangle|[Pp]arallelogram|[Rr]hombus|[Tt]rapezoid|[Tt]rapezium|[Qq]uadrilateral/u;
+var PREFILTER = /[Hh]ình\s+(?:vuông|chữ\s+nhật|bình\s+hành|thoi|thang)|[Tt]ứ\s+giác|[Ss]quare|[Rr]ectangle|[Pp]arallelogram|[Rr]hombus|[Tt]rapezoid|[Tt]rapezium|[Qq]uadrilateral/u;
 var RIGHT_AFTER = /vuông(?!\p{L})/u;
 var ISO_AFTER = /(?<!\p{L})cân(?!\p{L})/u;
-var NEXT_SHAPE = /hình\s|tứ\s+giác/u;
+var NEXT_SHAPE = /[Hh]ình\s|[Tt]ứ\s+giác/u;
 function scanClause(text) {
   const claimed = [];
   const taken = [];
@@ -609,13 +627,17 @@ var CYCLIC_QUAD_THETAS = CYCLIC_QUAD_COORDS.map(
 );
 var CENTER = "(?:\\(\\s*([A-Z])\\s*\\)|t\xE2m\\s+([A-Z]))?";
 var QUAD_INSCRIBED_IN_CIRCLE = new RegExp(
-  "^[\\s,]*(?:n\u1ED9i\\s*ti\u1EBFp\\s+(?:trong\\s+)?(?:m\u1ED9t\\s+)?\u0111\u01B0\u1EDDng\\s*tr\xF2n|(?:is\\s+|are\\s+)?inscribed\\s+in\\s+(?:a\\s+|the\\s+)?circle)\\s*" + CENTER,
+  "^[\\s,]*(?:n\u1ED9i\\s*ti\u1EBFp\\s+(?:trong\\s+)?(?:m\u1ED9t\\s+)?\u0111\u01B0\u1EDDng\\s*tr\xF2n\\s*" + CENTER + "|n\u1ED9i\\s*ti\u1EBFp\\s+(?:trong\\s+)?\\(\\s*([A-Z])\\s*\\)|(?:is\\s+|are\\s+)?inscribed\\s+in\\s+(?:a\\s+|the\\s+)?circle\\s*" + CENTER + ")",
   "iu"
 );
 var CIRCLE_CIRCUMSCRIBES_QUAD = new RegExp(
   "(?:\u0111\u01B0\u1EDDng\\s*tr\xF2n|circle)\\s*" + CENTER + "\\s*(?:ngo\u1EA1i\\s*ti\u1EBFp|(?:is\\s+|are\\s+)?circumscrib(?:es|ed)(?:\\s+(?:about|around))?)\\s+$",
   "iu"
 );
+var TUGIAC_NOITIEP = new RegExp(
+  "[Tt]\u1EE9\\s+gi\xE1c(?:\\s+l\u1ED3i)?\\s+n\u1ED9i\\s*ti\u1EBFp\\s+(?:(?:trong\\s+)?(?:m\u1ED9t\\s+)?\u0111\u01B0\u1EDDng\\s*tr\xF2n\\s+)?(?:\\(\\s*([A-Z])\\s*\\)\\s+)?" + QUAD,
+  "gu"
+);
 var TRIANGLE_DECL = /(?:tam\s*giác|[Tt]riangle)\s+([A-Z])([A-Z])([A-Z])(?![A-Z])/gu;
 function ownedByOthers(ctx, selfLabels) {
   const owned = /* @__PURE__ */ new Set();
@@ -634,9 +656,26 @@ function ownedByOthers(ctx, selfLabels) {
   }
   return owned;
 }
+function conflictingOwners(ctx, quadLabels) {
+  const quadSet = new Set(quadLabels);
+  const owned = /* @__PURE__ */ new Set();
+  const addIfOutside = (verts) => {
+    if (verts.some((v) => !quadSet.has(v))) for (const v of verts) owned.add(v);
+  };
+  TRIANGLE_DECL.lastIndex = 0;
+  for (const m of ctx.problem.matchAll(TRIANGLE_DECL)) addIfOutside([m[1], m[2], m[3]]);
+  const selfKey = quadLabels.join("");
+  for (const c of ctx.clauses) {
+    for (const h of scanClause(c.text)) {
+      if (h.labels.join("") === selfKey) continue;
+      addIfOutside(h.labels);
+    }
+  }
+  return owned;
+}
 function detectCyclic(text, hit) {
   const a = QUAD_INSCRIBED_IN_CIRCLE.exec(text.slice(hit.afterEnd));
-  if (a) return a[1] ?? a[2] ?? "";
+  if (a) return a[1] ?? a[2] ?? a[3] ?? a[4] ?? a[5] ?? "";
   const b = CIRCLE_CIRCUMSCRIBES_QUAD.exec(text.slice(0, hit.index));
   if (b) return b[1] ?? b[2] ?? "";
   return void 0;
@@ -649,12 +688,30 @@ var quadRule = {
   match(ctx) {
     const out = [];
     for (const c of ctx.clauses) {
+      TUGIAC_NOITIEP.lastIndex = 0;
+      for (const m of c.text.matchAll(TUGIAC_NOITIEP)) {
+        const labels = [m[2], m[3], m[4], m[5]];
+        const owned = ownedByOthers(ctx, labels);
+        if (labels.some((lbl) => owned.has(lbl))) continue;
+        const centerName = m[1] || "O";
+        out.push({
+          ruleId: "quad",
+          clauseIds: [c.id],
+          intents: [
+            drawCircle(centerName, "centerRadius", { center: centerName, radius: CYCLIC_RADIUS }),
+            ...labels.map(
+              (lbl, i) => addPoint(lbl, { kind: "onCircle", circle: centerName, theta: CYCLIC_QUAD_THETAS[i] })
+            ),
+            markShape("quadrilateral", labels)
+          ]
+        });
+      }
       for (const hit of scanClause(c.text)) {
         let intents = [drawShape(hit.shape, hit.labels, hit.variant)];
         if (hit.shape === "quadrilateral") {
           const center = detectCyclic(c.text, hit);
           if (center !== void 0) {
-            const owned = ownedByOthers(ctx, hit.labels);
+            const owned = conflictingOwners(ctx, hit.labels);
             const shared = hit.labels.some((lbl) => owned.has(lbl));
             if (!shared) {
               const centerName = center || "O";
@@ -764,11 +821,11 @@ var NAME_AFTER_G = new RegExp(
   "gu"
 );
 var DISTRIB = new RegExp(
-  `((?:[A-Z](?:['\u2032]?)\\s*(?:,|v\xE0)\\s*)+[A-Z](?:['\u2032]?))\\s+(?:l\u1EA7n\\s*l\u01B0\u1EE3t\\s+|theo\\s+th\u1EE9\\s+t\u1EF1\\s+)?(?:l\xE0\\s+)?(?:\u0111i\u1EC3m\\s+)?trung\\s*\u0111i\u1EC3m\\s+(?:c\u1EE7a\\s+)?(?:c\xE1c\\s+)?${SIDE_PREFIX}((?:[A-Z][A-Z]\\s*,\\s*)*(?:[A-Z][A-Z]\\s*,\\s*)?[A-Z][A-Z](?:\\s*v\xE0\\s*[A-Z][A-Z])?)`,
+  `((?:[A-Z](?:['\u2032]?)\\s*(?:,|v\xE0)\\s*)+[A-Z](?:['\u2032]?))\\s+(?:l\u1EA7n\\s*l\u01B0\u1EE3t\\s+|(?:theo\\s+)?th\u1EE9\\s+t\u1EF1\\s+)?(?:l\xE0\\s+)?(?:\u0111i\u1EC3m\\s+)?trung\\s*\u0111i\u1EC3m\\s+(?:c\u1EE7a\\s+)?(?:c\xE1c\\s+)?${SIDE_PREFIX}((?:[A-Z][A-Z]\\s*,\\s*)*(?:[A-Z][A-Z]\\s*,\\s*)?[A-Z][A-Z](?:\\s*v\xE0\\s*[A-Z][A-Z])?)`,
   "u"
 );
 var DISTRIB_AFTER = new RegExp(
-  `trung\\s*\u0111i\u1EC3m\\s+(?:c\u1EE7a\\s+)?(?:c\xE1c\\s+)?${SIDE_PREFIX}((?:[A-Z][A-Z]\\s*(?:,|v\xE0)\\s*)+[A-Z][A-Z])(?![A-Z])\\s+(?:l\u1EA7n\\s*l\u01B0\u1EE3t\\s+|theo\\s+th\u1EE9\\s+t\u1EF1\\s+)?l\xE0\\s+((?:[A-Z](?:['\u2032]?)\\s*(?:,|v\xE0)\\s*)+[A-Z](?:['\u2032]?))(?!\\p{L})`,
+  `trung\\s*\u0111i\u1EC3m\\s+(?:c\u1EE7a\\s+)?(?:c\xE1c\\s+)?${SIDE_PREFIX}((?:[A-Z][A-Z]\\s*(?:,|v\xE0)\\s*)+[A-Z][A-Z])(?![A-Z])\\s+(?:l\u1EA7n\\s*l\u01B0\u1EE3t\\s+|(?:theo\\s+)?th\u1EE9\\s+t\u1EF1\\s+)?l\xE0\\s+((?:[A-Z](?:['\u2032]?)\\s*(?:,|v\xE0)\\s*)+[A-Z](?:['\u2032]?))(?!\\p{L})`,
   "u"
 );
 function nameToken(raw) {
@@ -1134,8 +1191,8 @@ var PREFILTER4 = [
   /[Bb]isector\s+of\s+(?:the\s+)?(?:[Aa]ngle|∠)/u
   // Form A EN
 ];
-var ANGLE3 = /phân\s*giác\s+(?:trong\s+)?(?:(?:của|cho)\s+)?góc\s+([A-Z])([A-Z])([A-Z])(?![A-Z])/giu;
-var ANGLE1 = /phân\s*giác\s+(?:trong\s+)?(?:(?:của|cho)\s+)?góc\s+([A-Z])(?![A-Z])/giu;
+var ANGLE3 = /phân\s*giác\s+(?:trong\s+)?(?:(?:của|cho)\s+)?(?:góc\s+|∠\s*)([A-Z])([A-Z])([A-Z])(?![A-Z])/giu;
+var ANGLE1 = /phân\s*giác\s+(?:trong\s+)?(?:(?:của|cho)\s+)?(?:góc\s+|∠\s*)([A-Z])(?![A-Z])/giu;
 var CHAN_BEFORE = /chân\s+(?:của\s+)?(?:đường\s*|tia\s+)?$/u;
 var ANGLE3_EN_A = /[Bb]isector\s+of\s+(?:the\s+)?(?:[Aa]ngle|∠)\s*([A-Z])([A-Z])([A-Z])(?![A-Z])/gu;
 var ANGLE3_EN_B = /[Aa]ngle\s+bisector\s+of\s+([A-Z])([A-Z])([A-Z])(?![A-Z])/gu;
@@ -1313,6 +1370,13 @@ function resolveTriangle(clauseText, kwIndex, uniqueProblemTri) {
   }
   return uniqueProblemTri;
 }
+function dropDegenerate(intents) {
+  return intents.filter((i) => {
+    if (i.op !== "add-point") return true;
+    const of = i.constraint.of;
+    return !(Array.isArray(of) && of.includes(i.name));
+  });
+}
 var centersRule = {
   id: "centers",
   priority: 70,
@@ -1345,7 +1409,8 @@ var centersRule = {
         if (of) {
           intents.push(addPoint(dc[1], { kind: centerTypeToKind(dc[3]), of }));
           intents.push(addPoint(dc[2], { kind: centerTypeToKind(dc[4]), of }));
-          out.push({ ruleId: "centers", clauseIds: [c.id], intents });
+          const kept2 = dropDegenerate(intents);
+          if (kept2.length) out.push({ ruleId: "centers", clauseIds: [c.id], intents: kept2 });
           continue;
         }
       }
@@ -1394,8 +1459,9 @@ var centersRule = {
         const of = ofFor(c.text, INCENTER_KW_EN);
         if (name && of) intents.push(addPoint(name, { kind: "incenter", of }));
       }
-      if (intents.length > 0) {
-        out.push({ ruleId: "centers", clauseIds: [c.id], intents });
+      const kept = dropDegenerate(intents);
+      if (kept.length > 0) {
+        out.push({ ruleId: "centers", clauseIds: [c.id], intents: kept });
       }
     }
     return out;
@@ -1408,9 +1474,11 @@ var PREFILTER5 = new RegExp(
   "u"
 );
 var PREFILTER_EN = /projection|perpendicular|foot\s+of/i;
-var LINE = "(?:" + DUONG_KW + "\\s*th\u1EB3ng\\s+|c\u1EA1nh\\s+|\u0111o\u1EA1n(?:\\s+th\u1EB3ng)?\\s+)?([A-Z]{1,2})(?![A-Z])";
+var LINE_PREFIX = "(?:" + DUONG_KW + "\\s*th\u1EB3ng\\s+|ti\u1EBFp\\s*tuy\u1EBFn\\s+|c\u1EA1nh\\s+|\u0111o\u1EA1n(?:\\s+th\u1EB3ng)?\\s+)?";
+var LINE_TOK = "([A-Z]{1,2}(?![A-Za-z])|[A-Z]?[a-z][a-z]?[0-9]?(?![A-Za-z]))";
+var LINE = LINE_PREFIX + LINE_TOK;
 var PREP = "(?:tr\xEAn|l\xEAn|xu\u1ED1ng|\u0111\u1EBFn|t\u1EDBi)";
-var LANLUOT_OPT = "(?:(?:l\u1EA7n\\s*l\u01B0\u1EE3t|theo\\s+th\u1EE9\\s+t\u1EF1|th\u1EE9\\s+t\u1EF1)\\s+)?";
+var LANLUOT_OPT = "(?:(?:l\u1EA7n\\s*l\u01B0\u1EE3t|theo\\s+th\u1EE9\\s+t\u1EF1|th\u1EE9\\s+t\u1EF1|t\u01B0\u01A1ng\\s+\u1EE9ng)\\s+)?";
 var PROJ_CORE = `h\xECnh\\s*chi\u1EBFu\\s+(?:vu\xF4ng\\s*g\xF3c\\s+)?(?:c\u1EE7a\\s+)?(?:\u0111i\u1EC3m\\s+)?([A-Z])\\s+${PREP}\\s+${LINE}`;
 var FOOT_CORE = `ch\xE2n\\s+(?:c\u1EE7a\\s+)?${DUONG_KW}\\s+(?:vu\xF4ng\\s*g\xF3c|cao)\\s*(?:h\u1EA1\\s+|k\u1EBB\\s+|v\u1EBD\\s+|d\u1EF1ng\\s+)?(?:t\u1EEB\\s+)?(?:\u0111i\u1EC3m\\s+)?([A-Z])\\s+${PREP}\\s+${LINE}`;
 var LANLUOT = new RegExp(
@@ -1421,14 +1489,27 @@ var SINGLE = new RegExp(`(?:${PROJ_CORE})|(?:${FOOT_CORE})`, "gu");
 var NAMES_BLOB = "((?:[A-Z](?:['\u2032]?)\\s*(?:,|v\xE0)\\s*)+[A-Z](?:['\u2032]?))";
 var LINES_BLOB = "((?:[A-Z]{1,2}\\s*(?:,|v\xE0)\\s*)+[A-Z]{1,2})(?!\\p{L})";
 var LINES_PREFIX = "(?:c\xE1c\\s+)?(?:\u0111\u01B0\u1EDDng\\s*th\u1EB3ng\\s+|c\u1EA1nh\\s+|\u0111o\u1EA1n\\s+)?";
+var NO_HOA_BEFORE = "(?<![A-Z])";
 var DISTRIB_PROJ = new RegExp(
-  NAMES_BLOB + "\\s+" + LANLUOT_OPT + "(?:l\xE0\\s+)?(?:c\xE1c\\s+)?h\xECnh\\s*chi\u1EBFu\\s+(?:vu\xF4ng\\s*g\xF3c\\s+)?(?:c\u1EE7a\\s+)?(?:\u0111i\u1EC3m\\s+)?([A-Z])(?!\\p{L})\\s+(?:tr\xEAn|l\xEAn|xu\u1ED1ng|\u0111\u1EBFn)\\s+" + LINES_PREFIX + LINES_BLOB,
+  NO_HOA_BEFORE + NAMES_BLOB + "\\s+" + LANLUOT_OPT + "(?:l\xE0\\s+)?(?:c\xE1c\\s+)?h\xECnh\\s*chi\u1EBFu\\s+(?:vu\xF4ng\\s*g\xF3c\\s+)?(?:c\u1EE7a\\s+)?(?:\u0111i\u1EC3m\\s+)?([A-Z])(?!\\p{L})\\s+(?:tr\xEAn|l\xEAn|xu\u1ED1ng|\u0111\u1EBFn)\\s+" + LINES_PREFIX + LINES_BLOB,
   "gu"
 );
 var DISTRIB_FOOT = new RegExp(
-  NAMES_BLOB + "\\s+" + LANLUOT_OPT + "(?:l\xE0\\s+)?(?:c\xE1c\\s+)?ch\xE2n\\s+(?:c\u1EE7a\\s+)?(?:c\xE1c\\s+)?\u0111\u01B0\u1EDDng\\s+(?:vu\xF4ng\\s*g\xF3c|cao)\\s*(?:h\u1EA1\\s+|k\u1EBB\\s+|v\u1EBD\\s+|d\u1EF1ng\\s+)?(?:t\u1EEB\\s+)?(?:\u0111i\u1EC3m\\s+)?([A-Z])(?!\\p{L})\\s+(?:\u0111\u1EBFn|xu\u1ED1ng|tr\xEAn|t\u1EDBi)\\s+" + LINES_PREFIX + LINES_BLOB,
+  NO_HOA_BEFORE + NAMES_BLOB + "\\s+" + LANLUOT_OPT + "(?:l\xE0\\s+)?(?:c\xE1c\\s+)?ch\xE2n\\s+(?:c\u1EE7a\\s+)?(?:c\xE1c\\s+)?\u0111\u01B0\u1EDDng\\s+(?:vu\xF4ng\\s*g\xF3c|cao)\\s*(?:h\u1EA1\\s+|k\u1EBB\\s+|v\u1EBD\\s+|d\u1EF1ng\\s+)?(?:t\u1EEB\\s+)?(?:\u0111i\u1EC3m\\s+)?([A-Z])(?!\\p{L})\\s+(?:\u0111\u1EBFn|xu\u1ED1ng|tr\xEAn|t\u1EDBi)\\s+" + LINES_PREFIX + LINES_BLOB,
+  "gu"
+);
+var NAMES_BLOB_IDX = "((?:[A-Z][0-9]?(?:['\u2032]?)\\s*(?:,|v\xE0)\\s*)+[A-Z][0-9]?(?:['\u2032]?))";
+var FROMS_BLOB_IDX = "((?:[A-Z][0-9]?(?:['\u2032]?)\\s*(?:,|v\xE0)\\s*)+[A-Z][0-9]?(?:['\u2032]?))(?!\\p{L})";
+var ZIP_FROM_PROJ = new RegExp(
+  NO_HOA_BEFORE + NAMES_BLOB_IDX + "\\s+" + LANLUOT_OPT + "(?:l\xE0\\s+)?(?:c\xE1c\\s+)?h\xECnh\\s*chi\u1EBFu\\s+(?:vu\xF4ng\\s*g\xF3c\\s+)?(?:c\u1EE7a\\s+)?(?:\u0111i\u1EC3m\\s+)?" + FROMS_BLOB_IDX + "\\s+(?:tr\xEAn|l\xEAn|xu\u1ED1ng|\u0111\u1EBFn)\\s+" + LINES_PREFIX + LINES_BLOB,
   "gu"
 );
+function splitNamesIdx(blob) {
+  return blob.split(/,|và/).map((s) => {
+    const mm = /^([A-Z][0-9]?)(['′]?)/u.exec(s.trim());
+    return mm ? mm[2] ? `${mm[1]}'` : mm[1] : "";
+  }).filter(Boolean);
+}
 var TWO_LINES_PREP = "(?:tr\xEAn|l\xEAn|xu\u1ED1ng|\u0111\u1EBFn|t\u1EDBi)";
 var TWO_LINES_LINE = "(?:c\xE1c\\s+)?(?:\u0111\u01B0\u1EDDng\\s*th\u1EB3ng\\s+|c\u1EA1nh\\s+|\u0111o\u1EA1n\\s+)?([A-Z]{1,2})(?![A-Z])";
 var SHARED_FROM_TWO = new RegExp(
@@ -1436,21 +1517,44 @@ var SHARED_FROM_TWO = new RegExp(
   "gu"
 );
 var FEET_FROM_SHARED_LINE = new RegExp(
-  "(?:[Hh]ai\\s+\u0111i\u1EC3m\\s+|[Cc]\xE1c\\s+\u0111i\u1EC3m\\s+)?([A-Z])(?:['\u2032])?\\s*(?:,|v\xE0)\\s*([A-Z])(?:['\u2032])?\\s+l\u1EA7n\\s*l\u01B0\u1EE3t\\s+l\xE0\\s+ch\xE2n\\s+(?:c\xE1c\\s+)?(?:\u0111\u01B0\u1EDDng\\s+)?(?:vu\xF4ng\\s*g\xF3c|cao)\\s+(?:k\u1EBB\\s+|h\u1EA1\\s+|v\u1EBD\\s+|d\u1EF1ng\\s+)?(?:t\u1EEB\\s+)?([A-Z](?:['\u2032])?)\\s*(?:,|v\xE0)\\s*([A-Z](?:['\u2032])?)\\s+(?:\u0111\u1EBFn|xu\u1ED1ng|tr\xEAn|t\u1EDBi)\\s+(?:\u0111\u01B0\u1EDDng\\s*th\u1EB3ng\\s+|c\u1EA1nh\\s+|\u0111o\u1EA1n\\s+)?([A-Z]{1,2}(?:['\u2032])?)(?![A-Z])",
+  "(?:[Hh]ai\\s+\u0111i\u1EC3m\\s+|[Cc]\xE1c\\s+\u0111i\u1EC3m\\s+)?([A-Z])(?:['\u2032])?\\s*(?:,|v\xE0)\\s*([A-Z])(?:['\u2032])?\\s+" + // "lần lượt"/"theo thứ tự"/"thứ tự" = phân phối 1-1, OPTIONAL (LANLUOT_OPT).
+  LANLUOT_OPT + "l\xE0\\s+ch\xE2n\\s+(?:c\xE1c\\s+)?(?:\u0111\u01B0\u1EDDng\\s+)?(?:vu\xF4ng\\s*g\xF3c|cao)\\s+(?:k\u1EBB\\s+|h\u1EA1\\s+|v\u1EBD\\s+|d\u1EF1ng\\s+)?(?:t\u1EEB\\s+)?([A-Z](?:['\u2032])?)\\s*(?:,|v\xE0)\\s*([A-Z](?:['\u2032])?)\\s+(?:\u0111\u1EBFn|xu\u1ED1ng|tr\xEAn|t\u1EDBi)\\s+(?:\u0111\u01B0\u1EDDng\\s*th\u1EB3ng\\s+|\u0111\u01B0\u1EDDng\\s*k\xEDnh\\s+|c\u1EA1nh\\s+|\u0111o\u1EA1n\\s+)?([A-Z]{1,2}(?:['\u2032])?)(?![A-Z])",
   "gu"
 );
+var PERP_LINE_PREFIX = "(?:\u0111\u01B0\u1EDDng\\s*th\u1EB3ng\\s+|ti\u1EBFp\\s*tuy\u1EBFn\\s+|c\u1EA1nh\\s+|\u0111o\u1EA1n\\s+)?";
+var PERP_LINE_TOK = "([A-Z]{1,2}(?![A-Za-z])|[A-Z]?[a-z][a-z]?[0-9]?(?![A-Za-z]))";
 var PERP_DRAW_DISTRIB = new RegExp(
   "(?:[Kk]\u1EBB|[Vv]\u1EBD|[Dd]\u1EF1ng|[Hh]\u1EA1)\\s+([A-Z])([A-Z])\\s*,\\s*([A-Z])([A-Z])(?![A-Z])\\s+(?:l\u1EA7n\\s*l\u01B0\u1EE3t\\s+)?(?:\u22A5|vu\xF4ng\\s*g\xF3c(?:\\s+v\u1EDBi)?)\\s+(?:v\u1EDBi\\s+)?(?:c\xE1c\\s+)?(?:\u0111\u01B0\u1EDDng\\s*th\u1EB3ng\\s+|c\u1EA1nh\\s+|\u0111o\u1EA1n\\s+)?([A-Z]{2})\\s*,\\s*([A-Z]{2})(?![A-Z])",
   "gu"
 );
+var PAIRS_BLOB = "((?:[A-Z]{2}\\s*,\\s*)+[A-Z]{2})(?![A-Z])";
+var PERP_DRAW_ARE = new RegExp(
+  "(?:[Kk]\u1EBB|[Vv]\u1EBD|[Dd]\u1EF1ng|[Hh]\u1EA1)\\s+" + PAIRS_BLOB + "\\s+l\xE0\\s+(?:c\xE1c\\s+)?(?:\u0111\u01B0\u1EDDng\\s*th\u1EB3ng\\s+|\u0111\u01B0\u1EDDng\\s+)?vu\xF4ng\\s*g\xF3c\\s+(?:t\u1EDBi|\u0111\u1EBFn|xu\u1ED1ng|v\u1EDBi)\\s+(?:c\xE1c\\s+)?(?:\u0111\u01B0\u1EDDng\\s*th\u1EB3ng\\s+|c\u1EA1nh\\s+|\u0111o\u1EA1n\\s+)?((?:[A-Z]{2}\\s*(?:,|v\xE0)\\s*)+[A-Z]{2})(?![A-Z])",
+  "gu"
+);
 var PERP_SHARED_CUNG = new RegExp(
-  "(?:[Kk]\u1EBB|[Vv]\u1EBD|[Dd]\u1EF1ng|[Hh]\u1EA1)\\s+([A-Z])([A-Z])(?![A-Z])\\s+v\xE0\\s+([A-Z])([A-Z])(?![A-Z])\\s+c\xF9ng\\s+vu\xF4ng\\s*g\xF3c\\s+(?:v\u1EDBi\\s+)?(?:\u0111\u01B0\u1EDDng\\s*th\u1EB3ng\\s+|c\u1EA1nh\\s+|\u0111o\u1EA1n\\s+)?([A-Z]{1,2})(?![A-Z])",
+  "(?:[Kk]\u1EBB|[Vv]\u1EBD|[Dd]\u1EF1ng|[Hh]\u1EA1)\\s+([A-Z])([A-Z])(?![A-Z])\\s+v\xE0\\s+([A-Z])([A-Z])(?![A-Z])\\s+(?:c\xF9ng\\s+)?vu\xF4ng\\s*g\xF3c\\s+(?:v\u1EDBi\\s+)?" + PERP_LINE_PREFIX + PERP_LINE_TOK,
   "gu"
 );
 var FROM_DRAW_DISTRIB = new RegExp(
   "t\u1EEB\\s+([A-Z])(?!\\p{L})\\s+k\u1EBB\\s+([A-Z]{2})\\s*,\\s*([A-Z]{2})\\s+vu\xF4ng\\s*g\xF3c\\s+v\u1EDBi\\s+c\xE1c\\s+c\u1EA1nh\\s+([A-Z]{2})\\s*,\\s*([A-Z]{2})(?![A-Z])",
   "gu"
 );
+var DECLARE_LINE = new RegExp(
+  "(?:\u0111\u01B0\u1EDDng\\s*th\u1EB3ng|ti\u1EBFp\\s*tuy\u1EBFn|c\xE1t\\s*tuy\u1EBFn|tia)\\s+([A-Z]?[a-z][a-z]?[0-9]?)(?![A-Za-z])",
+  "gu"
+);
+function declaredNamedLines(problem) {
+  const out = /* @__PURE__ */ new Set();
+  DECLARE_LINE.lastIndex = 0;
+  let m;
+  while ((m = DECLARE_LINE.exec(problem)) !== null) out.add(m[1]);
+  return out;
+}
+function isAllowedLine(line, declared) {
+  if (/^[A-Z]{1,2}$/u.test(line)) return true;
+  return declared.has(line);
+}
 function splitNames(blob) {
   return blob.split(/,|và/).map((s) => {
     const mm = /^([A-Z])(['′]?)/u.exec(s.trim());
@@ -1458,11 +1562,11 @@ function splitNames(blob) {
   }).filter(Boolean);
 }
 var PERP_DRAW = new RegExp(
-  `(?:[Kk]\u1EBB|[Vv]\u1EBD|[Dd]\u1EF1ng|[Hh]\u1EA1)\\s+([A-Z])([A-Z])(?![A-Z])\\s+(?:\u22A5\\s*|vu\xF4ng\\s*g\xF3c(?:\\s+v\u1EDBi)?\\s+)(?:v\u1EDBi\\s+)?(?:\u0111\u01B0\u1EDDng\\s*th\u1EB3ng\\s+|c\u1EA1nh\\s+|\u0111o\u1EA1n\\s+)?([A-Z]{1,2})(?![A-Z])(?:\\s+t\u1EA1i\\s+([A-Z]))?`,
+  `(?:[Kk]\u1EBB|[Vv]\u1EBD|[Dd]\u1EF1ng|[Hh]\u1EA1)\\s+([A-Z])([A-Z])(?![A-Z])\\s+(?:\u22A5\\s*|vu\xF4ng\\s*g\xF3c(?:\\s+v\u1EDBi)?\\s+)(?:v\u1EDBi\\s+)?${PERP_LINE_PREFIX}${PERP_LINE_TOK}(?:\\s+t\u1EA1i\\s+([A-Z]))?`,
   "gu"
 );
 var PERP_BARE = new RegExp(
-  `([A-Z])([A-Z])(?![A-Z])\\s+(?:\u22A5\\s*|vu\xF4ng\\s*g\xF3c(?:\\s+v\u1EDBi)?\\s+)(?:v\u1EDBi\\s+)?(?:\u0111\u01B0\u1EDDng\\s*th\u1EB3ng\\s+|c\u1EA1nh\\s+|\u0111o\u1EA1n\\s+)?([A-Z]{1,2})(?![A-Z])(?:\\s+t\u1EA1i\\s+([A-Z]))?`,
+  `([A-Z])([A-Z])(?![A-Z])\\s+(?:\u22A5\\s*|vu\xF4ng\\s*g\xF3c(?:\\s+v\u1EDBi)?\\s+)(?:v\u1EDBi\\s+)?${PERP_LINE_PREFIX}${PERP_LINE_TOK}(?:\\s+t\u1EA1i\\s+([A-Z]))?`,
   "gu"
 );
 var DRAW_VERB = /[Kk]ẻ|[Vv]ẽ|[Dd]ựng/u;
@@ -1531,7 +1635,7 @@ function parseAltitudeBundle(text, fallbackTri) {
   }
   return out;
 }
-function parseFeet(text, fallbackTri) {
+function parseFeet(text, fallbackTri, declared = /* @__PURE__ */ new Set()) {
   const out = [];
   const consumed = [];
   const bundled = parseAltitudeBundle(text, fallbackTri);
@@ -1573,6 +1677,24 @@ function parseFeet(text, fallbackTri) {
     }
     if (ok) return local;
   }
+  ZIP_FROM_PROJ.lastIndex = 0;
+  for (const zm of text.matchAll(ZIP_FROM_PROJ)) {
+    const names = splitNamesIdx(zm[1]);
+    const froms = splitNamesIdx(zm[2]);
+    const lines = zm[3].split(/,|và/).map((s) => s.trim()).filter(Boolean);
+    if (names.length < 2) continue;
+    if (names.length !== froms.length || names.length !== lines.length) continue;
+    const local = [];
+    let ok = true;
+    for (let i = 0; i < names.length; i++) {
+      if (lines[i].includes(names[i]) || names[i] === froms[i]) {
+        ok = false;
+        break;
+      }
+      local.push({ name: names[i], from: froms[i], onLine: lines[i], withSegment: true });
+    }
+    if (ok && local.length > 0) return local;
+  }
   for (const re of [DISTRIB_PROJ, DISTRIB_FOOT]) {
     re.lastIndex = 0;
     for (const dm2 of text.matchAll(re)) {
@@ -1613,8 +1735,8 @@ function parseFeet(text, fallbackTri) {
   for (const fm of text.matchAll(FEET_FROM_SHARED_LINE)) {
     const start = fm.index ?? 0;
     if (consumed.some(([a, b]) => start >= a && start < b)) continue;
-    const norm2 = (s) => s.replace(/′/g, "'");
-    const [n1, n2, f1, f2, line] = [fm[1], fm[2], norm2(fm[3]), norm2(fm[4]), norm2(fm[5])];
+    const norm5 = (s) => s.replace(/′/g, "'");
+    const [n1, n2, f1, f2, line] = [fm[1], fm[2], norm5(fm[3]), norm5(fm[4]), norm5(fm[5])];
     if (n1 === n2 || f1 === f2 || line.includes(n1) || line.includes(n2)) continue;
     out.push({ name: n1, from: f1, onLine: line, withSegment: true });
     out.push({ name: n2, from: f2, onLine: line, withSegment: true });
@@ -1639,7 +1761,9 @@ function parseFeet(text, fallbackTri) {
     if (MID_BEFORE.test(before)) continue;
     const nm = NAME_BEFORE.exec(before);
     if (!nm) continue;
-    out.push({ name: nm[1], from: m[1] ?? m[3], onLine: m[2] ?? m[4] });
+    const onLine = m[2] ?? m[4];
+    if (!isAllowedLine(onLine, declared)) continue;
+    out.push({ name: nm[1], from: m[1] ?? m[3], onLine });
   }
   PERP_DRAW_DISTRIB.lastIndex = 0;
   for (const ddm of text.matchAll(PERP_DRAW_DISTRIB)) {
@@ -1650,10 +1774,36 @@ function parseFeet(text, fallbackTri) {
     out.push({ name: foot2, from: from2, onLine: line2, withSegment: true });
     consumed.push([ddm.index ?? 0, (ddm.index ?? 0) + ddm[0].length]);
   }
+  PERP_DRAW_ARE.lastIndex = 0;
+  for (const am of text.matchAll(PERP_DRAW_ARE)) {
+    const start = am.index ?? 0;
+    if (consumed.some(([a, b]) => start >= a && start < b)) continue;
+    const pairs = am[1].split(",").map((s) => s.trim()).filter((s) => /^[A-Z]{2}$/.test(s));
+    const lines = am[2].split(/,|và/).map((s) => s.trim()).filter((s) => /^[A-Z]{2}$/.test(s));
+    if (pairs.length < 2 || pairs.length !== lines.length) continue;
+    const from = pairs[0][0];
+    if (!pairs.every((p) => p[0] === from)) continue;
+    const local = [];
+    let ok = true;
+    for (let i = 0; i < pairs.length; i++) {
+      const foot = pairs[i][1];
+      const onLine = lines[i];
+      if (onLine.includes(foot)) {
+        ok = false;
+        break;
+      }
+      local.push({ name: foot, from, onLine, withSegment: true });
+    }
+    if (ok && local.length > 0) {
+      out.push(...local);
+      consumed.push([start, start + am[0].length]);
+    }
+  }
   PERP_SHARED_CUNG.lastIndex = 0;
   for (const sm of text.matchAll(PERP_SHARED_CUNG)) {
     const [f1, t1, f2, t2, line] = [sm[1], sm[2], sm[3], sm[4], sm[5]];
     if (t1 === t2 || line.includes(t1) || line.includes(t2)) continue;
+    if (!isAllowedLine(line, declared)) continue;
     out.push({ name: t1, from: f1, onLine: line, withSegment: true });
     out.push({ name: t2, from: f2, onLine: line, withSegment: true });
     consumed.push([sm.index ?? 0, (sm.index ?? 0) + sm[0].length]);
@@ -1667,6 +1817,7 @@ function parseFeet(text, fallbackTri) {
     const at = pm[4];
     if (at && at !== foot) continue;
     if (onLine.includes(foot)) continue;
+    if (!isAllowedLine(onLine, declared)) continue;
     out.push({ name: foot, from, onLine });
   }
   if (DRAW_VERB.test(text)) {
@@ -1679,6 +1830,7 @@ function parseFeet(text, fallbackTri) {
       const at = bm[4];
       if (at && at !== foot) continue;
       if (onLine.includes(foot)) continue;
+      if (!isAllowedLine(onLine, declared)) continue;
       if (out.some((o) => o.name === foot)) continue;
       out.push({ name: foot, from, onLine });
     }
@@ -1714,13 +1866,14 @@ var perpFootRule = {
   match(ctx) {
     const out = [];
     const fallbackTri = uniqueTriangle(ctx.problem);
+    const declared = declaredNamedLines(ctx.problem);
     for (const c of ctx.clauses) {
-      const feet = parseFeet(c.text, fallbackTri);
+      const feet = parseFeet(c.text, fallbackTri, declared);
       if (feet.length === 0) continue;
       const intents = feet.flatMap((f) => {
         if (f.from === "") return [addPoint(f.name, { kind: "orthocenter", of: f.onLine.split("") })];
-        const add = addPoint(f.name, { kind: "perpFoot", from: f.from, onLine: f.onLine });
-        return f.withSegment ? [add, connect(f.from, f.name, "segment")] : [add];
+        const add2 = addPoint(f.name, { kind: "perpFoot", from: f.from, onLine: f.onLine });
+        return f.withSegment ? [add2, connect(f.from, f.name, "segment")] : [add2];
       });
       out.push({ ruleId: "perpFoot", clauseIds: [c.id], intents });
     }
@@ -1767,28 +1920,28 @@ function parseNum(raw) {
 function isInscribedCircumscribed(problem, center) {
   const REL = "(?:(?:n\u1ED9i|ngo\u1EA1i)\\s*ti\u1EBFp|[Ii]nscribed|[Cc]ircumscrib(?:es|ed))";
   const after = new RegExp(
-    `${REL}[^.]{0,30}?(?:\u0111\u01B0\u1EDDng\\s*tr\xF2n\\s*|[Cc]ircle\\s*)?\\(?\\s*${center}(?![A-Z])`,
+    `${REL}[^.]{0,30}?(?:\u0111\u01B0\u1EDDng\\s*tr\xF2n\\s*|[Cc]ircle\\s*)?\\(?\\s*${escapeRe(center)}(?![A-Z])`,
     "u"
   );
   const before = new RegExp(
-    `\\(\\s*${center}\\s*[;,][^()]*\\)[^.]{0,30}?${REL}`,
+    `\\(\\s*${escapeRe(center)}\\s*[;,][^()]*\\)[^.]{0,30}?${REL}`,
     "u"
   );
   return after.test(problem) || before.test(problem);
 }
 function isDiameterCircle(problem, center) {
   const parenThenDiameter = new RegExp(
-    `\\(\\s*${center}\\s*[;,][^()]*\\)[^.]{0,40}?${DUONG_KW}\\s*k\xEDnh\\s+[A-Z]{2}(?![A-Z])`,
+    `\\(\\s*${escapeRe(center)}\\s*[;,][^()]*\\)[^.]{0,40}?${DUONG_KW}\\s*k\xEDnh\\s+[A-Z]{2}(?![A-Z])`,
     "u"
   );
   const namedThenDiameter = new RegExp(
-    `${CIRCLE_KW}\\s*\\(\\s*${center}\\s*\\)[^.]{0,40}?${DUONG_KW}\\s*k\xEDnh\\s+[A-Z]{2}(?![A-Z])`,
+    `${CIRCLE_KW}\\s*\\(\\s*${escapeRe(center)}\\s*\\)[^.]{0,40}?${DUONG_KW}\\s*k\xEDnh\\s+[A-Z]{2}(?![A-Z])`,
     "u"
   );
   return parenThenDiameter.test(problem) || namedThenDiameter.test(problem);
 }
 function findParenClauseId(clauses, center) {
-  const frag = new RegExp(`\\(\\s*${center}(?![A-Z])`, "u");
+  const frag = new RegExp(`\\(\\s*${escapeRe(center)}(?![A-Z])`, "u");
   for (const c of clauses) if (frag.test(c.text)) return c.id;
   return void 0;
 }
@@ -2326,8 +2479,52 @@ var externalPointRule = {
   }
 };
 
+// src/stamps/geometry-2d/ai/rules/externalPointAtRadius.ts
+var METRIC = /([A-Z])(?:['′]?)([A-Z])(?:['′]?)\s*=\s*([2-9])\s*[Rr](?![A-Za-z])/gu;
+function isCenter(problem, c) {
+  const e = escapeRe(c);
+  return new RegExp(
+    String.raw`\(\s*${e}[\s);,]|tâm\s*${e}(?![A-Za-z])|đường\s*tròn\s*\(?\s*${e}(?![A-Za-z])`,
+    "u"
+  ).test(problem);
+}
+var externalPointAtRadiusRule = {
+  id: "externalPointAtRadius",
+  priority: 67,
+  languages: ["vi"],
+  patterns: [/[A-Z](?:['′]?)[A-Z](?:['′]?)\s*=\s*[2-9]\s*[Rr](?![A-Za-z])/u],
+  match(ctx) {
+    const out = [];
+    for (const c of ctx.clauses) {
+      METRIC.lastIndex = 0;
+      for (const m of c.text.matchAll(METRIC)) {
+        const a = m[1];
+        const b = m[2];
+        let center;
+        let point;
+        const aC = isCenter(ctx.problem, a);
+        const bC = isCenter(ctx.problem, b);
+        if (aC && !bC) {
+          center = a;
+          point = b;
+        } else if (bC && !aC) {
+          center = b;
+          point = a;
+        }
+        if (!center || !point || center === point) continue;
+        out.push({
+          ruleId: "externalPointAtRadius",
+          clauseIds: [c.id],
+          intents: [addPoint(point, { kind: "externalToCircle", circle: center })]
+        });
+      }
+    }
+    return out;
+  }
+};
+
 // src/stamps/geometry-2d/ai/rules/arcMidpoint.ts
-var ARC_MID = /(?:chính\s+giữa|trung\s*điểm)\s+(?:của\s+)?cung/u;
+var ARC_MID = /(?:chính\s+giữa|trung\s*điểm)\s+(?:của\s+|các\s+)*cung/u;
 var ARC_PAIR = /(?:chính\s+giữa|trung\s*điểm)\s+(?:của\s+)?cung\s+(nhỏ\s+|lớn\s+)?([A-Z])([A-Z])/u;
 var NAME_BEFORE2 = /([A-Z])(?:['′]?)\s+(?:là\s+)?(?:điểm\s+)?(?:chính\s+giữa|trung\s*điểm)\s+(?:của\s+)?cung/u;
 var TRI3 = /tam giác\s+([A-Z])([A-Z])([A-Z])/u;
@@ -2363,6 +2560,10 @@ var DISTRIB_TWO_ARCS = new RegExp(
   "([A-Z])(?:['\u2032]?)\\s*(?:,|v\xE0)\\s*([A-Z])(?:['\u2032]?)\\s+l\u1EA7n\\s*l\u01B0\u1EE3t\\s+(?:l\xE0\\s+)?(?:\u0111i\u1EC3m\\s+)?(?:ch\xEDnh\\s+gi\u1EEFa|trung\\s*\u0111i\u1EC3m)\\s+(?:c\u1EE7a\\s+)?cung\\s+(?:nh\u1ECF\\s+|l\u1EDBn\\s+)?([A-Z])([A-Z])(?![A-Z])\\s+v\xE0\\s+(?:\u0111i\u1EC3m\\s+)?(?:(?:ch\xEDnh\\s+gi\u1EEFa|trung\\s*\u0111i\u1EC3m)\\s+)?(?:c\u1EE7a\\s+)?cung\\s+(?:nh\u1ECF\\s+|l\u1EDBn\\s+)?([A-Z])([A-Z])(?![A-Z])",
   "u"
 );
+var DISTRIB_TWO_ARCS3 = new RegExp(
+  "([A-Z])(?:['\u2032]?)\\s*(?:,|v\xE0)\\s*([A-Z])(?:['\u2032]?)\\s+l\u1EA7n\\s*l\u01B0\u1EE3t\\s+(?:l\xE0\\s+)?(?:\u0111i\u1EC3m\\s+)?(?:ch\xEDnh\\s+gi\u1EEFa|trung\\s*\u0111i\u1EC3m)\\s+(?:c\u1EE7a\\s+|c\xE1c\\s+)*cung\\s+([A-Z])([A-Z])([A-Z])(?![A-Z])\\s+v\xE0\\s+(?:\u0111i\u1EC3m\\s+)?(?:(?:ch\xEDnh\\s+gi\u1EEFa|trung\\s*\u0111i\u1EC3m)\\s+)?(?:c\u1EE7a\\s+)?(?:cung\\s+)?([A-Z])([A-Z])([A-Z])(?![A-Z])",
+  "u"
+);
 function resolveCircle(problem) {
   const w = CIRCLE_WORDS.exec(problem);
   if (w) return w[1];
@@ -2410,6 +2611,27 @@ var arcMidpointRule = {
     };
     for (const c of ctx.clauses) {
       if (!ARC_MID.test(c.text)) continue;
+      const twoArcs3 = DISTRIB_TWO_ARCS3.exec(c.text);
+      if (twoArcs3) {
+        const [, n1, n2, x1, y1, z1, x2, y2, z210] = twoArcs3;
+        const triples = [
+          [n1, x1, z1, y1],
+          [n2, x2, z210, y2]
+        ];
+        const ok = triples.every(
+          ([n, a2, b2, ct]) => arcOnCircum(a2, b2) && (/* @__PURE__ */ new Set([a2, b2, ct])).size === 3 && n !== a2 && n !== b2 && n !== ct
+        );
+        if (ok) {
+          const mark = out.length;
+          let good = true;
+          for (const [n, a2, b2, ct] of triples) {
+            good = pushArc(c, n, a2, b2, { rel: "in", point: ct });
+            if (!good) break;
+          }
+          if (!good) out.length = mark;
+        }
+        continue;
+      }
       const twoArcs = DISTRIB_TWO_ARCS.exec(c.text);
       if (twoArcs) {
         const [, n1, n2, a1, b1, a2, b2] = twoArcs;
@@ -2433,7 +2655,7 @@ var arcMidpointRule = {
       }
       const pairM = ARC_PAIR.exec(c.text);
       if (!pairM) continue;
-      if (pairM[1] && /lớn/u.test(pairM[1])) continue;
+      const isMajor = !!pairM[1] && /lớn/u.test(pairM[1]);
       const pair = pairFromToken(pairM[2] + pairM[3]);
       if (pair.length !== 2) continue;
       const [a, b] = pair;
@@ -2458,7 +2680,9 @@ var arcMidpointRule = {
         pushArc(c, name, a, b, conts[0]);
       } else if (tri) {
         const third = [tri[1], tri[2], tri[3]].find((v) => v !== a && v !== b);
-        if (third) pushArc(c, name, a, b, { rel: "not", point: third });
+        if (third) pushArc(c, name, a, b, isMajor ? { rel: "in", point: third } : { rel: "not", point: third });
+      } else if (isMajor && explicitCircle) {
+        pushArc(c, name, a, b, { rel: "in", point: explicitCircle });
       } else {
         out.push({
           ruleId: "arcMidpoint",
@@ -2554,6 +2778,14 @@ var RE_CUT = new RegExp(
   THROUGH_LINE + "\\s+c\u1EAFt\\s+(?:\u0111\u01B0\u1EDDng\\s*(?:th\u1EB3ng\\s*)?)?([A-Z])([A-Z])(?!\\p{L})\\s+(?:t\u1EA1i|\u1EDF)\\s+(?:\u0111i\u1EC3m\\s+)?([A-Z])(?![A-Z])",
   "gu"
 );
+var FOOT2 = "([A-Z])([A-Z])\\s*,\\s*([A-Z])([A-Z])";
+var FOOT3 = "([A-Z])([A-Z])\\s*,\\s*([A-Z])([A-Z])\\s*,\\s*([A-Z])([A-Z])";
+var TARGET2 = "([A-Z]{2})\\s*,\\s*([A-Z]{2})(?![A-Z])";
+var TARGET3 = "([A-Z]{2})\\s*,\\s*([A-Z]{2})\\s*,\\s*([A-Z]{2})(?![A-Z])";
+var PERP_KW = "(?:l\u1EA7n\\s*l\u01B0\u1EE3t\\s+|theo\\s+th\u1EE9\\s+t\u1EF1\\s+)?(?:\u22A5|vu\xF4ng\\s*g\xF3c)\\s+(?:v\u1EDBi\\s+)?(?:c\xE1c\\s+)?(?:c\u1EA1nh\\s+|\u0111o\u1EA1n(?:\\s+th\u1EB3ng)?\\s+|\u0111\u01B0\u1EDDng\\s*th\u1EB3ng\\s+)?";
+var FROM = "(?:Qua|qua|T\u1EEB|t\u1EEB)\\s+(?:\u0111i\u1EC3m\\s+)?([A-Z])(?:['\u2032]?)(?!\\p{L})[^.]{0,16}?(?:k\u1EBB|v\u1EBD|d\u1EF1ng)\\s+";
+var PERP_NAMED_DISTRIB3 = new RegExp(FROM + FOOT3 + "\\s+" + PERP_KW + TARGET3, "gu");
+var PERP_NAMED_DISTRIB2 = new RegExp(FROM + FOOT2 + "\\s+" + PERP_KW + TARGET2, "gu");
 var PREFILTER6 = /(?:Qua|qua|Từ|từ)\s+(?:điểm\s+)?[A-Z][^.]{0,24}?(?:song\s*song|vuông\s*góc)|đường\s*thẳng\s+qua\s+[A-Z][^.]{0,24}?(?:song\s*song|vuông\s*góc)/u;
 function lineNameOf(isParallel, through) {
   return (isParallel ? "par" : "prp") + through;
@@ -2583,6 +2815,43 @@ var parallelPerpRule = {
         });
         cutSpans.push([start, end]);
       };
+      const emitNamedPerp = (from, foot, target, start, end) => {
+        if (foot === from || target.includes(foot)) return;
+        const lineName = lineNameOf(false, from) + foot;
+        out.push({
+          ruleId: "parallelPerp",
+          clauseIds: [c.id],
+          intents: [
+            drawLine(lineName, "perpThrough", { through: from, to: target }),
+            addPoint(foot, { kind: "intersection", of: [lineName, target] })
+          ]
+        });
+        cutSpans.push([start, end]);
+      };
+      PERP_NAMED_DISTRIB3.lastIndex = 0;
+      for (const m of c.text.matchAll(PERP_NAMED_DISTRIB3)) {
+        const from = m[1];
+        const triples = [
+          [m[3], m[8]],
+          [m[5], m[9]],
+          [m[7], m[10]]
+        ];
+        if ([m[2], m[4], m[6]].every((f) => f === from)) {
+          const s = m.index ?? 0;
+          const e = s + m[0].length;
+          for (const [foot, target] of triples) emitNamedPerp(from, foot, target, s, e);
+        }
+      }
+      PERP_NAMED_DISTRIB2.lastIndex = 0;
+      for (const m of c.text.matchAll(PERP_NAMED_DISTRIB2)) {
+        const s = m.index ?? 0;
+        if (cutSpans.some(([a, b]) => s >= a && s < b)) continue;
+        const from = m[1];
+        if (m[2] !== from || m[4] !== from) continue;
+        const pairs = [[m[3], m[6]], [m[5], m[7]]];
+        const e = s + m[0].length;
+        for (const [foot, target] of pairs) emitNamedPerp(from, foot, target, s, e);
+      }
       RE_GIAO.lastIndex = 0;
       for (const m of c.text.matchAll(RE_GIAO)) {
         emitCut(m[2], m[3], m[4], m[5], m[6] + m[7], m[1], m.index ?? 0, (m.index ?? 0) + m[0].length);
@@ -2616,12 +2885,23 @@ var REFLECT = /đối\s*xứng/u;
 var PT = `[A-Z](?:['\u2032])?`;
 var NAME_BEFORE4 = new RegExp(
   `(${PT})\\s+(?:l\xE0\\s+)?(?:\u0111i\u1EC3m\\s+)?\u0111\u1ED1i\\s*x\u1EE9ng\\s+(?:c\u1EE7a\\s+|v\u1EDBi\\s+)?(?:\u0111i\u1EC3m\\s+)?(${PT})\\s+qua\\s+(?:\u0111\u01B0\u1EDDng\\s*th\u1EB3ng\\s+|c\u1EA1nh\\s+|\u0111o\u1EA1n\\s+|tr\u1EE5c\\s+|trung\\s*\u0111i\u1EC3m\\s+|t\xE2m\\s+|\u0111i\u1EC3m\\s+)?([A-Za-z][A-Za-z\u2032']?)`,
-  "u"
+  "gu"
 );
 var DISTRIB2 = new RegExp(
   `(${PT})\\s*,\\s*(${PT})\\s+l\u1EA7n\\s*l\u01B0\u1EE3t\\s+(?:l\xE0\\s+)?(?:\u0111i\u1EC3m\\s+)?\u0111\u1ED1i\\s*x\u1EE9ng\\s+(?:c\u1EE7a\\s+|v\u1EDBi\\s+)?(?:\u0111i\u1EC3m\\s+)?(${PT})\\s+qua\\s+([A-Za-z]{1,2})(?:['\u2032]?)\\s*(?:,|v\xE0)\\s*([A-Za-z]{1,2})(?:['\u2032]?)`,
   "u"
 );
+var LL = `(?:l\u1EA7n\\s*l\u01B0\u1EE3t|t\u01B0\u01A1ng\\s*\u1EE9ng|(?:theo\\s+)?th\u1EE9\\s+t\u1EF1)`;
+var NAMES_BLOB2 = `(${PT}(?:\\s*(?:,|v\xE0)\\s*${PT})+)`;
+var SRCS_BLOB = `(${PT}(?:\\s*(?:,|v\xE0)\\s*${PT})+)`;
+var MIRRORS_BLOB = `([A-Za-z]{1,2}(?:['\u2032]?)(?:\\s*(?:,|v\xE0)\\s*[A-Za-z]{1,2}(?:['\u2032]?))+)`;
+var DISTRIB_MULTI = new RegExp(
+  `${NAMES_BLOB2}\\s+(?:${LL}\\s+)?(?:l\xE0\\s+)?(?:c\xE1c\\s+)?(?:\u0111i\u1EC3m\\s+)?\u0111\u1ED1i\\s*x\u1EE9ng\\s+(?:c\u1EE7a\\s+|v\u1EDBi\\s+)?(?:\u0111i\u1EC3m\\s+)?${SRCS_BLOB}\\s+(?:${LL}\\s+)?qua\\s+${MIRRORS_BLOB}`,
+  "u"
+);
+function splitList(blob) {
+  return blob.split(/\s*,\s*|\s+và\s+/u).map((s) => s.trim()).filter(Boolean);
+}
 var NAME_AFTER = new RegExp(
   `(?:\u0111i\u1EC3m\\s+)?\u0111\u1ED1i\\s*x\u1EE9ng\\s+(?:c\u1EE7a\\s+|v\u1EDBi\\s+)?(?:\u0111i\u1EC3m\\s+)?(${PT})\\s+qua\\s+(?:\u0111\u01B0\u1EDDng\\s*th\u1EB3ng\\s+|c\u1EA1nh\\s+|\u0111o\u1EA1n\\s+|tr\u1EE5c\\s+|trung\\s*\u0111i\u1EC3m\\s+|t\xE2m\\s+|\u0111i\u1EC3m\\s+)?([A-Za-z][A-Za-z\u2032']?)`,
   "u"
@@ -2632,10 +2912,10 @@ function normalizePointName(name) {
 var REFLECT_EN = /(?<![A-Za-z])([A-Z])(?:['′]?)\s+(?:is|be)\s+the\s+reflection\s+of\s+([A-Z])(?:['′]?)\s+(?:over|across|in|about|through)\s+(?:the\s+)?(?:line\s+|point\s+|segment\s+)?([A-Za-z][A-Za-z′']?)/u;
 var REFLECT_EN_PRE = /[Rr]eflection/u;
 function classifyThrough(raw) {
-  const z46 = raw.replace(/['′]/gu, "").trim();
-  if (/^[A-Z]$/u.test(z46)) return { kind: "point", value: z46 };
-  if (/^[A-Z][A-Z]$/u.test(z46)) return { kind: "line", value: z46 };
-  if (/^[a-z][A-Za-z0-9]*$/u.test(z46)) return { kind: "line", value: z46 };
+  const z47 = raw.replace(/['′]/gu, "").trim();
+  if (/^[A-Z]$/u.test(z47)) return { kind: "point", value: z47 };
+  if (/^[A-Z][A-Z]$/u.test(z47)) return { kind: "line", value: z47 };
+  if (/^[a-z][A-Za-z0-9]*$/u.test(z47)) return { kind: "line", value: z47 };
   return void 0;
 }
 var reflectionRule = {
@@ -2647,6 +2927,28 @@ var reflectionRule = {
     const out = [];
     for (const c of ctx.clauses) {
       if (!REFLECT.test(c.text) && !REFLECT_EN_PRE.test(c.text)) continue;
+      const dmm = DISTRIB_MULTI.exec(c.text);
+      if (dmm) {
+        const names = splitList(dmm[1]).map(normalizePointName);
+        const srcs = splitList(dmm[2]).map(normalizePointName);
+        const mirrors = splitList(dmm[3]);
+        if (names.length >= 2 && names.length === srcs.length && names.length === mirrors.length) {
+          const through2 = mirrors.map(classifyThrough);
+          if (through2.every((t) => !!t)) {
+            out.push({
+              ruleId: "reflection",
+              clauseIds: [c.id],
+              intents: names.map(
+                (nm, i) => addPoint(
+                  nm,
+                  through2[i].kind === "point" ? { kind: "reflectPoint", of: srcs[i], through: through2[i].value } : { kind: "reflectLine", of: srcs[i], through: through2[i].value }
+                )
+              )
+            });
+            continue;
+          }
+        }
+      }
       const dm = DISTRIB2.exec(c.text);
       if (dm) {
         const [n1, n2, ofPt, raw1, raw2] = [
@@ -2668,15 +2970,31 @@ var reflectionRule = {
           continue;
         }
       }
+      NAME_BEFORE4.lastIndex = 0;
+      const befores = [...c.text.matchAll(NAME_BEFORE4)];
+      if (befores.length) {
+        for (const b of befores) {
+          const nm = normalizePointName(b[1]);
+          const ofP = normalizePointName(b[2]);
+          const thr = classifyThrough(b[3]);
+          if (!thr) continue;
+          out.push({
+            ruleId: "reflection",
+            clauseIds: [c.id],
+            intents: [
+              addPoint(
+                nm,
+                thr.kind === "point" ? { kind: "reflectPoint", of: ofP, through: thr.value } : { kind: "reflectLine", of: ofP, through: thr.value }
+              )
+            ]
+          });
+        }
+        continue;
+      }
       let name;
       let of;
       let throughRaw;
-      const before = NAME_BEFORE4.exec(c.text);
-      if (before) {
-        name = normalizePointName(before[1]);
-        of = normalizePointName(before[2]);
-        throughRaw = before[3];
-      } else {
+      {
         const after = NAME_AFTER.exec(c.text);
         if (after) {
           name = extractPointName(c.text);
@@ -3179,7 +3497,7 @@ var DISTRIB_TWO = new RegExp(
   "gu"
 );
 var CAT_ONE_TWO = new RegExp(
-  `${REF}\\s+c\u1EAFt\\s+${REF}\\s*(?:,|v\xE0)\\s*${REF}\\s+(?:theo\\s+th\u1EE9\\s+t\u1EF1\\s+|l\u1EA7n\\s*l\u01B0\u1EE3t\\s+)?t\u1EA1i\\s+([A-Z])\\s*(?:,|v\xE0)\\s*(?:t\u1EA1i\\s+)?([A-Z])(?![A-Z])`,
+  `${REF}\\s+(?:l\u1EA7n\\s*l\u01B0\u1EE3t\\s+|theo\\s+th\u1EE9\\s+t\u1EF1\\s+)?c\u1EAFt\\s+${REF}\\s*(?:,|v\xE0)\\s*${REF}\\s+(?:theo\\s+th\u1EE9\\s+t\u1EF1\\s+|l\u1EA7n\\s*l\u01B0\u1EE3t\\s+)?t\u1EA1i\\s+([A-Z])\\s*(?:,|v\xE0)\\s*(?:t\u1EA1i\\s+)?([A-Z])(?![A-Z])`,
   "gu"
 );
 var CAT_TWO_ONE = new RegExp(
@@ -3194,12 +3512,22 @@ var CAT_ONE_RAY = new RegExp(
   `${REF}\\s+c\u1EAFt\\s+(?:tia\\s+)?(?:ti\u1EBFp\\s*tuy\u1EBFn\\s+)?(?:\u0111\u01B0\u1EDDng\\s*th\u1EB3ng\\s+)?([A-Z][a-z]|[a-z])(?![\\p{L}\\d])[^.;,]{0,40}?(?:t\u1EA1i|\u1EDF)\\s+(?:\u0111i\u1EC3m\\s+)?([A-Z])(?![A-Z])`,
   "gu"
 );
+var NAMED_CAT_TAI = new RegExp(
+  `(?:\u0111\u01B0\u1EDDng\\s*th\u1EB3ng\\s+|tia\\s+)?\\b([a-z]{1,2}[0-9]?)(?![\\p{L}\\d])\\s+(?:k\xE9o\\s+d\xE0i\\s+)?c\u1EAFt\\s+${REF}\\s+(?:k\xE9o\\s+d\xE0i\\s+)?(?:t\u1EA1i|\u1EDF)\\s+(?:\u0111i\u1EC3m\\s+)?([A-Z])(?![A-Z])`,
+  "gu"
+);
 var GIAO_TWO_ONE_LA = new RegExp(
   `giao\\s*\u0111i\u1EC3m\\s+(?:c\u1EE7a\\s+)?${REF}\\s*(?:,|v\xE0)\\s*${REF}\\s+v\u1EDBi\\s+${REF}\\s+(?:l\u1EA7n\\s*l\u01B0\u1EE3t\\s+|theo\\s+th\u1EE9\\s+t\u1EF1\\s+)?l\xE0\\s+([A-Z])\\s*(?:,|v\xE0)\\s*([A-Z])(?![A-Z])`,
   "gu"
 );
+var ZIP_MK = `(?:l\u1EA7n\\s*l\u01B0\u1EE3t|theo\\s+th\u1EE9\\s+t\u1EF1|t\u01B0\u01A1ng\\s+\u1EE9ng)`;
+var ZIP_SIDE = `(?:\u0111o\u1EA1n(?:\\s+th\u1EB3ng)?\\s+|c\u1EA1nh\\s+|tia\\s+|${DUONG_KW}\\s*th\u1EB3ng\\s+)?`;
 var CAT_ZIP = new RegExp(
-  `${REF}\\s*,\\s*${REF}\\s+(?:l\u1EA7n\\s*l\u01B0\u1EE3t\\s+|theo\\s+th\u1EE9\\s+t\u1EF1\\s+)c\u1EAFt\\s+(?:c\xE1c\\s+)?(?:\u0111o\u1EA1n(?:\\s+th\u1EB3ng)?\\s+|c\u1EA1nh\\s+|${DUONG_KW}\\s*th\u1EB3ng\\s+)?${REF}\\s*,\\s*${REF}\\s+(?:t\u1EA1i|\u1EDF)\\s+(?:\u0111i\u1EC3m\\s+)?([A-Z])\\s*(?:,|v\xE0)\\s*([A-Z])(?![A-Z])`,
+  `${REF}\\s*,\\s*${REF}\\s+${ZIP_MK}\\s+c\u1EAFt\\s+(?:c\xE1c\\s+)?${ZIP_SIDE}${REF}\\s*,\\s*${REF}\\s+(?:t\u1EA1i|\u1EDF)\\s+(?:\u0111i\u1EC3m\\s+)?([A-Z])\\s*(?:,|v\xE0)\\s*([A-Z])(?![A-Z])`,
+  "gu"
+);
+var CAT_ZIP_POST = new RegExp(
+  `${REF}\\s*,\\s*${REF}\\s+c\u1EAFt\\s+(?:c\xE1c\\s+)?${ZIP_SIDE}${REF}\\s*,\\s*${REF}\\s+${ZIP_MK}\\s+(?:t\u1EA1i|\u1EDF)\\s+(?:\u0111i\u1EC3m\\s+)?([A-Z])\\s*(?:,|v\xE0)\\s*([A-Z])(?![A-Z])`,
   "gu"
 );
 var NAME_BEFORE6 = /([A-Z])(?:['′]?)\s+là\s+$/u;
@@ -3214,6 +3542,10 @@ var CAP_SYMBOL = new RegExp(
   `(${PT2})\\s*=\\s*(${PT2})\\s*(${PT2})\\s*\u2229\\s*(${PT2})\\s*(${PT2})(?!${PT2})`,
   "gu"
 );
+var CAP_SYMBOL_POST = new RegExp(
+  `(${PT2})\\s*(${PT2})\\s*\u2229\\s*(${PT2})\\s*(${PT2})\\s*=\\s*\\{?\\s*(${PT2})\\s*\\}?`,
+  "gu"
+);
 var PTP = "[A-Z](?:['\u2032])?";
 var REFP = `(?:\u0111\u01B0\u1EDDng\\s*th\u1EB3ng\\s+|\u0111o\u1EA1n(?:\\s+th\u1EB3ng)?\\s+|tia\\s+|c\u1EA1nh\\s+)?(${PTP}\\s*${PTP})(?![A-Za-z])`;
 var GIAO_PRIMED = new RegExp(
@@ -3238,6 +3570,12 @@ function makeIntent(name, ref1, ref2) {
   if (ends.includes(name)) return null;
   return addPoint(name, { kind: "intersection", of: [ref1, ref2] });
 }
+function declaredNamedLines2(problem) {
+  const out = /* @__PURE__ */ new Set();
+  const RE31 = /(?:đường\s*thẳng|tiếp\s*tuyến|cát\s*tuyến)\s+([a-z]{1,2}[0-9]?)(?![\p{L}\d])/gu;
+  for (const m of problem.matchAll(RE31)) out.add(m[1]);
+  return out;
+}
 function makeIntentEnds(name, e1, e2, e3, e4) {
   const ends = [e1, e2, e3, e4];
   if (new Set(ends).size !== 4) return null;
@@ -3255,6 +3593,7 @@ var intersectionRule = {
   patterns: [PREFILTER8],
   match(ctx) {
     const out = [];
+    const namedLines = declaredNamedLines2(ctx.problem);
     for (const c of ctx.clauses) {
       const seen = /* @__PURE__ */ new Set();
       const emit = (name, ref1, ref2) => {
@@ -3278,6 +3617,15 @@ var intersectionRule = {
         seen.add(name);
         out.push({ ruleId: "intersection", clauseIds: [c.id], intents: [intent] });
       }
+      CAP_SYMBOL_POST.lastIndex = 0;
+      for (const m of c.text.matchAll(CAP_SYMBOL_POST)) {
+        const name = m[5];
+        if (seen.has(name)) continue;
+        const intent = makeIntentEnds(name, m[1], m[2], m[3], m[4]);
+        if (!intent) continue;
+        seen.add(name);
+        out.push({ ruleId: "intersection", clauseIds: [c.id], intents: [intent] });
+      }
       CAT_ONE_TWO.lastIndex = 0;
       for (const m of c.text.matchAll(CAT_ONE_TWO)) {
         emit(m[4], m[1], m[2]);
@@ -3309,6 +3657,12 @@ var intersectionRule = {
       for (const m of c.text.matchAll(CAT_ONE_RAY)) {
         emitShape(m[3], m[1], m[2]);
       }
+      if (namedLines.size > 0) {
+        NAMED_CAT_TAI.lastIndex = 0;
+        for (const m of c.text.matchAll(NAMED_CAT_TAI)) {
+          if (namedLines.has(m[1])) emitShape(m[3], m[2], m[1]);
+        }
+      }
       GIAO_TWO_ONE_LA.lastIndex = 0;
       for (const m of c.text.matchAll(GIAO_TWO_ONE_LA)) {
         emit(m[4], m[1], m[3]);
@@ -3319,6 +3673,11 @@ var intersectionRule = {
         emit(m[5], m[1], m[3]);
         emit(m[6], m[2], m[4]);
       }
+      CAT_ZIP_POST.lastIndex = 0;
+      for (const m of c.text.matchAll(CAT_ZIP_POST)) {
+        emit(m[5], m[1], m[3]);
+        emit(m[6], m[2], m[4]);
+      }
       GIAO_LA.lastIndex = 0;
       for (const m of c.text.matchAll(GIAO_LA)) emit(m[3], m[1], m[2]);
       GIAO_DIEM.lastIndex = 0;
@@ -3402,9 +3761,6 @@ var THETA_A = 2.3;
 var THETA_B = 0.7;
 var THETA_STEP = 0.9;
 var PREFILTER9 = /[Dd]ây/u;
-function escapeRe(s) {
-  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
 function findCircleClauseId(clauses, circle) {
   const frag = new RegExp(CIRCLE_KW + `|\\(\\s*${escapeRe(circle)}\\s*\\)`, "u");
   for (const c of clauses) if (frag.test(c.text)) return c.id;
@@ -3417,6 +3773,29 @@ function resolveCircle2(problem) {
   if (p) return p[1];
   return void 0;
 }
+function inscribedTriangleVertices(problem, circle) {
+  const out = /* @__PURE__ */ new Set();
+  const NAMED_O = "(?:\\(\\s*([^\\s;,).:]+)\\s*\\)|t\xE2m\\s+([A-Z]))?";
+  const TRI7 = "tam\\s*gi\xE1c\\s+(?:(?:nh\u1ECDn|c\xE2n|\u0111\u1EC1u|vu\xF4ng|t\xF9)\\s+)?([A-Z])([A-Z])([A-Z])(?![A-Z])";
+  const RE_A = new RegExp(TRI7 + "[^.]{0,40}?n\u1ED9i\\s*ti\u1EBFp\\s+(?:trong\\s+)?(?:" + CIRCLE_KW + ")?\\s*" + NAMED_O, "gu");
+  for (const m of problem.matchAll(RE_A)) {
+    const named = m[4] ?? m[5];
+    if (named && named !== circle) continue;
+    out.add(m[1]);
+    out.add(m[2]);
+    out.add(m[3]);
+  }
+  const NAMED_O_B = "(?:\\(\\s*([^\\s;,).:]+)\\s*\\)|t\xE2m\\s+([A-Z])|([A-Z]))?";
+  const RE_B = new RegExp(CIRCLE_KW + "\\s*" + NAMED_O_B + "\\s*ngo\u1EA1i\\s*ti\u1EBFp\\s+" + TRI7, "gu");
+  for (const m of problem.matchAll(RE_B)) {
+    const named = m[1] ?? m[2] ?? m[3];
+    if (named && named !== circle) continue;
+    out.add(m[4]);
+    out.add(m[5]);
+    out.add(m[6]);
+  }
+  return out;
+}
 var chordRule = {
   id: "chord",
   // Dưới circleRadius (75) — nếu circle O có bán kính cụ thể, định nghĩa đó thắng.
@@ -3430,6 +3809,7 @@ var chordRule = {
   match(ctx) {
     const circle = resolveCircle2(ctx.problem);
     if (!circle) return [];
+    const inscribedVerts = inscribedTriangleVertices(ctx.problem, circle);
     const chords = [];
     const seen = /* @__PURE__ */ new Set();
     for (const c of ctx.clauses) {
@@ -3464,15 +3844,11 @@ var chordRule = {
     });
     chords.forEach((ch, k) => {
       const offset = k * THETA_STEP;
-      out.push({
-        ruleId: "chord",
-        clauseIds: [ch.clauseId],
-        intents: [
-          addPoint(ch.a, { kind: "onCircle", circle, theta: THETA_A + offset }),
-          addPoint(ch.b, { kind: "onCircle", circle, theta: THETA_B + offset }),
-          connect(ch.a, ch.b, "segment")
-        ]
-      });
+      const intents = [];
+      if (!inscribedVerts.has(ch.a)) intents.push(addPoint(ch.a, { kind: "onCircle", circle, theta: THETA_A + offset }));
+      if (!inscribedVerts.has(ch.b)) intents.push(addPoint(ch.b, { kind: "onCircle", circle, theta: THETA_B + offset }));
+      intents.push(connect(ch.a, ch.b, "segment"));
+      out.push({ ruleId: "chord", clauseIds: [ch.clauseId], intents });
     });
     return out;
   }
@@ -3482,9 +3858,13 @@ var chordRule = {
 var PREFILTER10 = /tiếp\s*xúc|tiếp\s*điểm/u;
 var TANGENT_NAMED_FWD = /tiếp\s*điểm\s+(?:của\s+)?(?:đường\s*tròn\s*)?\(\s*([A-Z])\s*\)\s+với\s+(?:các\s+)?(?:(?:cạnh|đoạn)\s+)?([A-Z]{2}(?:\s*(?:,|và)\s*[A-Z]{2})*)\s+(?:lần\s*lượt\s+|theo\s+thứ\s+tự\s+)?là\s+(?:các\s+)?(?:điểm\s+)?([A-Z](?:\s*(?:,|và)\s*[A-Z])*)(?![A-Za-z])/iu;
 var TANGENT_NAMED_REV = /tiếp\s*điểm\s+(?:của\s+)?(?:các\s+)?(?:(?:cạnh|đoạn)\s+)?([A-Z]{2}(?:\s*(?:,|và)\s*[A-Z]{2})*)\s+với\s+(?:đường\s*tròn\s*)?\(\s*([A-Z])\s*\)\s+(?:lần\s*lượt\s+|theo\s+thứ\s+tự\s+)?là\s+(?:các\s+)?(?:điểm\s+)?([A-Z](?:\s*(?:,|và)\s*[A-Z])*)(?![A-Za-z])/iu;
+var TANGENT_NAMED_BEFORE = /([A-Z](?:\s*(?:,|và)\s*[A-Z])*)\s+(?:lần\s*lượt\s+|theo\s+thứ\s+tự\s+)?là\s+(?:các\s+)?(?:điểm\s+)?tiếp\s*điểm\s+(?:của\s+)?(?:các\s+)?(?:(?:cạnh|đoạn)\s+)?([A-Z]{2}(?:\s*(?:,|và)\s*[A-Z]{2})*)\s+với\s+(?:đường\s*tròn\s*)?\(\s*([A-Z])\s*\)/iu;
 var INCIRCLE_IN_CLAUSE = /đường\s*tròn\s*(?:\(\s*([A-Z])\s*\)|tâm\s+([A-Z]))?\s*nội\s*tiếp\s+tam\s*giác(?:\s+([A-Z])([A-Z])([A-Z])(?![A-Z]))?/iu;
 var SIDE_POINT_LIST = /tiếp\s*xúc\s+(?:với\s+)?(?:các\s+|ba\s+|hai\s+|bốn\s+)?(?:(?:cạnh|đoạn)\s+)?([A-Z]{2}(?:\s*(?:,|và)\s*[A-Z]{2})*)\s+(?:lần\s*lượt\s+|tương\s*ứng\s+)?tại\s+(?:các\s+|ba\s+|hai\s+|bốn\s+)?(?:điểm\s+)?([A-Z]'?(?:\s*(?:,|và)\s*[A-Z]'?)*)(?![A-Za-z])/iu;
 var REVERSED_SIDE_POINT = /(?:các\s+)?(?:cạnh|đoạn)\s+([A-Z]{2}(?:\s*(?:,|và)\s*[A-Z]{2})*)\s+tiếp\s*xúc\s+(?:với\s+)?(?:đường\s*tròn\s*)?\(\s*([A-Z])\s*\)\s+(?:lần\s*lượt\s+|tương\s*ứng\s+)?tại\s+(?:các\s+)?(?:điểm\s+)?([A-Z]'?(?:\s*(?:,|và)\s*[A-Z]'?)*)(?![A-Za-z])/iu;
+var INTERLEAVED_CIRCLE = /(?:đường\s*tròn\s*)?\(\s*([A-Z])\s*[,;]?\s*[Rr]?\s*\)\s*tiếp\s*xúc\s+(?:với\s+)?(?:(?:cạnh|đoạn)\s+)?([A-Z]{2}\s+tại\s+[A-Z]'?(?:\s*,\s*[A-Z]{2}\s+tại\s+[A-Z]'?)+)(?![A-Za-z])/iu;
+var PAIR_RE = /([A-Z]{2})\s+tại\s+([A-Z]'?)/giu;
+var REVERSED_BARE = /(?<![A-Za-z])([A-Z]{2}(?:\s*(?:,|và)\s*[A-Z]{2})*)\s+tiếp\s*xúc\s+(?:với\s+)?(?:đường\s*tròn\s*)?\(\s*([A-Z])\s*\)\s+(?:lần\s*lượt\s+|tương\s*ứng\s+)?tại\s+(?:các\s+)?(?:điểm\s+)?([A-Z]'?(?:\s*(?:,|và)\s*[A-Z]'?)*)(?![A-Za-z])/iu;
 function splitCsv(blob) {
   return blob.split(/,|và/iu).map((s) => s.trim()).filter(Boolean);
 }
@@ -3522,6 +3902,22 @@ var incircleTangencyRule = {
   match(ctx) {
     const out = [];
     for (const chunk of logicalChunks(ctx.problem, ctx.clauses)) {
+      const tb = TANGENT_NAMED_BEFORE.exec(chunk.text);
+      if (tb) {
+        const names = splitCsv(tb[1]);
+        const sides2 = splitCsv(tb[2]);
+        const circle2 = tb[3];
+        if (sides2.length >= 1 && sides2.length === names.length) {
+          const verts2 = [...new Set(sides2.join("").split(""))];
+          const intents2 = [];
+          if (verts2.length === 3) intents2.push(drawCircle(circle2, "inscribedIn", { triangle: verts2 }));
+          for (let i = 0; i < names.length; i++) {
+            intents2.push(addPoint(names[i], { kind: "tangencyPoint", circle: circle2, onLine: sides2[i] }));
+          }
+          out.push({ ruleId: "incircleTangency", clauseIds: chunk.clauseIds, intents: intents2 });
+          continue;
+        }
+      }
       const tn = TANGENT_NAMED_FWD.exec(chunk.text) ?? TANGENT_NAMED_REV.exec(chunk.text);
       if (tn) {
         const fwd = TANGENT_NAMED_FWD.test(chunk.text);
@@ -3539,6 +3935,20 @@ var incircleTangencyRule = {
           continue;
         }
       }
+      const il = INTERLEAVED_CIRCLE.exec(chunk.text);
+      if (il) {
+        const circle2 = il[1];
+        const pairs = [];
+        PAIR_RE.lastIndex = 0;
+        for (const pm of il[2].matchAll(PAIR_RE)) pairs.push([pm[1], pm[2]]);
+        if (pairs.length >= 1) {
+          const intents2 = pairs.map(
+            ([side, name]) => addPoint(name, { kind: "tangencyPoint", circle: circle2, onLine: side })
+          );
+          out.push({ ruleId: "incircleTangency", clauseIds: chunk.clauseIds, intents: intents2 });
+          continue;
+        }
+      }
       const rev = REVERSED_SIDE_POINT.exec(chunk.text);
       if (rev) {
         const sides2 = splitCsv(rev[1]);
@@ -3557,6 +3967,19 @@ var incircleTangencyRule = {
           continue;
         }
       }
+      const rb = REVERSED_BARE.exec(chunk.text);
+      if (rb) {
+        const sides2 = splitCsv(rb[1]);
+        const circle2 = rb[2];
+        const names = splitCsv(rb[3]);
+        if (sides2.length >= 1 && sides2.length === names.length) {
+          const intents2 = sides2.map(
+            (side, i) => addPoint(names[i], { kind: "tangencyPoint", circle: circle2, onLine: side })
+          );
+          out.push({ ruleId: "incircleTangency", clauseIds: chunk.clauseIds, intents: intents2 });
+          continue;
+        }
+      }
       let circle = parseIncircleName(chunk.text);
       if (!circle) {
         const fm = FORWARD_CIRCLE.exec(chunk.text);
@@ -3671,16 +4094,17 @@ var altitudeDiameterCirclesRule = {
 
 // src/stamps/geometry-2d/ai/rules/diameterCircleCutsSides.ts
 var PATTERN = new RegExp(
-  // Chỉ-báo đường tròn: "đường tròn (tâm X|(X))?" HOẶC "(X)" trần (httcd:2 "(O)
-  // đường kính BC" — KHÔNG có chữ "đường tròn"). Bắt buộc có 1 trong 2.
-  "(?:" + CIRCLE_KW + "\\s+(?:(?:\\(\\s*[A-Z]\\s*\\)|t\xE2m\\s+[A-Z])\\s+)?|\\(\\s*[A-Z]\\s*\\)\\s+)" + DUONG_KW + // optional phẩy + đại từ "nó" giữa diameter và "cắt" (vao10:81 "AH, cắt…").
-  // "theo thứ tự" = "lần lượt". Anchor điểm = "tại" (dạng "ở" tách sang
-  // PATTERN_O vì lazy-region dừng ở "ở" đầu tiên có thể nuốt thiếu — vao10:155).
-  "\\s*k\xEDnh\\s+([A-Z])([A-Z])(?![A-Z])\\s*,?\\s*(?:n\xF3\\s+)?\\s*c\u1EAFt\\s+([^.;\\n]*?)\\s+(?:(?:l\u1EA7n\\s*l\u01B0\u1EE3t|theo\\s+th\u1EE9\\s+t\u1EF1)\\s+)?t\u1EA1i\\s+([A-Z](?!\\p{L})(?:\\s*(?:,|v\xE0)\\s*[A-Z](?!\\p{L}))*)",
+  // Chỉ-báo đường tròn: "đường tròn ((X)|tâm X|X-trần)?" HOẶC "(X)" trần (httcd:2
+  // "(O) đường kính BC"). "X-trần" = tâm 1-HOA không ngoặc ("đường tròn O đường
+  // kính BC" — vxhung:14). Bắt buộc có 1 trong 2 nhánh.
+  "(?:" + CIRCLE_KW + "\\s+(?:(?:\\(\\s*[A-Z]\\s*\\)|t\xE2m\\s+[A-Z]|[A-Z])\\s+)?|\\(\\s*[A-Z]\\s*\\)\\s+)" + DUONG_KW + // optional phẩy + đại từ "nó" giữa diameter và "cắt" (vao10:81 "AH, cắt…").
+  // "theo thứ tự" = "lần lượt". Anchor điểm = "tại"; "(các)? (điểm)?" trước danh
+  // sách tên ("tại các điểm D và E" — vxhung:6).
+  "\\s*k\xEDnh\\s+([A-Z])([A-Z])(?![A-Z])\\s*,?\\s*(?:n\xF3\\s+)?\\s*c\u1EAFt\\s+([^.;\\n]*?)\\s+(?:(?:l\u1EA7n\\s*l\u01B0\u1EE3t|theo\\s+th\u1EE9\\s+t\u1EF1)\\s+)?t\u1EA1i\\s+(?:c\xE1c\\s+)?(?:\u0111i\u1EC3m\\s+)?([A-Z](?!\\p{L})(?:\\s*(?:,|v\xE0)\\s*[A-Z](?!\\p{L}))*)",
   "gu"
 );
 var PATTERN_O = new RegExp(
-  "(?:" + CIRCLE_KW + "\\s+(?:(?:\\(\\s*[A-Z]\\s*\\)|t\xE2m\\s+[A-Z])\\s+)?|\\(\\s*[A-Z]\\s*\\)\\s+)" + DUONG_KW + "\\s*k\xEDnh\\s+([A-Z])([A-Z])(?![A-Z])\\s*,?\\s*(?:n\xF3\\s+)?\\s*c\u1EAFt\\s+([^.;\\n]*?)\\s+(?:(?:l\u1EA7n\\s*l\u01B0\u1EE3t|theo\\s+th\u1EE9\\s+t\u1EF1)\\s+)?\u1EDF\\s+([A-Z](?!\\p{L})(?:\\s*(?:,|v\xE0)\\s*[A-Z](?!\\p{L}))+)",
+  "(?:" + CIRCLE_KW + "\\s+(?:(?:\\(\\s*[A-Z]\\s*\\)|t\xE2m\\s+[A-Z]|[A-Z])\\s+)?|\\(\\s*[A-Z]\\s*\\)\\s+)" + DUONG_KW + "\\s*k\xEDnh\\s+([A-Z])([A-Z])(?![A-Z])\\s*,?\\s*(?:n\xF3\\s+)?\\s*c\u1EAFt\\s+([^.;\\n]*?)\\s+(?:(?:l\u1EA7n\\s*l\u01B0\u1EE3t|theo\\s+th\u1EE9\\s+t\u1EF1)\\s+)?\u1EDF\\s+(?:c\xE1c\\s+)?(?:\u0111i\u1EC3m\\s+)?([A-Z](?!\\p{L})(?:\\s*(?:,|v\xE0)\\s*[A-Z](?!\\p{L}))+)",
   "gu"
 );
 var PATTERN_INTERLEAVED = new RegExp(
@@ -3779,6 +4203,10 @@ var GIVEN_BARE = new RegExp(
   String.raw`[Cc]ho\s+\(\s*(${CTR})\s*\)\s*,?\s*(?:có\s+)?` + DUONG_KW + String.raw`\s*kính\s+([A-Z])([A-Z])(?![A-Z])`,
   "gu"
 );
+var CHO_BARE = new RegExp(
+  String.raw`[Cc]ho\s+(${CTR})(?![A-Z\p{L}])\s+` + DUONG_KW + String.raw`\s*kính\s+([A-Z])([A-Z])(?![A-Z])`,
+  "gu"
+);
 var BARE_PAREN = new RegExp(
   String.raw`\(\s*(${CTR})\s*\)\s*(?:có\s+)?` + DUONG_KW + String.raw`\s*kính\s+([A-Z])([A-Z])(?![A-Z])`,
   "gu"
@@ -3869,6 +4297,22 @@ var circleDiameterRule = {
         intents: intentsFor(p)
       });
     }
+    CHO_BARE.lastIndex = 0;
+    let cm;
+    while ((cm = CHO_BARE.exec(ctx.problem)) !== null) {
+      const p = { center: cm[1], a: cm[2], b: cm[3] };
+      if (!p.center || p.center === p.a || p.center === p.b || p.a === p.b) continue;
+      const key = `${p.center}|${p.a}${p.b}`;
+      if (emitted.has(key)) continue;
+      emitted.add(key);
+      const matched = cm[0];
+      const claim = ctx.clauses.filter((c) => c.text.includes(matched.replace(/^[Cc]ho\s+/u, ""))).map((c) => c.id);
+      out.push({
+        ruleId: "circle-diameter",
+        clauseIds: claim.length > 0 ? claim : [ctx.clauses[0]?.id ?? 0],
+        intents: intentsFor(p)
+      });
+    }
     BARE_PAREN.lastIndex = 0;
     let bm;
     while ((bm = BARE_PAREN.exec(ctx.problem)) !== null) {
@@ -3879,7 +4323,7 @@ var circleDiameterRule = {
       const key = `${center}|${a}${b}`;
       if (emitted.has(key)) continue;
       const before = ctx.problem.slice(0, bm.index);
-      const known = (p) => new RegExp(`(?<![a-z])${p}(?![a-z])`, "u").test(before);
+      const known = (p) => new RegExp(`(?<![a-z])${escapeRe(p)}(?![a-z])`, "u").test(before);
       if (!known(a) || !known(b)) continue;
       emitted.add(key);
       const matched = bm[0];
@@ -3901,7 +4345,7 @@ var circleDiameterRule = {
 var PREFILTER12 = /(?:nằm|thuộc|lấy\s+điểm|trên\s+(?:nửa\s+)?(?:đường\s*tròn|cung))/iu;
 var NAMED_CIRCLE = /(?:nửa\s+)?đường\s*tròn\s*(?:tâm\s+)?\(?\s*([A-Z])(?:\s*[;,]\s*[Rr])?\s*\)?/u;
 var COMPACT_CIRCLE = /\(\s*([A-Z])\s*[;,]\s*[Rr]\s*\)/u;
-var ON_SUFFIX = "(?:cung\\s+(?:nh\u1ECF\\s+|l\u1EDBn\\s+)?[A-Z]{2}(?:\\s*(?:nh\u1ECF|l\u1EDBn))?|(?:n\u1EEDa\\s+)?\u0111\u01B0\u1EDDng\\s*tr\xF2n|\\(\\s*[A-Z]\\s*\\))";
+var ON_SUFFIX = "(?:cung\\s+(?:nh\u1ECF\\s+|l\u1EDBn\\s+)?[A-Z]{2}(?:\\s*(?:nh\u1ECF|l\u1EDBn))?|(?:n\u1EEDa\\s+)?\u0111\u01B0\u1EDDng\\s*tr\xF2n|(?:\u0111\u01B0\u1EDDng\\s+)?\\(\\s*[A-Z]\\s*\\))";
 var POINT_ON = new RegExp(
   // "nằm" optional → bắt "M (bất kì)? trên (nửa)? đường tròn" / "điểm A trên (O)"
   // (chỉ "trên" trần, không "nằm trên"). ON_SUFFIX neo circle/cung nên "trên"
@@ -3922,18 +4366,21 @@ var TAKE_ON_CUNG = /[Tt]rên\s+cung\s+(?:nhỏ\s+|lớn\s+)?[A-Z]{2}(?:\s*(?:nh
 var TAKE_ON_REV = /[Tt]rên\s+(?:nửa\s+)?(?:đường\s*tròn|cung)\s*\(\s*([A-Z])(?:\s*[;,]\s*[Rr])?\s*\)[^.]{0,16}?lấy\s+điểm\s+([A-Z])(?![A-Z])/u;
 var TWO_ON = /(?:lấy\s+)?hai\s*điểm\s+([A-Z])(?![A-Za-z])\s+và\s+([A-Z])(?![A-Za-z])(?:\s+bất\s*k[ìiyỳ])?\s+thuộc\s+(?:nửa\s+)?(?:đường\s*tròn|cung)/u;
 var TWO_ON_COMMA = /(?:[CcNn]ác\s+|[Nn]hững\s+)?điểm\s+([A-Z])(?![A-Za-z])\s*,\s*([A-Z])(?![A-Za-z])\s+thuộc\s+(?:nửa\s+)?(?:đường\s*tròn|cung)/u;
-var TWO_ON_NAMES = /([A-Z])(?![A-Za-z])\s*,\s*([A-Z])(?![A-Za-z])\s+là\s+(?:hai|các)\s+điểm\s+(?:thuộc|nằm\s+trên|trên)\s+(?:(?:nửa\s+)?(?:đường\s*tròn|cung)|\(\s*[A-Z]\s*\))/u;
+var TWO_ON_NAMES = /([A-Z])(?![A-Za-z])\s*(?:,|và)\s*([A-Z])(?![A-Za-z])\s+là\s+(?:hai|các)\s+điểm\s+(?:thuộc|nằm\s+trên|trên)\s+(?:(?:nửa\s+)?(?:đường\s*tròn|cung)|\(\s*[A-Z]\s*\))/u;
 var TWO_ON_CUNG_REV = /[Tt]rên\s+cung\s+(?:nhỏ\s+|lớn\s+)?[A-Z]{2}(?:\s*(?:nhỏ|lớn))?\s+lấy\s+hai\s+điểm\s+([A-Z])(?![A-Za-z])\s*(?:,|và)\s*([A-Z])(?![A-Za-z])/u;
 var BARE_CIRCLE = /\(\s*([A-Z])\s*\)/u;
 var UNNAMED_DIAMETER = /(?:nửa\s+)?đường\s*tròn\s+đường\s*kính\s+([A-Z])([A-Z])(?![A-Z])/u;
+var BARE_CENTER_DIAMETER = /(?<![\p{L}\d(])([A-Z])\s+đường\s*kính/u;
 function resolveCircle3(problem) {
   const m = NAMED_CIRCLE.exec(problem) ?? COMPACT_CIRCLE.exec(problem) ?? BARE_CIRCLE.exec(problem);
   if (!m) {
     const dm = UNNAMED_DIAMETER.exec(problem);
-    return dm ? `k${dm[1]}${dm[2]}` : void 0;
+    if (dm) return `k${dm[1]}${dm[2]}`;
+    const bd = BARE_CENTER_DIAMETER.exec(problem);
+    return bd ? `${bd[1]}_c` : void 0;
   }
   const center = m[1];
-  const c = center.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const c = escapeRe(center);
   const diameterOfThisCenter = new RegExp(`(?:\\(\\s*${c}\\s*[;,)]|t\xE2m\\s+${c}(?![A-Za-z]))[^.]{0,25}?\u0111\u01B0\u1EDDng\\s*k\xEDnh`, "u").test(problem) || new RegExp(`\u0111\u01B0\u1EDDng\\s*k\xEDnh[^.]{0,25}?\\(\\s*${c}\\s*\\)`, "u").test(problem);
   return diameterOfThisCenter ? `${center}_c` : center;
 }
@@ -3978,10 +4425,12 @@ var onCirclePointRule = {
       if (!m) continue;
       const name = m[1];
       if (name.length !== 1) continue;
+      const major = /cung\s+lớn|lớn\s+[A-Z]{2}/u.test(c.text);
+      const ptTheta = major ? -1.6 : theta;
       out.push({
         ruleId: "on-circle-point",
         clauseIds: [c.id],
-        intents: [addPoint(name, { kind: "onCircle", circle, theta })]
+        intents: [addPoint(name, { kind: "onCircle", circle, theta: ptTheta })]
       });
       theta += 0.8;
     }
@@ -3990,10 +4439,10 @@ var onCirclePointRule = {
 };
 
 // src/stamps/geometry-2d/ai/rules/tangentAt.ts
-var PREFILTER13 = /[Tt]iếp\s*tuyến\s+(?:với\s+|của\s+)?(?:đường\s*tròn\s*)?(?:\([^)]*\)\s*)?tại/u;
+var PREFILTER13 = /[Tt]iếp\s*tuyến\s+(?:với\s+|của\s+)?(?:đường\s*tròn\s*)?(?:\([^)]*\)\s*)?(?:tại|qua)/u;
 var CIRCLE_REF = /đường\s*tròn\s*\(\s*([A-Z])(?:\s*[;,]\s*[Rr])?\s*\)|\(\s*([A-Z])(?:\s*[;,]\s*[Rr])?\s*\)/u;
 var DISTRIB3 = /[Tt]iếp\s*tuyến\s+tại\s+([A-Z])\s+cắt\s+tiếp\s*tuyến\s+tại\s+([A-Z])\s+và\s+([A-Z])[^.]{0,60}?lần\s*lượt\s+tại\s+([A-Z])\s+và\s+([A-Z])/u;
-var TWO_MEET = /[Tt]iếp\s*tuyến\s+(?:với\s+|của\s+)?(?:đường\s*tròn\s*)?(?:\(\s*[A-Z]['′]?\s*\)\s*)?tại\s+([A-Z])\s*(?:,|và)\s*([A-Z])(?![A-Z])[^.]{0,30}?cắt\s+nhau\s+(?:ở|tại)\s+([A-Z])(?![A-Z])/u;
+var TWO_MEET = /[Tt]iếp\s*tuyến\s+(?:với\s+|của\s+)?(?:đường\s*tròn\s*)?(?:\(\s*[A-Z]['′]?\s*\)\s*)?(?:tại|qua)\s+([A-Z])\s*(?:,|và)\s*([A-Z])(?![A-Z])[^.]{0,30}?cắt\s+nhau\s+(?:ở|tại)\s+([A-Z])(?![A-Z])/u;
 var SINGLE2 = /[Tt]iếp\s*tuyến\s+tại\s+(?:điểm\s+)?([A-Z])(?:\s+với|\s+của|\s+đường|\s*$)/u;
 function circleName(problem) {
   const m = CIRCLE_REF.exec(problem);
@@ -4064,17 +4513,37 @@ var tangentAtRule = {
 };
 
 // src/stamps/geometry-2d/ai/rules/onSegmentPoint.ts
-var PREFILTER14 = /(?:thuộc\s+(?:các\s+|hai\s+|ba\s+)?(?:cạnh|đoạn|đáy|tia|bán\s*kính|đường\s*kính|dây|[A-Z]{2})|[Tt]rên\s+(?:các\s+|hai\s+|ba\s+)?(?:cạnh|đoạn|đáy|tia|bán\s*kính|đường\s*kính|đường\s*thẳng|dây|[A-Z]{2})|(?:di\s*chuyển|di\s*động)\s+trên|nằm\s+giữa)/u;
+var PREFILTER14 = /(?:thuộc\s+(?:các\s+|hai\s+|ba\s+)?(?:cạnh|đoạn|đáy|tia|bán\s*kính|đường\s*kính|dây|[A-Za-z]{1,2}[0-9]?(?![\p{L}\d]))|[Tt]rên\s+(?:các\s+|hai\s+|ba\s+)?(?:cạnh|đoạn|đáy|tia|bán\s*kính|đường\s*kính|đường\s*thẳng|dây|[A-Za-z]{1,2}[0-9]?(?![\p{L}\d]))|(?:di\s*chuyển|di\s*động)\s+trên|nằm\s+giữa)/u;
 var ON_NAMED_LINE = new RegExp(
   String.raw`[Tt]rên\s+đường\s*thẳng\s+([a-z][0-9]?)(?!\p{L})[^.]{0,20}?(?:lấy\s+)?(?:một\s+)?(?:điểm\s+)?([A-Z](?:['′])?)(?![A-Z])`,
   "gu"
 );
+var ON_NAMED_LINE_BARE = new RegExp(
+  String.raw`[Tt]rên\s+([a-z]{1,2}[0-9]?)(?![\p{L}\d])\s+(?:lấy\s+)?(?:một\s+)?(?:điểm\s+)?([A-Z](?:['′])?)(?![A-Z])`,
+  "gu"
+);
+var POINT_THUOC_NAMED_BARE = new RegExp(
+  String.raw`(?:điểm\s+)?([A-Z](?:['′])?)(?![A-Z])\s+(?:là\s+(?:một\s+)?điểm\s+(?:bất\s*k[iìyỳ]\s+)?)?thuộc\s+([a-z]{1,2}[0-9]?)(?![\p{L}\d])`,
+  "gu"
+);
 var SEG = "([A-Z]{2})(?![A-Z])";
 var POINT = "([A-Z](?:['\u2032])?)(?![A-Z])";
+var TAKE_POINT_ON_SEG = new RegExp(
+  String.raw`[Ll]ấy\s+(?:điểm\s+)?${POINT}\s+(?:bất\s*k[iìyỳ]\s+)?(?:trên|thuộc)\s+(?:cạnh\s+|đáy\s+|đoạn(?:\s+thẳng)?\s+|tia\s+|bán\s*kính\s+|đường\s*kính\s+)?${SEG}`,
+  "gu"
+);
+var TAKE_TWO_ON_TWO_SEG = new RegExp(
+  String.raw`[Ll]ấy\s+(?:điểm\s+)?([A-Z](?:['′])?)\s*,\s*([A-Z](?:['′])?)(?![A-Z])\s+(?:bất\s*k[iìyỳ]\s+)?(?:trên|thuộc)\s+(?:các\s+)?(?:cạnh\s+|đoạn\s+|tia\s+)?([A-Z]{2})\s*(?:,|và)\s*([A-Z]{2})(?![A-Z])`,
+  "gu"
+);
 var ON_SEG_THEN_POINT = new RegExp(
   String.raw`[Tt]rên\s+(?:cạnh|đáy|đoạn(?:\s+thẳng)?|bán\s*kính|đường\s*kính|dây\s*(?:cung)?)\s+${SEG}[^.]{0,30}?(?:lấy\s+)?(?:một\s+)?(?:điểm\s+)?${POINT}`,
   "gu"
 );
+var ON_BARE_SEG_THEN_POINT = new RegExp(
+  String.raw`[Tt]rên\s+${SEG}[^.]{0,14}?\blấy\s+(?:một\s+)?(?:điểm\s+)?${POINT}`,
+  "gu"
+);
 var ON_SEG_MULTI_POINT = new RegExp(
   String.raw`[Tt]rên\s+(?:cạnh\s+|đáy\s+|đoạn(?:\s+thẳng)?\s+)?${SEG}\s+(?:lấy\s+)?(?:các\s+)?(?:điểm\s+)?((?:[A-Z](?:['′])?\s*,\s*)+[A-Z](?:['′])?)(?![A-Z])`,
   "gu"
@@ -4108,13 +4577,17 @@ var ZIP_SEG = new RegExp(
   "gu"
 );
 var SEGS_THEN_POINTS = new RegExp(
-  String.raw`[Tt]rên\s+(?:các\s+)?(?:cạnh\s+|đoạn(?:\s+thẳng)?\s+|đáy\s+|bán\s*kính\s+)?((?:[A-Z]{2}\s*,\s*)+[A-Z]{2})(?![A-Z])(?:\s+của\s+(?:tam\s*giác\s+|tứ\s*giác\s+)?[A-Z]{2,4})?\s+(?:(?:theo\s+)?thứ\s+tự\s+|lần\s*lượt\s+)?lấy\s+(?:các\s+)?điểm\s+((?:[A-Z]\s*,\s*)+[A-Z])(?![A-Z])`,
+  String.raw`[Tt]rên\s+(?:các\s+)?(?:cạnh\s+|đoạn(?:\s+thẳng)?\s+|đáy\s+|bán\s*kính\s+)?((?:[A-Z]{2}\s*,\s*)+[A-Z]{2})(?![A-Z])(?:\s+của\s+(?:tam\s*giác\s+|tứ\s*giác\s+)?[A-Z]{2,4})?\s+(?:(?:theo\s+)?thứ\s+tự\s+|lần\s*lượt\s+)?lấy\s+(?:các\s+)?(?:điểm\s+)?((?:[A-Z]\s*,\s*)+[A-Z])(?![A-Z])`,
   "gu"
 );
 var TWO_SEG_LAY = new RegExp(
   String.raw`[Tt]rên\s+(?:cạnh|đáy|đoạn(?:\s+thẳng)?)\s+${SEG}\s+(?:lấy\s+)?(?:một\s+)?(?:điểm\s+)?${POINT}\s+và\s+(?:trên\s+)?(?:cạnh|đáy|đoạn(?:\s+thẳng)?)\s+${SEG}\s+(?:lấy\s+)?(?:một\s+)?(?:điểm\s+)?${POINT}`,
   "gu"
 );
+var TWO_ON_NAMED_RAY = new RegExp(
+  String.raw`[Tt]rên\s+(?:tia\s+)?([A-Z][xyzt])(?!\p{L})\s+(?:lấy\s+)?(?:hai\s+|2\s+)?(?:điểm\s+)?([A-Z](?:['′])?)(?![A-Z])\s*(?:,|và)\s*([A-Z](?:['′])?)(?![A-Z])`,
+  "gu"
+);
 function normalizePoint(name) {
   return name.replace("\u2032", "'");
 }
@@ -4124,6 +4597,18 @@ function validOnSegment(name, segment) {
 function hasMetricConstraint(text) {
   return /sao\s+cho[^.]{0,40}(?:=|>|<)/u.test(text);
 }
+function declaredNamedLines3(problem) {
+  const out = /* @__PURE__ */ new Set();
+  const RE31 = /(?:đường\s*thẳng|tiếp\s*tuyến|cát\s*tuyến)\s+([a-z]{1,2}[0-9]?)(?![\p{L}\d])/gu;
+  for (const m of problem.matchAll(RE31)) out.add(m[1]);
+  return out;
+}
+function declaredNamedRays(problem) {
+  const out = /* @__PURE__ */ new Set();
+  const RE31 = /tiếp\s*tuyến\s+([A-Z][xyzt])(?![A-Za-z])/gu;
+  for (const m of problem.matchAll(RE31)) out.add(m[1]);
+  return out;
+}
 var onSegmentPointRule = {
   id: "on-segment-point",
   priority: 62,
@@ -4131,8 +4616,73 @@ var onSegmentPointRule = {
   patterns: [PREFILTER14],
   match(ctx) {
     const out = [];
+    const namedLines = declaredNamedLines3(ctx.problem);
+    const namedRays = declaredNamedRays(ctx.problem);
     for (const c of ctx.clauses) {
       const intents = [];
+      ON_NAMED_LINE.lastIndex = 0;
+      for (const m of c.text.matchAll(ON_NAMED_LINE)) {
+        const line = m[1];
+        const name = normalizePoint(m[2]);
+        if (/^[A-Z]['′]?$/u.test(name)) intents.push(addPoint(name, { kind: "onSegment", of: line }));
+      }
+      if (namedLines.size > 0) {
+        ON_NAMED_LINE_BARE.lastIndex = 0;
+        for (const m of c.text.matchAll(ON_NAMED_LINE_BARE)) {
+          const line = m[1];
+          const name = normalizePoint(m[2]);
+          if (namedLines.has(line) && /^[A-Z]['′]?$/u.test(name)) {
+            intents.push(addPoint(name, { kind: "onSegment", of: line }));
+          }
+        }
+        POINT_THUOC_NAMED_BARE.lastIndex = 0;
+        for (const m of c.text.matchAll(POINT_THUOC_NAMED_BARE)) {
+          const name = normalizePoint(m[1]);
+          const line = m[2];
+          if (namedLines.has(line) && /^[A-Z]['′]?$/u.test(name)) {
+            intents.push(addPoint(name, { kind: "onSegment", of: line }));
+          }
+        }
+      }
+      if (namedRays.size > 0) {
+        TWO_ON_NAMED_RAY.lastIndex = 0;
+        for (const m of c.text.matchAll(TWO_ON_NAMED_RAY)) {
+          const ray = m[1];
+          if (!namedRays.has(ray)) continue;
+          for (const raw of [m[2], m[3]]) {
+            const name = normalizePoint(raw);
+            if (/^[A-Z]['′]?$/u.test(name) && name[0] !== ray[0]) {
+              intents.push(addPoint(name, { kind: "onSegment", of: ray }));
+            }
+          }
+        }
+      }
+      if (!/tia\s+đối/u.test(c.text)) {
+        TAKE_TWO_ON_TWO_SEG.lastIndex = 0;
+        for (const m of c.text.matchAll(TAKE_TWO_ON_TWO_SEG)) {
+          const [n1, n2, s1, s2] = [normalizePoint(m[1]), normalizePoint(m[2]), m[3], m[4]];
+          if (validOnSegment(n1, s1) && validOnSegment(n2, s2)) {
+            intents.push(addPoint(n1, { kind: "onSegment", of: s1 }));
+            intents.push(addPoint(n2, { kind: "onSegment", of: s2 }));
+          }
+        }
+        TAKE_POINT_ON_SEG.lastIndex = 0;
+        for (const m of c.text.matchAll(TAKE_POINT_ON_SEG)) {
+          const name = normalizePoint(m[1]);
+          const segment = m[2];
+          if (validOnSegment(name, segment)) {
+            intents.push(addPoint(name, { kind: "onSegment", of: segment }));
+          }
+        }
+        ON_BARE_SEG_THEN_POINT.lastIndex = 0;
+        for (const m of c.text.matchAll(ON_BARE_SEG_THEN_POINT)) {
+          const segment = m[1];
+          const name = normalizePoint(m[2]);
+          if (validOnSegment(name, segment)) {
+            intents.push(addPoint(name, { kind: "onSegment", of: segment }));
+          }
+        }
+      }
       SEGS_THEN_POINTS.lastIndex = 0;
       for (const m of c.text.matchAll(SEGS_THEN_POINTS)) {
         const segs = m[1].split(",").map((s) => s.trim());
@@ -4192,12 +4742,6 @@ var onSegmentPointRule = {
         if (intents.length > 0) out.push({ ruleId: "on-segment-point", clauseIds: [c.id], intents });
         continue;
       }
-      ON_NAMED_LINE.lastIndex = 0;
-      for (const m of c.text.matchAll(ON_NAMED_LINE)) {
-        const line = m[1];
-        const name = normalizePoint(m[2]);
-        if (/^[A-Z]['′]?$/u.test(name)) intents.push(addPoint(name, { kind: "onSegment", of: line }));
-      }
       ON_SEG_THEN_POINT.lastIndex = 0;
       for (const m of c.text.matchAll(ON_SEG_THEN_POINT)) {
         const segment = m[1];
@@ -4249,7 +4793,7 @@ var onSegmentPointRule = {
 };
 
 // src/stamps/geometry-2d/ai/rules/lineCircleIntersection.ts
-var PREFILTER15 = /cắt\s+(?:lại\s+)?(?:(?:nửa\s+)?đường\s*tròn\s*)?\(|cắt\s+(?:lại\s+)?(?:nửa\s+)?đường\s*tròn\s+(?:ở|tại)|cắt\s+[A-Z]{2}\s+và\s+\(|giao\s*điểm\s+(?:thứ\s+hai\s+)?(?:của\s+|khác\s+[A-Z]\s+của\s+)?(?:đường\s*thẳng\s+)?[A-Z]{2}\s+(?:và|với)\s+(?:(?:nửa\s+)?đường\s*tròn|\(|ngoại\s*tiếp\s+tam\s*giác)/u;
+var PREFILTER15 = /cắt\s+(?:lại\s+)?(?:(?:nửa\s+)?đường\s*tròn\s*)?\(|cắt\s+(?:lại\s+)?(?:nửa\s+)?đường\s*tròn\s+(?:tâm\s+[A-Z](?:['′])?\s+)?(?:ở|tại)|cắt\s+[A-Z]{2}\s+và\s+\(|\(\s*[A-Z](?:['′]?)\s*(?:[;,]\s*[Rr]\s*)?\)\s+cắt\s+(?:lại\s+)?[A-Z]{2}\s*(?:,|và)?\s*(?:[A-Z]{2})?\s+(?:lần\s*lượt\s+|theo\s+thứ\s+tự\s+|tương\s+ứng\s+)?(?:ở|tại)|\(\s*[A-Z]{3}\s*\)\s*(?:,|và)\s*\(\s*[A-Z]{3}\s*\)\s+cắt|giao\s*điểm\s+(?:thứ\s+hai\s+)?(?:của\s+|khác\s+[A-Z]\s+của\s+)?(?:đường\s*thẳng\s+)?[A-Z]{2}(?:\s*,\s*[A-Z]{2})?\s+(?:và|với)\s+(?:(?:nửa\s+)?đường\s*tròn|\(|ngoại\s*tiếp\s+tam\s*giác)/u;
 var CIRCLE = String.raw`(?:(?:nửa\s+)?đường\s*tròn\s*)?\(\s*([A-Z])(?:['′]?)\s*(?:[;,]\s*[Rr]\s*)?\)`;
 var CIRCLE_P = String.raw`(?:(?:nửa\s+)?đường\s*tròn\s*)?\(\s*([A-Z](?:['′])?)\s*(?:[;,]\s*[Rr]\s*)?\)`;
 var PERP_CUTS_CIRCLE = new RegExp(
@@ -4265,13 +4809,21 @@ var DOUBLE_DISTRIB = new RegExp(
   "gu"
 );
 var SINGLE3 = new RegExp(
-  String.raw`([A-Z]{2})(?![A-Z])\s+cắt\s+(?:lại\s+)?` + CIRCLE + String.raw`\s+(?:ở|tại)\s+(?:điểm\s+(?:thứ\s+hai\s+)?)?(?:là\s+)?([A-Z])(?![A-Z])(?:\s+khác\s+([A-Z])(?![A-Z]))?`,
+  String.raw`([A-Z]{2})(?![A-Z])\s+(?:kéo\s+dài\s+)?cắt\s+(?:lại\s+)?` + CIRCLE + String.raw`\s+(?:ở|tại)\s+(?:điểm\s+(?:thứ\s+hai\s+)?)?(?:là\s+)?([A-Z])(?![A-Z])(?:\s+khác\s+([A-Z])(?![A-Z]))?`,
+  "gu"
+);
+var SINGLE_NAMED_CENTER = new RegExp(
+  String.raw`([A-Z]{2})(?![A-Z])\s+(?:kéo\s+dài\s+)?cắt\s+(?:lại\s+)?(?:nửa\s+)?đường\s*tròn\s+tâm\s+([A-Z](?:['′])?)(?![A-Za-z])` + String.raw`\s+(?:ở|tại)\s+(?:điểm\s+(?:thứ\s+hai\s+)?)?(?:là\s+)?([A-Z])(?![A-Z])`,
   "gu"
 );
 var BOTH = new RegExp(
   String.raw`([A-Z]{2})(?![A-Z])\s+cắt\s+` + CIRCLE + String.raw`\s+(?:ở|tại)\s+(?:hai\s+|các\s+)?điểm\s+(?:phân\s*biệt\s+)?([A-Z])\s*(?:,|và)\s*([A-Z])(?![A-Z])`,
   "gu"
 );
+var TWO_NAMED = new RegExp(
+  String.raw`([A-Z]{2})(?![A-Z])\s+(?:kéo\s+dài\s+)?cắt\s+(?:lại\s+)?` + CIRCLE + String.raw`\s+(?:ở|tại)\s+([A-Z])\s+và\s+([A-Z])(?![A-Z])`,
+  "gu"
+);
 var LINE_AND_CIRCLE = new RegExp(
   String.raw`([A-Z]{2})(?![A-Z])\s+cắt\s+([A-Z]{2})(?![A-Z])\s+và\s+` + CIRCLE + String.raw`\s+(?:lần\s*lượt\s+|theo\s+thứ\s+tự\s+)?(?:tại|ở)\s+([A-Z])\s*(?:,|và)\s*([A-Z])(?![A-Z])`,
   "gu"
@@ -4288,12 +4840,16 @@ var CIRCLE_SUBJECT = new RegExp(
   CIRCLE + String.raw`\s+cắt\s+(?:lại\s+)?([A-Z]{2})(?![A-Z])\s+(?:ở|tại)\s+(?:điểm\s+(?:thứ\s+hai\s+)?)?(?:là\s+)?([A-Z])(?![A-Z])`,
   "gu"
 );
+var CIRCLE_SUBJECT_TWO = new RegExp(
+  CIRCLE + String.raw`\s+cắt\s+(?:lại\s+)?([A-Z]{2})\s*(?:,|và)\s*([A-Z]{2})(?![A-Z])\s+(?:lần\s*lượt\s+|theo\s+thứ\s+tự\s+|tương\s+ứng\s+)?(?:ở|tại)\s+([A-Z])\s*(?:,|và)\s*([A-Z])(?![A-Z])`,
+  "gu"
+);
 var GIAO_CIRCLE = new RegExp(
   String.raw`giao\s*điểm\s+(?:thứ\s+hai\s+)?(?:của\s+)?([A-Z]{2})(?![A-Z])\s+(?:và|với)\s+` + CIRCLE + String.raw`\s+là\s+([A-Z])(?![A-Z])(?:\s+khác\s+([A-Z])(?![A-Z]))?`,
   "gu"
 );
 var NAME_2ND_CUA = new RegExp(
-  String.raw`([A-Z])(?![A-Z])\s+là\s+giao\s*điểm\s+thứ\s+hai\s+của\s+([A-Z]{2})(?![A-Z])\s+(?:và|với)\s+` + CIRCLE,
+  String.raw`([A-Z])(?![A-Z])\s+là\s+giao\s*điểm\s+thứ\s+hai\s+của\s+(?:đường\s*thẳng\s+)?([A-Z]{2})(?![A-Z])\s+(?:và|với)\s+` + CIRCLE,
   "gu"
 );
 var NAME_2ND_BARE = new RegExp(
@@ -4309,13 +4865,28 @@ var NAME_KHAC_CUA = new RegExp(
   String.raw`([A-Z])(?![A-Z])\s+là\s+giao\s*điểm\s+(?:thứ\s+hai\s+)?khác\s+([A-Z])(?![A-Z])\s+của\s+([A-Z]{2})(?![A-Z])\s+(?:và|với)\s+` + CIRCLE,
   "gu"
 );
+var NAME_CUA = new RegExp(
+  String.raw`([A-Z])(?![A-Z])\s+là\s+giao\s*điểm\s+của\s+(?!thứ\s+hai)(?!khác)(?:đường\s*thẳng\s+)?([A-Z]{2})(?![A-Z])\s+(?:và|với)\s+` + CIRCLE,
+  "gu"
+);
 var NAME_2ND_CIRCUM = new RegExp(
   String.raw`giao\s*điểm\s+thứ\s+hai\s+của\s+([A-Z]{2})(?![A-Z])\s+(?:và|với)\s+` + String.raw`(?:nửa\s+)?` + CIRCLE_KW + String.raw`\s+ngoại\s*tiếp\s+tam\s*giác\s+[A-Z]{3}(?![A-Z])` + String.raw`\s+là\s+(?:điểm\s+)?([A-Z])(?![A-Z])(?:\s+khác\s+([A-Z])(?![A-Z]))?`,
   "gu"
 );
+var LINE_CUTS_PAREN_PAIR = new RegExp(
+  String.raw`([A-Z]{2})(?![A-Z])\s+(?:lần\s*lượt\s+|theo\s+thứ\s+tự\s+|tương\s+ứng\s+)?cắt\s+(?:lại\s+)?` + String.raw`\(\s*([A-Z]{3})\s*\)\s*(?:,|và)\s*\(\s*([A-Z]{3})\s*\)` + String.raw`\s+(?:lần\s*lượt\s+|theo\s+thứ\s+tự\s+)?(?:ở|tại)\s+(?:điểm\s+(?:thứ\s+hai\s+)?(?:là\s+)?)?([A-Z])\s*(?:,|và)\s*([A-Z])(?![A-Z])`,
+  "gu"
+);
+var PAREN_PAIR_CUTS = new RegExp(
+  String.raw`\(\s*([A-Z]{3})\s*\)\s*(?:,|và)\s*\(\s*([A-Z]{3})\s*\)\s+cắt\s+(?:lại\s+)?` + String.raw`([A-Z]{2})\s*(?:,|và)\s*([A-Z]{2})(?![A-Z])\s+(?:lần\s*lượt\s+|theo\s+thứ\s+tự\s+)?(?:ở|tại)\s+([A-Z])\s*(?:,|và)\s*([A-Z])(?![A-Z])`,
+  "gu"
+);
 function secondIntersection(name, line, circle, other) {
   return addPoint(name, { kind: "secondIntersection", line, circle, other: other ?? line[0] });
 }
+function vertexOnLine(verts, line) {
+  return verts.split("").find((v) => line.includes(v));
+}
 function valid(name, line) {
   return /^[A-Z]$/u.test(name) && /^[A-Z]{2}$/u.test(line) && !line.includes(name);
 }
@@ -4352,6 +4923,13 @@ var lineCircleIntersectionRule = {
         const other = m[4];
         if (valid(name, line)) intents.push(secondIntersection(name, line, circle, other));
       }
+      SINGLE_NAMED_CENTER.lastIndex = 0;
+      for (const m of c.text.matchAll(SINGLE_NAMED_CENTER)) {
+        const line = m[1];
+        const circle = m[2].replace(/′/g, "'");
+        const name = m[3];
+        if (valid(name, line)) intents.push(secondIntersection(name, line, circle, line[0]));
+      }
       LINE_AND_CIRCLE.lastIndex = 0;
       for (const m of c.text.matchAll(LINE_AND_CIRCLE)) {
         const [line, line2, circle, n1, n2] = [m[1], m[2], m[3], m[4], m[5]];
@@ -4372,7 +4950,14 @@ var lineCircleIntersectionRule = {
           addPoint(y, { kind: "intersection", of: [line, circle], branch: 1 })
         );
       }
-      NAME_2ND_BARE.lastIndex = 0;
+      TWO_NAMED.lastIndex = 0;
+      for (const m of c.text.matchAll(TWO_NAMED)) {
+        const [line, circle, p, q] = [m[1], m[2], m[3], m[4]];
+        if (p === q) continue;
+        if (line.includes(p) && !line.includes(q)) intents.push(secondIntersection(q, line, circle, p));
+        else if (line.includes(q) && !line.includes(p)) intents.push(secondIntersection(p, line, circle, q));
+      }
+      NAME_2ND_BARE.lastIndex = 0;
       for (const m of c.text.matchAll(NAME_2ND_BARE)) {
         const rc = RESOLVE_CIRCLE_BARE.exec(ctx.problem);
         const circle = rc?.[1] ?? rc?.[2];
@@ -4409,6 +4994,13 @@ var lineCircleIntersectionRule = {
         const [line, name] = [m[1], m[2]];
         if (circle && valid(name, line)) intents.push(secondIntersection(name, line, circle, line[0]));
       }
+      CIRCLE_SUBJECT_TWO.lastIndex = 0;
+      for (const m of c.text.matchAll(CIRCLE_SUBJECT_TWO)) {
+        const [circle, l1, l2, n1, n2] = [m[1], m[2], m[3], m[4], m[5]];
+        if (n1 === n2) continue;
+        if (valid(n1, l1)) intents.push(secondIntersection(n1, l1, circle));
+        if (valid(n2, l2)) intents.push(secondIntersection(n2, l2, circle));
+      }
       CIRCLE_SUBJECT.lastIndex = 0;
       for (const m of c.text.matchAll(CIRCLE_SUBJECT)) {
         const [circle, line, name] = [m[1], m[2], m[3]];
@@ -4430,6 +5022,11 @@ var lineCircleIntersectionRule = {
         const circle = m[4];
         if (valid(name, line)) intents.push(secondIntersection(name, line, circle, other));
       }
+      NAME_CUA.lastIndex = 0;
+      for (const m of c.text.matchAll(NAME_CUA)) {
+        const [name, line, circle] = [m[1], m[2], m[3]];
+        if (valid(name, line)) intents.push(secondIntersection(name, line, circle));
+      }
       NAME_2ND_CIRCUM.lastIndex = 0;
       for (const m of c.text.matchAll(NAME_2ND_CIRCUM)) {
         const line = m[1];
@@ -4445,6 +5042,34 @@ var lineCircleIntersectionRule = {
         if (line.includes(name)) continue;
         intents.push(addPoint(name, { kind: "intersection", of: [line, circle], branch: 0 }));
       }
+      LINE_CUTS_PAREN_PAIR.lastIndex = 0;
+      for (const m of c.text.matchAll(LINE_CUTS_PAREN_PAIR)) {
+        const [line, t1, t2, n1, n2] = [m[1], m[2], m[3], m[4], m[5]];
+        const o1 = vertexOnLine(t1, line);
+        const o2 = vertexOnLine(t2, line);
+        if (!o1 || !o2 || n1 === n2) continue;
+        if (line.includes(n1) || line.includes(n2)) continue;
+        intents.push(
+          drawCircle(`w${t1}`, "through3", { points: t1.split("") }),
+          drawCircle(`w${t2}`, "through3", { points: t2.split("") }),
+          secondIntersection(n1, line, `w${t1}`, o1),
+          secondIntersection(n2, line, `w${t2}`, o2)
+        );
+      }
+      PAREN_PAIR_CUTS.lastIndex = 0;
+      for (const m of c.text.matchAll(PAREN_PAIR_CUTS)) {
+        const [t1, t2, l1, l2, n1, n2] = [m[1], m[2], m[3], m[4], m[5], m[6]];
+        const o1 = vertexOnLine(t1, l1);
+        const o2 = vertexOnLine(t2, l2);
+        if (!o1 || !o2 || n1 === n2) continue;
+        if (l1.includes(n1) || l2.includes(n2)) continue;
+        intents.push(
+          drawCircle(`w${t1}`, "through3", { points: t1.split("") }),
+          drawCircle(`w${t2}`, "through3", { points: t2.split("") }),
+          secondIntersection(n1, l1, `w${t1}`, o1),
+          secondIntersection(n2, l2, `w${t2}`, o2)
+        );
+      }
       if (intents.length > 0) out.push({ ruleId: "line-circle-intersection", clauseIds: [c.id], intents });
     }
     return out;
@@ -4505,8 +5130,9 @@ var incenterNamedTriangleRule = {
 };
 
 // src/stamps/geometry-2d/ai/rules/perpThroughCutsLines.ts
+var LTOK = "(?:[A-Z]{2}|[A-Z][a-z][0-9]?)";
 var RE2 = new RegExp(
-  "(?:Qua|qua|T\u1EEB|t\u1EEB)\\s+(?:\u0111i\u1EC3m\\s+)?([A-Z])(?:['\u2032]?)(?!\\p{L})[^.]{0,24}?(song\\s*song|vu\xF4ng\\s*g\xF3c)\\s+(?:v\u1EDBi\\s+)?(?:c\u1EA1nh\\s+|\u0111o\u1EA1n(?:\\s+th\u1EB3ng)?\\s+)?([A-Z])([A-Z])(?!\\p{L})[^.]{0,40}?c\u1EAFt\\s+(?:c\xE1c\\s+)?(?:\u0111\u01B0\u1EDDng\\s*th\u1EB3ng\\s+)?([A-Z])([A-Z])\\s*(?:,|v\xE0)\\s*([A-Z])([A-Z])(?![A-Z])[^.]{0,30}?(?:\u1EDF|t\u1EA1i)\\s+([A-Z])\\s*(?:,|v\xE0)\\s*([A-Z])(?![A-Z])",
+  `(?:Qua|qua|T\u1EEB|t\u1EEB)\\s+(?:\u0111i\u1EC3m\\s+)?([A-Z])(?:['\u2032]?)(?!\\p{L})[^.]{0,24}?(song\\s*song|vu\xF4ng\\s*g\xF3c)\\s+(?:v\u1EDBi\\s+)?(?:c\u1EA1nh\\s+|\u0111o\u1EA1n(?:\\s+th\u1EB3ng)?\\s+)?([A-Z])([A-Z])(?!\\p{L})[^.]{0,40}?c\u1EAFt\\s+(?:c\xE1c\\s+)?(?:\u0111\u01B0\u1EDDng\\s*th\u1EB3ng\\s+)?(${LTOK})\\s*(?:,|v\xE0)\\s*(${LTOK})(?![A-Z])[^.]{0,30}?(?:\u1EDF|t\u1EA1i)\\s+([A-Z])\\s*(?:,|v\xE0)\\s*([A-Z])(?![A-Z])`,
   "gu"
 );
 var PREFILTER16 = /(?:Qua|qua|Từ|từ)\s+(?:điểm\s+)?[A-Z][^.]{0,24}?(?:song\s*song|vuông\s*góc)[^.]{0,80}?cắt/u;
@@ -4529,10 +5155,10 @@ var perpThroughCutsLinesRule = {
         const through = m[1];
         const isParallel = /song/.test(m[2]);
         const to = m[3] + m[4];
-        const line1 = m[5] + m[6];
-        const line2 = m[7] + m[8];
-        const h = m[9];
-        const k = m[10];
+        const line1 = m[5];
+        const line2 = m[6];
+        const h = m[7];
+        const k = m[8];
         if (isParallel && to.includes(through)) continue;
         if (h === k) continue;
         const kind = isParallel ? "parallelThrough" : "perpThrough";
@@ -4578,6 +5204,40 @@ var CIRCLE_CENTER3 = /\(\s*([A-Z])(?:\s*[;,]\s*[Rr])?\s*\)|tâm\s+([A-Z])(?![A-Z
 var DIAMETER_ENDS = /đường\s*kính\s+([A-Z])([A-Z])(?![A-Z])/u;
 var AFTER_TANGENT = /tiếp\s*tuyến\s+((?:[A-Z][xyzt](?![A-Za-z])\s*[,và\s]*)+)/gu;
 var RAY_TOKEN = /([A-Z])([xyzt])(?![A-Za-z])/gu;
+var SHAPE_VERTICES = /[Cc]ho\s+(?:tam\s*giác|tứ\s*giác|hình\s+(?:vuông|chữ\s*nhật|thang|bình\s*hành|thoi))\s+([A-Z]{3,})/gu;
+function matchFreeTangentPoint(ctx, cm) {
+  const center = cm ? cm[1] ?? cm[2] : void 0;
+  if (!center) return [];
+  const known = /* @__PURE__ */ new Set();
+  SHAPE_VERTICES.lastIndex = 0;
+  for (const m of ctx.problem.matchAll(SHAPE_VERTICES)) {
+    for (const ch of m[1]) known.add(ch);
+  }
+  const out = [];
+  for (const c of ctx.clauses) {
+    const intents = [];
+    const seen = /* @__PURE__ */ new Set();
+    AFTER_TANGENT.lastIndex = 0;
+    for (const grp of c.text.matchAll(AFTER_TANGENT)) {
+      RAY_TOKEN.lastIndex = 0;
+      for (const m of grp[1].matchAll(RAY_TOKEN)) {
+        const endpoint = m[1];
+        const token = `${m[1]}${m[2]}`;
+        if (known.has(endpoint)) continue;
+        if (seen.has(token)) continue;
+        seen.add(token);
+        intents.push(
+          addPoint(endpoint, { kind: "onCircle", circle: center, theta: 0.7 }),
+          drawLine(token, "tangentAt", { through: endpoint, circle: center })
+        );
+      }
+    }
+    if (intents.length > 0) {
+      out.push({ ruleId: "tangent-ray", clauseIds: [c.id], intents });
+    }
+  }
+  return out;
+}
 var tangentRayRule = {
   id: "tangent-ray",
   // Cao hơn point-on-ray (55) + intersect-ray (48): token tia phải được dựng
@@ -4589,7 +5249,7 @@ var tangentRayRule = {
   match(ctx) {
     const cm = CIRCLE_CENTER3.exec(ctx.problem);
     const dm = DIAMETER_ENDS.exec(ctx.problem);
-    if (!dm) return [];
+    if (!dm) return matchFreeTangentPoint(ctx, cm);
     const center = cm ? cm[1] ?? cm[2] : `k${dm[1]}${dm[2]}`;
     const ends = /* @__PURE__ */ new Set([dm[1], dm[2]]);
     const out = [];
@@ -5238,7 +5898,7 @@ var PREFILTER30 = /[Tt]iếp\s*tuyến[^.]{0,30}?tại\s+[A-Z][^.]{0,40}?cắt|Q
 var CIRCLE_REF4 = /đường\s*tròn\s*(?:tâm\s+)?\(?\s*([A-Z])(?:\s*[;,]\s*[Rr])?\s*\)?/u;
 var UNNAMED_DIAMETER2 = /(?:nửa\s+)?đường\s*tròn\s+đường\s*kính\s+([A-Z])([A-Z])(?![A-Z])/u;
 var QUA_RE = new RegExp(
-  "Qua\\s+(?:\u0111i\u1EC3m\\s+)?([A-Z])(?!\\p{L})[^.]{0,40}?ti\u1EBFp\\s*tuy\u1EBFn\\s+(?:th\u1EE9\\s+(?:ba|3|hai|2)\\s+)?c\u1EAFt\\s+(?:c\xE1c\\s+)?(?:(?:c\xE1c\\s+)?ti\u1EBFp\\s*tuy\u1EBFn\\s+|\u0111\u01B0\u1EDDng\\s*th\u1EB3ng\\s+|c\u1EA1nh\\s+)?([A-Z](?:[A-Z]|[xyzt]))\\s*(?:,|v\xE0)\\s*([A-Z](?:[A-Z]|[xyzt]))(?!\\p{L})\\s+(?:l\u1EA7n\\s*l\u01B0\u1EE3t\\s+)?(?:\u1EDF|t\u1EA1i)\\s+([A-Z])\\s*(?:,|v\xE0)\\s*([A-Z])(?![A-Z])",
+  "Qua\\s+(?:\u0111i\u1EC3m\\s+)?([A-Z])(?!\\p{L})[^.]{0,40}?ti\u1EBFp\\s*tuy\u1EBFn\\s+(?:th\u1EE9\\s+(?:ba|3|hai|2)\\s+)?c\u1EAFt\\s+(?:c\xE1c\\s+)?(?:(?:c\xE1c\\s+)?ti\u1EBFp\\s*tuy\u1EBFn\\s+|\u0111\u01B0\u1EDDng\\s*th\u1EB3ng\\s+|c\u1EA1nh\\s+)?([A-Z](?:[A-Z]|[xyzt]))\\s*(?:,|v\xE0)\\s*([A-Z](?:[A-Z]|[xyzt]))(?!\\p{L})(?:\\s+k\xE9o\\s+d\xE0i)?\\s+(?:l\u1EA7n\\s*l\u01B0\u1EE3t\\s+)?(?:\u1EDF|t\u1EA1i)\\s+([A-Z])\\s*(?:,|v\xE0)\\s*(?:(?:t\u1EA1i|\u1EDF)\\s+)?([A-Z])(?![A-Z])",
   "gu"
 );
 var SINGLE_RE = new RegExp(
@@ -5246,7 +5906,7 @@ var SINGLE_RE = new RegExp(
   "gu"
 );
 var RE6 = new RegExp(
-  "[Tt]i\u1EBFp\\s*tuy\u1EBFn\\s+(?:c\u1EE7a\\s+[^.]{0,14}?\\s+)?t\u1EA1i\\s+(?:\u0111i\u1EC3m\\s+)?([A-Z])(?!\\p{L})(?:\\s+c\u1EE7a\\s+[^.]{0,14}?)?\\s+c\u1EAFt\\s+(?:c\xE1c\\s+)?(?:(?:c\xE1c\\s+)?ti\u1EBFp\\s*tuy\u1EBFn\\s+|\u0111\u01B0\u1EDDng\\s*th\u1EB3ng\\s+|c\u1EA1nh\\s+)?([A-Z](?:[A-Z]|[xyzt]))\\s*(?:,|v\xE0)\\s*([A-Z](?:[A-Z]|[xyzt]))(?!\\p{L})\\s+(?:l\u1EA7n\\s*l\u01B0\u1EE3t\\s+)?(?:t\u1EA1i|\u1EDF)\\s+([A-Z])\\s*(?:,|v\xE0)\\s*([A-Z])(?![A-Z])",
+  "[Tt]i\u1EBFp\\s*tuy\u1EBFn\\s+(?:(?:c\u1EE7a|v\u1EDBi)\\s+[^.]{0,14}?\\s+)?t\u1EA1i\\s+(?:\u0111i\u1EC3m\\s+)?([A-Z])(?!\\p{L})(?:\\s+(?:c\u1EE7a|v\u1EDBi)\\s+[^.]{0,14}?)?\\s+c\u1EAFt\\s+(?:c\xE1c\\s+)?(?:(?:c\xE1c\\s+)?ti\u1EBFp\\s*tuy\u1EBFn\\s+|\u0111\u01B0\u1EDDng\\s*th\u1EB3ng\\s+|c\u1EA1nh\\s+)?([A-Z](?:[A-Z]|[xyzt]))\\s*(?:,|v\xE0)\\s*([A-Z](?:[A-Z]|[xyzt]))(?!\\p{L})(?:\\s+k\xE9o\\s+d\xE0i)?\\s+(?:l\u1EA7n\\s*l\u01B0\u1EE3t\\s+)?(?:t\u1EA1i|\u1EDF)\\s+([A-Z])\\s*(?:,|v\xE0)\\s*(?:(?:t\u1EA1i|\u1EDF)\\s+)?([A-Z])(?![A-Z])",
   "gu"
 );
 function circleName3(problem) {
@@ -5308,15 +5968,15 @@ var tangentAtCutsLinesRule = {
       for (const m of c.text.matchAll(SINGLE_RE)) {
         const at = m[1];
         const line = m[2];
-        const z46 = m[3];
-        if (line.includes(z46) || line.includes(at)) continue;
+        const z47 = m[3];
+        if (line.includes(z47) || line.includes(at)) continue;
         const t = `t${at}`;
         out.push({
           ruleId: "tangentAtCutsLines",
           clauseIds: [c.id],
           intents: [
             drawLine(t, "tangentAt", { through: at, circle }),
-            addPoint(z46, { kind: "intersection", of: [t, line] })
+            addPoint(z47, { kind: "intersection", of: [t, line] })
           ]
         });
       }
@@ -5330,12 +5990,16 @@ var RE7 = new RegExp(
   "([A-Z])([A-Z])(?![A-Z])\\s+l\xE0\\s+\u0111\u01B0\u1EDDng\\s*k\xEDnh\\s+(?:c\u1EE7a\\s+)?(?:\u0111\u01B0\u1EDDng\\s*tr\xF2n\\s*)?(?:t\xE2m\\s+)?\\(?\\s*([A-Z])\\s*\\)?",
   "gu"
 );
+var VERB_GAP = "(?:[^.;,]{0,24}?v\xE0\\s+|(?:(?!\u0111\u01B0\u1EDDng\\s*tr\xF2n|\\()[^.;,]){0,24}?)?";
 var RE_VERB = new RegExp(
-  "(?:[Kk]\u1EBB|[Vv]\u1EBD|[Dd]\u1EF1ng)\\s+(?:[^.;,]{0,24}?v\xE0\\s+)?\u0111\u01B0\u1EDDng\\s*k\xEDnh\\s+([A-Z])([A-Z]['\u2032]?)(?![A-Za-z'\u2032])",
+  "(?:[Kk]\u1EBB|[Vv]\u1EBD|[Dd]\u1EF1ng)\\s+" + VERB_GAP + "\u0111\u01B0\u1EDDng\\s*k\xEDnh\\s+([A-Z])([A-Z]['\u2032]?)(?![A-Za-z'\u2032])",
   "gu"
 );
 var RESOLVE_CENTER = /\(\s*([A-Z])(?:\s*[;,]\s*[Rr0-9][^)]*)?\s*\)|tâm\s+([A-Z])(?![A-Za-z])/u;
-var PREFILTER31 = /[A-Z]{2}\s+là\s+đường\s*kính|(?:[Kk]ẻ|[Vv]ẽ|[Dd]ựng)\s+(?:[^.;,]{0,24}?và\s+)?đường\s*kính/u;
+var PREFILTER31 = new RegExp(
+  "[A-Z]{2}\\s+l\xE0\\s+\u0111\u01B0\u1EDDng\\s*k\xEDnh|(?:[Kk]\u1EBB|[Vv]\u1EBD|[Dd]\u1EF1ng)\\s+" + VERB_GAP + "\u0111\u01B0\u1EDDng\\s*k\xEDnh",
+  "u"
+);
 var diameterEndpointRule = {
   id: "diameterEndpoint",
   priority: 56,
@@ -5369,7 +6033,7 @@ var diameterEndpointRule = {
         const d = m[2].replace(/′/g, "'");
         if (a === d || center === a || center === d || emitted.has(d)) continue;
         const before = ctx.problem.slice(0, ctx.problem.indexOf(m[0]));
-        if (!new RegExp(`(?<![a-z])${a}(?![a-z])`, "u").test(before)) continue;
+        if (!new RegExp(`(?<![a-z])${escapeRe(a)}(?![a-z])`, "u").test(before)) continue;
         emitted.add(d);
         out.push({
           ruleId: "diameterEndpoint",
@@ -5433,8 +6097,69 @@ var circleThroughTwoCutsSidesRule = {
   }
 };
 
+// src/stamps/geometry-2d/ai/rules/circleCenterRadiusCutsSides.ts
+var PATTERN4 = new RegExp(
+  CIRCLE_KW + "\\s+t\xE2m\\s+([A-Z])(?![A-Z])\\s*b\xE1n\\s*k\xEDnh\\s+([A-Z])([A-Z])(?![A-Z])[^.;\\n]*?c\u1EAFt\\s+([^.;\\n]*?)\\s+(?:(?:l\u1EA7n\\s*l\u01B0\u1EE3t|theo\\s+th\u1EE9\\s+t\u1EF1)\\s+)?t\u1EA1i\\s+(?:c\xE1c\\s+)?(?:\u0111i\u1EC3m\\s+)?([A-Z](?!\\p{L})(?:\\s*(?:,|v\xE0)\\s*[A-Z](?!\\p{L}))*)",
+  "gu"
+);
+var PREFILTER33 = new RegExp(
+  CIRCLE_KW + "\\s+t\xE2m\\s+[A-Z]\\s*b\xE1n\\s*k\xEDnh\\s+[A-Z]{2}[^.;\\n]*?c\u1EAFt",
+  "u"
+);
+var circleCenterRadiusCutsSidesRule = {
+  id: "circle-center-radius-cuts-sides",
+  // THẤP HƠN triangle (100) + centers (cần đỉnh + tâm H dựng trước). Cùng họ với
+  // diameterCircleCutsSides (66) / circleThroughTwoCutsSides (58). Đặt 57.
+  priority: 57,
+  languages: ["vi"],
+  patterns: [PREFILTER33],
+  match(ctx) {
+    const out = [];
+    for (const c of ctx.clauses) {
+      PATTERN4.lastIndex = 0;
+      for (const m of c.text.matchAll(PATTERN4)) {
+        const center = m[1];
+        const r0 = m[2];
+        const r1 = m[3];
+        let through;
+        if (r0 === center && r1 !== center) through = r1;
+        else if (r1 === center && r0 !== center) through = r0;
+        if (!through) continue;
+        const lines = m[4].match(/[A-Z][A-Z](?![A-Z])/gu) ?? [];
+        const points = m[5].match(/[A-Z](?![A-Z])/gu) ?? [];
+        if (lines.length === 0 || lines.length !== points.length) continue;
+        const circ = `${center}_c`;
+        const intents = [
+          drawCircle(circ, "centerThrough", { center, through })
+        ];
+        let ok = true;
+        const seen = /* @__PURE__ */ new Set();
+        for (let i = 0; i < lines.length; i++) {
+          const line = lines[i];
+          const pt = points[i];
+          if (!line.includes(through)) {
+            ok = false;
+            break;
+          }
+          if (line.includes(pt) || pt === through || pt === center || seen.has(pt)) {
+            ok = false;
+            break;
+          }
+          seen.add(pt);
+          intents.push(
+            addPoint(pt, { kind: "secondIntersection", line, circle: circ, other: through })
+          );
+        }
+        if (!ok) continue;
+        out.push({ ruleId: "circle-center-radius-cuts-sides", clauseIds: [c.id], intents });
+      }
+    }
+    return out;
+  }
+};
+
 // src/stamps/geometry-2d/ai/rules/circumcircleNamedDistrib.ts
-var PREFILTER33 = /lần\s*lượt\s+là\s+(?:đường\s*tròn\s+)?ngoại\s*tiếp/u;
+var PREFILTER34 = /lần\s*lượt\s+là\s+(?:đường\s*tròn\s+)?ngoại\s*tiếp/u;
 var RE9 = new RegExp(
   "([A-Z])\\s*,\\s*([A-Z])\\s+l\u1EA7n\\s*l\u01B0\u1EE3t\\s+l\xE0\\s+(?:\u0111\u01B0\u1EDDng\\s*tr\xF2n\\s+)?ngo\u1EA1i\\s*ti\u1EBFp\\s+(?:c\xE1c\\s+)?tam\\s*gi\xE1c\\s+([A-Z])([A-Z])([A-Z])(?![A-Z])\\s*,\\s*(?:tam\\s*gi\xE1c\\s+)?([A-Z])([A-Z])([A-Z])(?![A-Z])",
   "u"
@@ -5443,7 +6168,7 @@ var circumcircleNamedDistribRule = {
   id: "circumcircleNamedDistrib",
   priority: 67,
   languages: ["vi"],
-  patterns: [PREFILTER33],
+  patterns: [PREFILTER34],
   match(ctx) {
     const out = [];
     for (const c of ctx.clauses) {
@@ -5468,7 +6193,7 @@ var circumcircleNamedDistribRule = {
 };
 
 // src/stamps/geometry-2d/ai/rules/circumcirclePairMeet.ts
-var PREFILTER34 = /[Đđ]ường\s*tròn\s+ngoại\s*tiếp\s+(?:các\s+)?tam\s*giác\s+[A-Z]{3}\s*(?:,|\s+(?:và|cắt)\s+(?:lại\s+)?đường\s*tròn\s+ngoại\s*tiếp\s+tam\s*giác)/u;
+var PREFILTER35 = /[Đđ]ường\s*tròn\s+ngoại\s*tiếp\s+(?:các\s+)?tam\s*giác\s+[A-Z]{3}\s*(?:,|\s+(?:và|cắt)\s+(?:lại\s+)?đường\s*tròn\s+ngoại\s*tiếp\s+tam\s*giác)/u;
 var RE_CAT = new RegExp(
   "[\u0110\u0111]\u01B0\u1EDDng\\s*tr\xF2n\\s+ngo\u1EA1i\\s*ti\u1EBFp\\s+tam\\s*gi\xE1c\\s+([A-Z]{3})(?![A-Z])\\s+c\u1EAFt\\s+(?:l\u1EA1i\\s+)?[\u0110\u0111]\u01B0\u1EDDng\\s*tr\xF2n\\s+ngo\u1EA1i\\s*ti\u1EBFp\\s+tam\\s*gi\xE1c\\s+([A-Z]{3})(?![A-Z])\\s+(?:t\u1EA1i|\u1EDF)\\s+(?:\u0111i\u1EC3m\\s+(?:th\u1EE9\\s+hai\\s+)?)?(?:l\xE0\\s+)?([A-Z])(?![A-Z])(?:\\s+kh\xE1c\\s+([A-Z])(?![A-Z]))?",
   "u"
@@ -5490,22 +6215,27 @@ var RE_PAREN_BEFORE = new RegExp(
   `([A-Z])(?![A-Z])\\s+l\xE0\\s+giao\\s*\u0111i\u1EC3m\\s+(?:th\u1EE9\\s+hai\\s+)?(?:c\u1EE7a\\s+)?${PAR}\\s+v\xE0\\s+${PAR}`,
   "u"
 );
+var RE_PAREN_CAT = new RegExp(
+  `${PAR}\\s+v\xE0\\s+${PAR}\\s+c\u1EAFt\\s+nhau\\s+(?:t\u1EA1i|\u1EDF)\\s+(?:\u0111i\u1EC3m\\s+(?:th\u1EE9\\s+hai\\s+)?)?([A-Z])(?![A-Z])(?:\\s+kh\xE1c\\s+([A-Z])(?![A-Z]))?`,
+  "u"
+);
 var circumcirclePairMeetRule = {
   id: "circumcirclePairMeet",
   priority: 59,
   languages: ["vi"],
-  patterns: [PREFILTER34, new RegExp(`${PAR}\\s+v\xE0\\s+${PAR}`, "u")],
+  patterns: [PREFILTER35, new RegExp(`${PAR}\\s+v\xE0\\s+${PAR}`, "u")],
   match(ctx) {
     const out = [];
     for (const c of ctx.clauses) {
       const pl = RE_PAREN_LA.exec(c.text);
-      const pb = pl ? null : RE_PAREN_BEFORE.exec(c.text);
-      if (pl || pb) {
-        const t1 = pl ? pl[1] : pb[2];
-        const t2 = pl ? pl[2] : pb[3];
-        const q2 = pl ? pl[3] : pb[1];
+      const pc = pl ? null : RE_PAREN_CAT.exec(c.text);
+      const pb = pl || pc ? null : RE_PAREN_BEFORE.exec(c.text);
+      if (pl || pc || pb) {
+        const t1 = pl ? pl[1] : pc ? pc[1] : pb[2];
+        const t2 = pl ? pl[2] : pc ? pc[2] : pb[3];
+        const q2 = pl ? pl[3] : pc ? pc[3] : pb[1];
         const tri12 = t1.split(""), tri22 = t2.split("");
-        const shared2 = pl && pl[4] || tri12.find((v) => tri22.includes(v));
+        const shared2 = pl && pl[4] || pc && pc[4] || tri12.find((v) => tri22.includes(v));
         if (shared2 && !tri12.includes(q2) && !tri22.includes(q2)) {
           out.push({
             ruleId: "circumcirclePairMeet",
@@ -5543,7 +6273,7 @@ var circumcirclePairMeetRule = {
 };
 
 // src/stamps/geometry-2d/ai/rules/tangentCircleAtPoint.ts
-var PREFILTER35 = /[Đđ]ường\s*tròn\s*\(?[A-Z]\)?[^.]{0,40}?tiếp\s*xúc[^.]{0,20}?tại\s+[A-Z]/u;
+var PREFILTER36 = /[Đđ]ường\s*tròn\s*\(?[A-Z]\)?[^.]{0,40}?tiếp\s*xúc[^.]{0,20}?tại\s+[A-Z]/u;
 var RE11 = new RegExp(
   "[\u0110\u0111]\u01B0\u1EDDng\\s*tr\xF2n\\s*\\(\\s*([A-Z])\\s*\\)\\s*(?:\u0111i\\s+)?qua\\s+([A-Z])\\s+(?:v\xE0\\s+)?ti\u1EBFp\\s*x\xFAc\\s+(?:v\u1EDBi\\s+)?(?:c\u1EA1nh\\s+|\u0111\u01B0\u1EDDng\\s*th\u1EB3ng\\s+)?([A-Z]{2})\\s+t\u1EA1i\\s+([A-Z])(?!\\p{L})[^.]{0,24}?c\u1EAFt\\s+(?:c\xE1c\\s+(?:c\u1EA1nh|\u0111o\u1EA1n)\\s+|c\u1EA1nh\\s+)?([A-Z]{2})\\s*(?:,|v\xE0)\\s*([A-Z]{2})(?!\\p{L})\\s+(?:l\u1EA7n\\s*l\u01B0\u1EE3t\\s+)?(?:\u1EDF|t\u1EA1i)\\s+([A-Z])\\s*(?:,|v\xE0)\\s*([A-Z])(?![A-Z])",
   "gu"
@@ -5556,7 +6286,7 @@ var tangentCircleAtPointRule = {
   id: "tangentCircleAtPoint",
   priority: 60,
   languages: ["vi"],
-  patterns: [PREFILTER35],
+  patterns: [PREFILTER36],
   match(ctx) {
     const out = [];
     for (const c of ctx.clauses) {
@@ -5612,7 +6342,7 @@ var tangentCircleAtPointRule = {
 };
 
 // src/stamps/geometry-2d/ai/rules/externalBisectorCutsLines.ts
-var PREFILTER36 = /phân\s*giác\s+ngoài\s+(?:của\s+)?góc\s+[A-Z]{3}[^.]{0,30}?cắt/u;
+var PREFILTER37 = /phân\s*giác\s+ngoài\s+(?:của\s+)?góc\s+[A-Z]{3}[^.]{0,30}?cắt/u;
 var RE12 = new RegExp(
   "[\u0110\u0111]\u01B0\u1EDDng\\s*th\u1EB3ng\\s+(?:ch\u1EE9a\\s+)?ph\xE2n\\s*gi\xE1c\\s+ngo\xE0i\\s+(?:c\u1EE7a\\s+)?g\xF3c\\s+([A-Z])([A-Z])([A-Z])(?![A-Z])[^.]{0,20}?c\u1EAFt\\s+(?:c\xE1c\\s+(?:c\u1EA1nh|\u0111\u01B0\u1EDDng\\s*th\u1EB3ng)\\s+)?([A-Z]{2})\\s*(?:,|v\xE0)\\s*([A-Z]{2})(?!\\p{L})\\s+(?:l\u1EA7n\\s*l\u01B0\u1EE3t\\s+)?(?:\u1EDF|t\u1EA1i)\\s+(?:c\xE1c\\s+\u0111i\u1EC3m\\s+)?([A-Z])\\s*(?:,|v\xE0)\\s*([A-Z])(?![A-Z])",
   "gu"
@@ -5621,7 +6351,7 @@ var externalBisectorCutsLinesRule = {
   id: "externalBisectorCutsLines",
   priority: 57,
   languages: ["vi"],
-  patterns: [PREFILTER36],
+  patterns: [PREFILTER37],
   match(ctx) {
     const out = [];
     for (const c of ctx.clauses) {
@@ -5652,7 +6382,7 @@ var externalBisectorCutsLinesRule = {
 };
 
 // src/stamps/geometry-2d/ai/rules/tangentTwoSidesCircle.ts
-var PREFILTER37 = /[Đđ]ường\s*tròn[^.]{0,30}?tiếp\s*xúc[^.]{0,40}?tiếp\s*xúc\s+trong/u;
+var PREFILTER38 = /[Đđ]ường\s*tròn[^.]{0,30}?tiếp\s*xúc[^.]{0,40}?tiếp\s*xúc\s+trong/u;
 var RE13 = new RegExp(
   "[\u0110\u0111]\u01B0\u1EDDng\\s*tr\xF2n\\s*\\(?\\s*([A-Z])\\s*\\)?\\s+ti\u1EBFp\\s*x\xFAc\\s+(?:v\u1EDBi\\s+)?(?:c\xE1c\\s+c\u1EA1nh\\s+|c\u1EA1nh\\s+)?([A-Z]{2})\\s*,\\s*([A-Z]{2})(?!\\p{L})\\s+(?:l\u1EA7n\\s*l\u01B0\u1EE3t\\s+)?(?:\u1EDF|t\u1EA1i)\\s+([A-Z])\\s*,\\s*([A-Z])(?!\\p{L})\\s+v\xE0\\s+ti\u1EBFp\\s*x\xFAc\\s+trong\\s+(?:v\u1EDBi\\s+)?\\(?\\s*[A-Z]\\s*\\)?\\s+(?:\u1EDF|t\u1EA1i)\\s+([A-Z])(?![A-Z])",
   "gu"
@@ -5665,7 +6395,7 @@ var tangentTwoSidesCircleRule = {
   id: "tangentTwoSidesCircle",
   priority: 61,
   languages: ["vi"],
-  patterns: [PREFILTER37],
+  patterns: [PREFILTER38],
   match(ctx) {
     const out = [];
     for (const c of ctx.clauses) {
@@ -5701,14 +6431,22 @@ var tangentTwoSidesCircleRule = {
 };
 
 // src/stamps/geometry-2d/ai/rules/interiorPoint.ts
-var PREFILTER38 = /(?:nằm\s+)?(?:bên\s+)?trong\s+(?:tam\s*giác|tứ\s*giác|hình|mặt\s*phẳng)/u;
-var RE14 = /(?:[Gg]ọi\s+|[Ll]ấy\s+)?(?:điểm\s+)?([A-Z])(?!\p{L})\s+(?:là\s+)?(?:một\s+)?điểm\s+(?:nằm\s+)?(?:bên\s+)?trong\s+(?:mặt\s*phẳng\s+(?:chứa\s+)?)?(?:tam\s*giác|tứ\s*giác|hình\s+\S+)\s+[A-Z]{3,4}(?![A-Z])/u;
-var RE22 = /(?:một\s+)?[Đđ]iểm\s+([A-Z])(?!\p{L})\s+nằm\s+(?:bên\s+)?trong\s+(?:tam\s*giác|tứ\s*giác|hình(?:\s+(?:chữ\s*nhật|vuông|thoi|bình\s*hành|thang|\S+))?)(?:\s+[A-Z]{3,4}(?![A-Z]))?/u;
+var SHAPE = "(?:(?:tam\\s*gi\xE1c|t\u1EE9\\s*gi\xE1c|\u0111\u01B0\u1EDDng\\s*tr\xF2n|h\xECnh(?:\\s+(?:ch\u1EEF\\s*nh\u1EADt|vu\xF4ng|thoi|b\xECnh\\s*h\xE0nh|thang))?)(?:\\s+(?:[A-Z]{3,4}(?![A-Z])|\\([^)]*\\)))?|\\([^)]*\\))";
+var QUAL = "(?:\\s+(?:b\u1EA5t\\s*k[i\xECy\u1EF3]|t[u\xF9][y\u1EF3]\\s*\xFD))?";
+var PREFILTER39 = /(?:nằm\s+)?(?:bên\s+)?trong\s+(?:tam\s*giác|tứ\s*giác|đường\s*tròn|hình|mặt\s*phẳng|\()/u;
+var RE14 = new RegExp(
+  "(?:[Gg]\u1ECDi\\s+|[Ll]\u1EA5y\\s+)?(?:\u0111i\u1EC3m\\s+)?([A-Z])(?!\\p{L})\\s+(?:l\xE0\\s+)?(?:m\u1ED9t\\s+)?\u0111i\u1EC3m" + QUAL + "\\s+(?:n\u1EB1m\\s+)?(?:b\xEAn\\s+)?trong\\s+(?:m\u1EB7t\\s*ph\u1EB3ng\\s+(?:ch\u1EE9a\\s+)?)?" + SHAPE,
+  "u"
+);
+var RE22 = new RegExp(
+  "(?:m\u1ED9t\\s+)?[\u0110\u0111]i\u1EC3m\\s+([A-Z])(?!\\p{L})" + QUAL + "\\s+n\u1EB1m\\s+(?:b\xEAn\\s+)?trong\\s+" + SHAPE,
+  "u"
+);
 var interiorPointRule = {
   id: "interiorPoint",
   priority: 30,
   languages: ["vi"],
-  patterns: [PREFILTER38],
+  patterns: [PREFILTER39],
   match(ctx) {
     const out = [];
     for (const c of ctx.clauses) {
@@ -5726,7 +6464,7 @@ var interiorPointRule = {
 };
 
 // src/stamps/geometry-2d/ai/rules/parallelCutsTangentAt.ts
-var PREFILTER39 = /[Đđ]ường\s*thẳng\s+qua\s+[A-Z][^.]{0,40}?tiếp\s*tuyến\s+tại\s+[A-Z]/u;
+var PREFILTER40 = /[Đđ]ường\s*thẳng\s+qua\s+[A-Z][^.]{0,40}?tiếp\s*tuyến\s+tại\s+[A-Z]/u;
 var CIRCLE_REF5 = /đường\s*tròn\s*\(\s*([A-Z])\s*\)|\(\s*([A-Z])\s*\)/u;
 var RE15 = new RegExp(
   "[\u0110\u0111]\u01B0\u1EDDng\\s*th\u1EB3ng\\s+qua\\s+([A-Z])(?!\\p{L})\\s+(song\\s*song|vu\xF4ng\\s*g\xF3c)\\s+(?:v\u1EDBi\\s+)?([A-Z]{2})(?!\\p{L})\\s+c\u1EAFt\\s+ti\u1EBFp\\s*tuy\u1EBFn\\s+t\u1EA1i\\s+([A-Z])(?!\\p{L})(?:\\s+c\u1EE7a\\s+[^.]{0,12}?)?\\s+(?:\u1EDF|t\u1EA1i)\\s+([A-Z])(?![A-Z])",
@@ -5740,7 +6478,7 @@ var parallelCutsTangentAtRule = {
   id: "parallelCutsTangentAt",
   priority: 52,
   languages: ["vi"],
-  patterns: [PREFILTER39],
+  patterns: [PREFILTER40],
   match(ctx) {
     const circle = circleName4(ctx.problem);
     if (!circle) return [];
@@ -5771,7 +6509,7 @@ var parallelCutsTangentAtRule = {
 };
 
 // src/stamps/geometry-2d/ai/rules/inExCircleTangentBC.ts
-var PREFILTER40 = /[Đđ]ường\s*tròn\s+(?:nội|bàng)\s*tiếp[^.]{0,60}?tâm\s+[A-Z][^.]{0,30}?tiếp\s*xúc/u;
+var PREFILTER41 = /[Đđ]ường\s*tròn\s+(?:nội|bàng)\s*tiếp[^.]{0,60}?tâm\s+[A-Z][^.]{0,30}?tiếp\s*xúc/u;
 var TANGENT_TAIL = "\\s*,?\\s*ti\u1EBFp\\s*x\xFAc\\s+(?:v\u1EDBi\\s+)?(?:c\u1EA1nh\\s+|\u0111o\u1EA1n(?:\\s+th\u1EB3ng)?\\s+)?([A-Z]{2})(?!\\p{L})\\s+(?:\u1EDF|t\u1EA1i)\\s+([A-Z])(?![A-Z])";
 var INCIRCLE = new RegExp(
   "[\u0110\u0111]\u01B0\u1EDDng\\s*tr\xF2n\\s+n\u1ED9i\\s*ti\u1EBFp\\s+tam\\s*gi\xE1c\\s+([A-Z]{3})(?![A-Z])[^.]{0,20}?t\xE2m\\s+([A-Z])(?!\\p{L})" + TANGENT_TAIL,
@@ -5785,7 +6523,7 @@ var inExCircleTangentBCRule = {
   id: "inExCircleTangentBC",
   priority: 69,
   languages: ["vi"],
-  patterns: [PREFILTER40],
+  patterns: [PREFILTER41],
   match(ctx) {
     const out = [];
     for (const c of ctx.clauses) {
@@ -5827,7 +6565,7 @@ var inExCircleTangentBCRule = {
 };
 
 // src/stamps/geometry-2d/ai/rules/tangentPointsFromExt.ts
-var PREFILTER41 = /[Tt]ừ\s+(?:điểm\s+)?[A-Z][^.]{0,60}?tiếp\s*tuyến\s+[A-Z]{2}\s*,\s*[A-Z]{2}/u;
+var PREFILTER42 = /[Tt]ừ\s+(?:điểm\s+)?[A-Z][^.]{0,60}?tiếp\s*tuyến\s+[A-Z]{2}\s*,\s*[A-Z]{2}/u;
 var RE16 = new RegExp(
   "[Tt]\u1EEB\\s+(?:\u0111i\u1EC3m\\s+)?([A-Z])(?!\\p{L})[^.]{0,60}?ti\u1EBFp\\s*tuy\u1EBFn\\s+([A-Z])([A-Z])\\s*,\\s*([A-Z])([A-Z])(?!\\p{L})",
   "gu"
@@ -5837,7 +6575,7 @@ var tangentPointsFromExtRule = {
   id: "tangentPointsFromExt",
   priority: 50,
   languages: ["vi"],
-  patterns: [PREFILTER41],
+  patterns: [PREFILTER42],
   match(ctx) {
     const out = [];
     for (const c of ctx.clauses) {
@@ -5872,7 +6610,11 @@ var VN_FORM2 = new RegExp(
   "u"
 );
 var VN_REV = new RegExp(
-  String.raw`điểm\s+([A-Z])(?:['′]?)\s+(?:nằm\s+|ở\s+)?ngoài\s+đường\s*tròn\s*(?:tâm\s+)?\(?\s*([A-Z])?`,
+  String.raw`điểm\s+([A-Z])(?:['′]?)[^.A-Z]{0,18}?ngoài\s+đường\s*tròn\s*(?:tâm\s+)?\(?\s*([A-Z])?`,
+  "u"
+);
+var VN_REV_BARE = new RegExp(
+  String.raw`(?<![\p{L}])([A-Z])(?:['′]?)[^.A-Z]{0,18}?ngoài\s+(?:đường\s*tròn\s*)?\(\s*([A-Z])\s*\)`,
   "u"
 );
 var RESOLVE_CENTER2 = /đường\s*tròn\s*(?:\(\s*)?(?:tâm\s+)?([A-Z])(?![A-Za-z])|\(\s*([A-Z])(?:\s*[;,]\s*[Rr])?\s*\)/u;
@@ -5901,17 +6643,23 @@ var circleExternalPointRule = {
       } else if (VN_METRIC.test(c.text)) {
         const mm = VN_METRIC.exec(c.text);
         const [ctr, r, pt, pair, d] = [mm[1], mm[2], mm[3], mm[4], mm[5]];
-        const norm2 = (s) => parseFloat(s.replace(",", "."));
-        if (pair.includes(ctr) && pair.includes(pt) && norm2(d) > norm2(r)) {
+        const norm5 = (s) => parseFloat(s.replace(",", "."));
+        if (pair.includes(ctr) && pair.includes(pt) && norm5(d) > norm5(r)) {
           center = ctr;
           ext = pt;
         }
       } else {
         const rv = VN_REV.exec(c.text);
-        if (!rv) continue;
-        ext = rv[1];
-        const rc = rv[2] ? void 0 : RESOLVE_CENTER2.exec(ctx.problem);
-        center = rv[2] ?? rc?.[1] ?? rc?.[2];
+        if (rv) {
+          ext = rv[1];
+          const rc = rv[2] ? void 0 : RESOLVE_CENTER2.exec(ctx.problem);
+          center = rv[2] ?? rc?.[1] ?? rc?.[2] ?? "O";
+        } else {
+          const rb = VN_REV_BARE.exec(c.text);
+          if (!rb) continue;
+          ext = rb[1];
+          center = rb[2];
+        }
       }
       if (!center || !ext || center === ext) continue;
       out.push({
@@ -5928,7 +6676,7 @@ var circleExternalPointRule = {
 };
 
 // src/stamps/geometry-2d/ai/rules/tangentNamedFromExt.ts
-var PREFILTER42 = /(?:[Kk]ẻ|[Vv]ẽ)\s+(?:các\s+|hai\s+|2\s+)?tiếp\s*tuyến\s+(?:thứ\s+\S+\s+)?[A-Z]{2}|[Cc]ác\s+tiếp\s*tuyến\s+với/u;
+var PREFILTER43 = /(?:[Kk]ẻ|[Vv]ẽ)\s+(?:các\s+|hai\s+|2\s+)?tiếp\s*tuyến\s+(?:thứ\s+\S+\s+)?[A-Z]{2}|[Cc]ác\s+tiếp\s*tuyến\s+với|[Tt]iếp\s*tuyến\s+[A-Z]{2}\s*(?:,|và)\s*[A-Z]{2}|[Tt]ừ\s+[A-Z][^.;]{0,20}?(?:kẻ|vẽ)\s+(?:hai|2|các)\s+tiếp\s*tuyến|[A-Z]{2}\s*(?:,|và)\s*[A-Z]{2}\s+là\s+(?:hai\s+|2\s+|các\s+)?tiếp\s*tuyến/u;
 var TWO = new RegExp(
   "(?:[Kk]\u1EBB|[Vv]\u1EBD)\\s+(?:c\xE1c\\s+|hai\\s+|2\\s+)?ti\u1EBFp\\s*tuy\u1EBFn\\s+([A-Z])([A-Z])\\s*(?:,\\s*|v\xE0\\s+)([A-Z])([A-Z])(?!\\p{L})",
   "gu"
@@ -5941,6 +6689,18 @@ var FROM_TOUCH = new RegExp(
   "[Cc]\xE1c\\s+ti\u1EBFp\\s*tuy\u1EBFn\\s+v\u1EDBi\\s+\u0111\u01B0\u1EDDng\\s*tr\xF2n\\s+k\u1EBB\\s+t\u1EEB\\s+([A-Z])(?!\\p{L})[^.;]{0,40}?t\u1EA1i\\s+([A-Z])\\s*(?:,\\s*|v\xE0\\s+)([A-Z])(?!\\p{L})",
   "gu"
 );
+var FROM_DRAW_TOUCH = new RegExp(
+  "[Tt]\u1EEB\\s+([A-Z])(?!\\p{L})[^.;]{0,20}?(?:k\u1EBB|v\u1EBD)\\s+(?:hai|2|c\xE1c)\\s+ti\u1EBFp\\s*tuy\u1EBFn[^.;]{0,40}?t\u1EA1i\\s+([A-Z])\\s*(?:,\\s*|v\xE0\\s+)([A-Z])(?!\\p{L})",
+  "gu"
+);
+var TWO_BARE = new RegExp(
+  "[Tt]i\u1EBFp\\s*tuy\u1EBFn\\s+([A-Z])([A-Z])\\s*(?:,\\s*|v\xE0\\s+)([A-Z])([A-Z])(?!\\p{L})",
+  "gu"
+);
+var NAME_BEFORE_TWO = new RegExp(
+  "([A-Z])([A-Z])\\s*(?:,\\s*|v\xE0\\s+)([A-Z])([A-Z])(?!\\p{L})\\s+l\xE0\\s+(?:hai\\s+|2\\s+|c\xE1c\\s+)?ti\u1EBFp\\s*tuy\u1EBFn",
+  "gu"
+);
 var TOUCH_APPOS = new RegExp(
   "^(?:v\u1EDBi\\s+)?([A-Z])\\s*(?:,\\s*|v\xE0\\s+)([A-Z])\\s+l\xE0\\s+(?:c\xE1c\\s+|hai\\s+|2\\s+)?ti\u1EBFp\\s*\u0111i\u1EC3m",
   "u"
@@ -5950,7 +6710,7 @@ var tangentNamedFromExtRule = {
   id: "tangentNamedFromExt",
   priority: 50,
   languages: ["vi"],
-  patterns: [PREFILTER42],
+  patterns: [PREFILTER43],
   match(ctx) {
     const par = PAREN_CIRCLE2.exec(ctx.problem);
     const circle = par ? par[1] : "O";
@@ -5979,14 +6739,43 @@ var tangentNamedFromExtRule = {
         });
       }
     }
+    for (const c of ctx.clauses) {
+      if (twoClauses.has(c.id)) continue;
+      TWO_BARE.lastIndex = 0;
+      NAME_BEFORE_TWO.lastIndex = 0;
+      const hits = [...c.text.matchAll(TWO_BARE), ...c.text.matchAll(NAME_BEFORE_TWO)];
+      for (const m of hits) {
+        if (twoClauses.has(c.id)) continue;
+        const ext = m[1];
+        if (m[3] !== ext) continue;
+        const p = m[2];
+        const q = m[4];
+        if (p === q || p === ext || q === ext) continue;
+        twoClauses.add(c.id);
+        whichOf.set(ext, 1);
+        out.push({
+          ruleId: "tangentNamedFromExt",
+          clauseIds: [c.id],
+          intents: [
+            addPoint(p, { kind: "tangentPoint", from: ext, circle, which: 0 }),
+            addPoint(q, { kind: "tangentPoint", from: ext, circle, which: 1 }),
+            connect(ext, p, "segment"),
+            connect(ext, q, "segment")
+          ]
+        });
+      }
+    }
     for (const c of ctx.clauses) {
       if (twoClauses.has(c.id)) continue;
       FROM_TOUCH.lastIndex = 0;
-      for (const m of c.text.matchAll(FROM_TOUCH)) {
+      FROM_DRAW_TOUCH.lastIndex = 0;
+      const hits = [...c.text.matchAll(FROM_TOUCH), ...c.text.matchAll(FROM_DRAW_TOUCH)];
+      for (const m of hits) {
         const ext = m[1];
         const p = m[2];
         const q = m[3];
         if (p === q || p === ext || q === ext) continue;
+        if (twoClauses.has(c.id)) continue;
         twoClauses.add(c.id);
         whichOf.set(ext, 1);
         out.push({
@@ -6040,11 +6829,16 @@ var tangentNamedFromExtRule = {
 // src/stamps/geometry-2d/ai/rules/secant.ts
 var CAT_TUYEN = /cát\s*tuyến\s+([A-Z])([A-Z])([A-Z])(?![A-Z])/gu;
 var LINE_THROUGH = new RegExp(
-  String.raw`[Qq]ua\s+(?:điểm\s+)?([A-Z])(?!\p{L})[^.]{0,30}?cắt\s+(?:đường\s*tròn\s*)?(?:\(\s*([A-Z])\s*\)\s*)?(?:tại|ở)\s+(?:hai\s+|2\s+)?(?:điểm\s+)?([A-Z])\s*(?:và|,)\s*([A-Z])(?![A-Z])`,
+  String.raw`[Qq]ua\s+(?:điểm\s+)?([A-Z])(?!\p{L})[^.]{0,30}?cắt\s+(?:lại\s+)?(?:nửa\s+)?(?:đường\s*tròn\s*)?(?:\(\s*([A-Z])\s*\)\s*|[A-Z]\s+)?(?:tại|ở)\s+(?:hai\s+|2\s+)?(?:điểm\s+)?([A-Z])\s*(?:và|,)\s*([A-Z])(?![A-Z])`,
+  "gu"
+);
+var CAT_CUTS = new RegExp(
+  String.raw`cát\s*tuyến\s+(?:[a-z][a-z0-9]?\s+)?cắt\s+(?:lại\s+)?(?:nửa\s+)?(?:đường\s*tròn\s*)?(?:\(\s*([A-Z])\s*\)\s*|[A-Z]\s+)?(?:tại|ở)\s+(?:hai\s+|2\s+)?(?:điểm\s+)?([A-Z])\s*(?:và|,)\s*([A-Z])(?![A-Z])`,
   "gu"
 );
 var PAREN_CIRCLE3 = /\(\s*([A-Z])\s*\)/u;
-var PREFILTER43 = /cát\s*tuyến|[Qq]ua\s+(?:điểm\s+)?[A-Z][^.]{0,30}?cắt/u;
+var EXT_RESOLVE = /([A-Z])(?!\p{L})[^.A-Z]{0,25}?(?:ở\s+|nằm\s+)?ngoài\s+(?:\(|nửa|đường\s*tròn)/u;
+var PREFILTER44 = /cát\s*tuyến|[Qq]ua\s+(?:điểm\s+)?[A-Z][^.]{0,30}?cắt/u;
 function secantIntents(ext, near, far, circle, theta) {
   if ((/* @__PURE__ */ new Set([ext, near, far])).size !== 3) return null;
   const line = ext + near;
@@ -6058,13 +6852,26 @@ var secantRule = {
   id: "secant",
   priority: 58,
   languages: ["vi"],
-  patterns: [PREFILTER43],
+  patterns: [PREFILTER44],
   match(ctx) {
     const par = PAREN_CIRCLE3.exec(ctx.problem);
     const fallbackCircle = par ? par[1] : "O";
+    const extM = EXT_RESOLVE.exec(ctx.problem);
+    const resolvedExt = extM ? extM[1] : void 0;
     const out = [];
     let theta = 2.4;
     for (const c of ctx.clauses) {
+      if (resolvedExt) {
+        CAT_CUTS.lastIndex = 0;
+        for (const m of c.text.matchAll(CAT_CUTS)) {
+          const circle = m[1] ?? fallbackCircle;
+          const intents = secantIntents(resolvedExt, m[2], m[3], circle, theta);
+          if (intents) {
+            out.push({ ruleId: "secant", clauseIds: [c.id], intents });
+            theta += 0.7;
+          }
+        }
+      }
       CAT_TUYEN.lastIndex = 0;
       for (const m of c.text.matchAll(CAT_TUYEN)) {
         const intents = secantIntents(m[1], m[2], m[3], fallbackCircle, theta);
@@ -6089,14 +6896,21 @@ var secantRule = {
 
 // src/stamps/geometry-2d/ai/rules/oppositeRayPoint.ts
 var RE17 = new RegExp(
-  String.raw`[Tt]rên\s+tia\s+đối\s+(?:của\s+)?tia\s+([A-Z])([A-Z])(?![A-Z])[^.]{0,20}?lấy\s+(?:một\s+)?(?:điểm\s+)?([A-Z])(?![A-Z])`,
+  String.raw`[Tt]rên\s+tia\s+đối\s+(?:của\s+)?(?:tia\s+)?([A-Z])([A-Z])(?![A-Z])[^.]{0,20}?lấy\s+(?:một\s+)?(?:điểm\s+)?([A-Z])(?![A-Z])`,
   "gu"
 );
 var RE_NAME_FIRST = new RegExp(
-  String.raw`[Ll]ấy\s+(?:điểm\s+)?([A-Z])(?![A-Z])\s+trên\s+tia\s+đối\s+(?:của\s+)?tia\s+([A-Z])([A-Z])(?![A-Z])`,
+  String.raw`[Ll]ấy\s+(?:điểm\s+)?([A-Z])(?![A-Z])\s+trên\s+tia\s+đối\s+(?:của\s+)?(?:tia\s+)?([A-Z])([A-Z])(?![A-Z])`,
   "gu"
 );
+var RE_DISTRIB = new RegExp(
+  String.raw`[Ll]ấy\s+(?:các\s+)?(?:điểm\s+)?((?:[A-Z]\s*(?:,|và)\s*)+[A-Z])(?![A-Z])\s+(?:lần\s*lượt\s+|(?:theo\s+)?thứ\s+tự\s+)?(?:thuộc|trên|nằm\s+trên)\s+(?:các\s+)?tia\s+đối\s+(?:của\s+)?(?:các\s+)?(?:tia\s+)?((?:[A-Z]{2}\s*(?:,|và)\s*)+[A-Z]{2})(?![A-Z])`,
+  "u"
+);
 var CANON = 2.5;
+function splitNames2(blob) {
+  return blob.split(/\s*,\s*|\s+và\s+/u).map((s) => s.trim()).filter(Boolean);
+}
 var oppositeRayPointRule = {
   id: "oppositeRayPoint",
   priority: 56,
@@ -6105,6 +6919,35 @@ var oppositeRayPointRule = {
   match(ctx) {
     const out = [];
     for (const c of ctx.clauses) {
+      const dm = RE_DISTRIB.exec(c.text);
+      if (dm) {
+        const names = splitNames2(dm[1]);
+        const rays = splitNames2(dm[2]);
+        if (names.length >= 2 && names.length === rays.length) {
+          const intents = [];
+          let valid3 = true;
+          for (let i = 0; i < names.length; i++) {
+            const a = rays[i][0];
+            const b = rays[i][1];
+            if ((/* @__PURE__ */ new Set([a, b, names[i]])).size !== 3) {
+              valid3 = false;
+              break;
+            }
+            intents.push(
+              addPoint(names[i], {
+                kind: "pointAtDistance",
+                from: b,
+                through: a,
+                distance: { kind: "literal", value: CANON }
+              })
+            );
+          }
+          if (valid3) {
+            out.push({ ruleId: "oppositeRayPoint", clauseIds: [c.id], intents });
+            continue;
+          }
+        }
+      }
       RE17.lastIndex = 0;
       for (const m of c.text.matchAll(RE17)) {
         const a = m[1];
@@ -6160,7 +7003,7 @@ var CENTER3 = /\(\s*([A-Z])\s*[;,)]|tâm\s+([A-Z])(?![A-Za-z])/u;
 function appearsBefore(problem, chordText, d) {
   const pos = problem.indexOf(chordText);
   if (pos < 0) return true;
-  return new RegExp(`(?<![A-Za-z])${d}(?![a-z])`, "u").test(problem.slice(0, pos));
+  return new RegExp(`(?<![A-Za-z])${escapeRe(d)}(?![a-z])`, "u").test(problem.slice(0, pos));
 }
 var perpChordAtFootRule = {
   id: "perpChordAtFoot",
@@ -6242,12 +7085,12 @@ var diameterCircleSecantRule = {
       CUTS.lastIndex = 0;
       for (const m of c.text.matchAll(CUTS)) {
         const line = m[1];
-        const z46 = m[2];
-        if (line.includes(z46) || onCircle.has(z46)) continue;
+        const z47 = m[2];
+        if (line.includes(z47) || onCircle.has(z47)) continue;
         const other = onCircle.has(line[0]) ? line[0] : onCircle.has(line[1]) ? line[1] : void 0;
         if (!other) continue;
-        onCircle.add(z46);
-        const intent = addPoint(z46, { kind: "secondIntersection", line, circle, other });
+        onCircle.add(z47);
+        const intent = addPoint(z47, { kind: "secondIntersection", line, circle, other });
         out.push({ ruleId: "diameterCircleSecant", clauseIds: [c.id], intents: [intent] });
       }
     }
@@ -6256,7 +7099,7 @@ var diameterCircleSecantRule = {
 };
 
 // src/stamps/geometry-2d/ai/rules/tangentsAtMeet.ts
-var PREFILTER44 = /[Tt]iếp\s*tuyến[^.]{0,40}?tại\s+[A-Z][^.]{0,30}?(?:và|,)\s*[A-Z][^.]{0,30}?cắt\s+nhau/u;
+var PREFILTER45 = /[Tt]iếp\s*tuyến[^.]{0,40}?tại\s+[A-Z][^.]{0,30}?(?:và|,)\s*[A-Z][^.]{0,30}?cắt\s+nhau/u;
 var CIRCLE_REF6 = /đường\s*tròn\s*(?:tâm\s+)?\(?\s*([A-ZωΩ])(?:\s*[;,]\s*[Rr])?\s*\)?|\(\s*([A-ZωΩ])\s*\)/u;
 var RE19 = new RegExp(
   "[Tt]i\u1EBFp\\s*tuy\u1EBFn\\s+(?:c\u1EE7a\\s+[^.]{0,14}?\\s+)?t\u1EA1i\\s+(?:\u0111i\u1EC3m\\s+)?([A-Z])\\s*(?:v\xE0|,)\\s*([A-Z])(?!\\p{L})(?:\\s+c\u1EE7a\\s+[^.]{0,14}?)?\\s+c\u1EAFt\\s+nhau\\s+(?:t\u1EA1i|\u1EDF)\\s+(?:\u0111i\u1EC3m\\s+)?([A-Z])(?![A-Z])",
@@ -6273,7 +7116,7 @@ var tangentsAtMeetRule = {
   priority: 55,
   // trên intersection(45) — 2 tiếp tuyến + giao trong CÙNG match nên tự đủ thứ tự
   languages: ["vi"],
-  patterns: [PREFILTER44],
+  patterns: [PREFILTER45],
   match(ctx) {
     const circle = circleName5(ctx.problem);
     if (!circle) return [];
@@ -6301,7 +7144,7 @@ var tangentsAtMeetRule = {
 };
 
 // src/stamps/geometry-2d/ai/rules/angleBisectorCutsSideCircle.ts
-var PREFILTER45 = /phân\s*giác[^.]{0,40}?cắt/u;
+var PREFILTER46 = /phân\s*giác[^.]{0,40}?cắt/u;
 var FOOT = new RegExp(
   "ph\xE2n\\s*gi\xE1c\\s+(?:trong\\s+)?(?:c\u1EE7a\\s+)?g\xF3c\\s+([A-Z])([A-Z])?([A-Z])?(?![A-Z])[^.]{0,20}?c\u1EAFt\\s+(?:c\u1EA1nh\\s+)?([A-Z])([A-Z])(?![A-Z])\\s+(?:t\u1EA1i|\u1EDF)\\s+(?:\u0111i\u1EC3m\\s+)?([A-Z])(?![A-Z])",
   "u"
@@ -6316,7 +7159,7 @@ var angleBisectorCutsSideCircleRule = {
   priority: 48,
   // sau triangle/circle/cevian; trước intersection(45)
   languages: ["vi"],
-  patterns: [PREFILTER45],
+  patterns: [PREFILTER46],
   match(ctx) {
     const out = [];
     for (const c of ctx.clauses) {
@@ -6362,7 +7205,7 @@ var angleBisectorCutsSideCircleRule = {
 };
 
 // src/stamps/geometry-2d/ai/rules/circleCutsArcSecond.ts
-var PREFILTER46 = /đường\s*tròn\s+đường\s*kính\s+[A-Z]{2}[^.]{0,40}?cắt\s+(?:cung|(?:nửa\s+)?đường\s*tròn)/u;
+var PREFILTER47 = /đường\s*tròn\s+đường\s*kính\s+[A-Z]{2}[^.]{0,40}?cắt\s+(?:cung|(?:nửa\s+)?đường\s*tròn)/u;
 var CUTS_ARC = new RegExp(
   "\u0111\u01B0\u1EDDng\\s*tr\xF2n\\s+\u0111\u01B0\u1EDDng\\s*k\xEDnh\\s+([A-Z])([A-Z])(?![A-Z])[^.]{0,20}?c\u1EAFt\\s+cung\\s+(?:nh\u1ECF\\s+|l\u1EDBn\\s+)?([A-Z])([A-Z])(?![A-Z])[^.]{0,24}?(?:t\u1EA1i|\u1EDF)\\s+(?:\u0111i\u1EC3m\\s+)?([A-Z])(?![A-Z])(?:\\s+kh\xE1c\\s+([A-Z])(?![A-Z]))?",
   "u"
@@ -6377,7 +7220,7 @@ var circleCutsArcSecondRule = {
   priority: 45,
   // sau mọi rule dựng đường tròn + điểm chung
   languages: ["vi"],
-  patterns: [PREFILTER46],
+  patterns: [PREFILTER47],
   match(ctx) {
     const out = [];
     for (const c of ctx.clauses) {
@@ -6416,7 +7259,7 @@ var circleCutsArcSecondRule = {
 };
 
 // src/stamps/geometry-2d/ai/rules/angleBisectorCutsCircleLine.ts
-var PREFILTER47 = /[Pp]hân\s*giác[^.]{0,40}?cắt\s+(?:đường\s*tròn|\()/u;
+var PREFILTER48 = /[Pp]hân\s*giác[^.]{0,40}?cắt\s+(?:đường\s*tròn|\()/u;
 var RE20 = new RegExp(
   "[Pp]h\xE2n\\s*gi\xE1c\\s+(?:trong\\s+)?(?:c\u1EE7a\\s+)?g\xF3c\\s+([A-Z])([A-Z])([A-Z])(?![A-Z])\\s+c\u1EAFt\\s+(?:\u0111\u01B0\u1EDDng\\s*tr\xF2n\\s*)?(?:\\(\\s*([A-Z])(?:['\u2032]?)\\s*\\))?[^.]{0,16}?(?:t\u1EA1i|\u1EDF)\\s+(?:\u0111i\u1EC3m\\s+)?([A-Z])(?![A-Z])(?:\\s+kh\xE1c\\s+[A-Z](?![A-Z]))?(?:\\s*,?\\s*v\xE0\\s+(?:c\u1EAFt\\s+)?(?:\u0111\u01B0\u1EDDng\\s*th\u1EB3ng\\s+|c\u1EA1nh\\s+|\u0111o\u1EA1n\\s+)?([A-Z]{2})(?![A-Z])\\s+(?:t\u1EA1i|\u1EDF)\\s+(?:\u0111i\u1EC3m\\s+)?([A-Z])(?![A-Z]))?",
   "u"
@@ -6429,7 +7272,7 @@ var angleBisectorCutsCircleLineRule = {
   // perpFoot 65 dựng tia/C/H trước).
   priority: 49,
   languages: ["vi"],
-  patterns: [PREFILTER47],
+  patterns: [PREFILTER48],
   match(ctx) {
     const out = [];
     for (const c of ctx.clauses) {
@@ -6461,17 +7304,34 @@ var angleBisectorCutsCircleLineRule = {
 };
 
 // src/stamps/geometry-2d/ai/rules/tangentLineNamedAtPoint.ts
-var PREFILTER48 = /(?:trên|thuộc)\s+\(\s*[A-Z][^)]*\)[^.]{0,24}?kẻ\s+tiếp\s*tuyến\s+[a-z]/u;
+var PREFILTER49 = /(?:trên|thuộc)\s+\(\s*[A-Z][^)]*\)[^.]{0,24}?kẻ\s+tiếp\s*tuyến\s+[a-z]|tiếp\s*tuyến\s+[a-z][0-9]?\s+(?:của|với)\s+|(?:[Qq]ua|[Tt]ừ)\s+[A-Z]\s+(?:vẽ|kẻ)\s+tiếp\s*tuyến\s+[a-z]/u;
 var RE21 = new RegExp(
   "(?:t\u1EEB\\s+|qua\\s+)?(?:m\u1ED9t\\s+)?\u0111i\u1EC3m\\s+([A-Z])(?![A-Z])\\s+(?:tr\xEAn|thu\u1ED9c)\\s+\\(\\s*([A-Z])(?:['\u2032]?)\\s*\\)[^.]{0,24}?k\u1EBB\\s+ti\u1EBFp\\s*tuy\u1EBFn\\s+([a-z][0-9]?)(?!\\p{L})",
   "gu"
 );
+var RE_NAMED_OF_AT = new RegExp(
+  "(?:[VvKk]\u1EBD|[Kk]\u1EBB|[Dd]\u1EF1ng)?\\s*ti\u1EBFp\\s*tuy\u1EBFn\\s+([a-z][0-9]?)(?!\\p{L})\\s+(?:c\u1EE7a|v\u1EDBi)\\s+(?:\u0111\u01B0\u1EDDng\\s*tr\xF2n\\s*)?\\(\\s*([A-Z])(?:['\u2032]?)\\s*\\)\\s+t\u1EA1i\\s+(?:\u0111i\u1EC3m\\s+)?([A-Z])(?![A-Z])",
+  "gu"
+);
+var RE_THROUGH_NAMED = new RegExp(
+  "(?:[Qq]ua|[Tt]\u1EEB)\\s+([A-Z])(?![A-Z])\\s+(?:v\u1EBD|k\u1EBB)\\s+ti\u1EBFp\\s*tuy\u1EBFn\\s+([a-z]{1,2}[0-9]?)(?!\\p{L})",
+  "gu"
+);
+var PAREN_CIRCLE4 = /\(\s*([A-Z])(?:\s*[;,]\s*[Rr])?\s*\)|đường\s*tròn\s+tâm\s+([A-Z])(?![A-Za-z])/u;
+function circleDslName(problem, center) {
+  return /đường\s*kính/u.test(problem) ? `${center}_c` : center;
+}
+function resolveProblemCircle(problem) {
+  const m = PAREN_CIRCLE4.exec(problem);
+  const center = m?.[1] ?? m?.[2];
+  return center ? circleDslName(problem, center) : void 0;
+}
 var tangentLineNamedAtPointRule = {
   id: "tangentLineNamedAtPoint",
   priority: 63,
   // cao như tangentAt — đường d phải dựng trước điểm-trên-d
   languages: ["vi"],
-  patterns: [PREFILTER48],
+  patterns: [PREFILTER49],
   match(ctx) {
     const out = [];
     for (const c of ctx.clauses) {
@@ -6486,6 +7346,30 @@ var tangentLineNamedAtPointRule = {
           intents: [drawLine(line, "tangentAt", { through, circle })]
         });
       }
+      RE_NAMED_OF_AT.lastIndex = 0;
+      for (const m of c.text.matchAll(RE_NAMED_OF_AT)) {
+        const line = m[1];
+        const circle = circleDslName(ctx.problem, m[2]);
+        const through = m[3];
+        out.push({
+          ruleId: "tangentLineNamedAtPoint",
+          clauseIds: [c.id],
+          intents: [drawLine(line, "tangentAt", { through, circle })]
+        });
+      }
+      RE_THROUGH_NAMED.lastIndex = 0;
+      const probCircle = resolveProblemCircle(ctx.problem);
+      if (probCircle) {
+        for (const m of c.text.matchAll(RE_THROUGH_NAMED)) {
+          const through = m[1];
+          const line = m[2];
+          out.push({
+            ruleId: "tangentLineNamedAtPoint",
+            clauseIds: [c.id],
+            intents: [drawLine(line, "tangentAt", { through, circle: probCircle })]
+          });
+        }
+      }
     }
     return out;
   }
@@ -6531,13 +7415,13 @@ var givenDiameterCircleRule = {
 
 // src/stamps/geometry-2d/ai/rules/multiDiameterCircles.ts
 var RE23 = /đường\s*kính\s+(?:theo\s+thứ\s+tự\s+)?(?:là\s+)?((?:[A-Z]{2}\s*,\s*)+[A-Z]{2})(?![A-Z])[^.]{0,30}?tâm\s+(?:theo\s+thứ\s+tự\s+)?(?:là\s+)?((?:[A-Z](?:['′])?\s*,\s*)+[A-Z](?:['′])?)(?![A-Z])/u;
-var PREFILTER49 = /đường\s*kính[^.]{0,40}?tâm/u;
+var PREFILTER50 = /đường\s*kính[^.]{0,40}?tâm/u;
 var multiDiameterCirclesRule = {
   id: "multiDiameterCircles",
   priority: 67,
   // như circleDiameter — dựng đầu mút + tâm trước điểm phái sinh
   languages: ["vi"],
-  patterns: [PREFILTER49],
+  patterns: [PREFILTER50],
   match(ctx) {
     for (const c of ctx.clauses) {
       const m = RE23.exec(c.text);
@@ -6589,12 +7473,12 @@ function diameterMap(problem) {
   }
   return map;
 }
-var PREFILTER50 = /giao\s*điểm\s+(?:của\s+)?[A-Z]{2}\s*,\s*[A-Z]{2}[^.]{0,30}?(?:với|cắt)\s+(?:các\s+)?(?:(?:nửa\s+)?đường\s*tròn\s*)?\(/u;
+var PREFILTER51 = /giao\s*điểm\s+(?:của\s+)?[A-Z]{2}\s*,\s*[A-Z]{2}[^.]{0,30}?(?:với|cắt)\s+(?:các\s+)?(?:(?:nửa\s+)?đường\s*tròn\s*)?\(/u;
 var cutCirclesDistribRule = {
   id: "cutCirclesDistrib",
   priority: 45,
   languages: ["vi"],
-  patterns: [PREFILTER50],
+  patterns: [PREFILTER51],
   match(ctx) {
     const map = diameterMap(ctx.problem);
     const out = [];
@@ -6622,6 +7506,7 @@ var cutCirclesDistribRule = {
 // src/stamps/geometry-2d/ai/rules/givenNamedCircle.ts
 var BARE_PAREN2 = /\(\s*([A-Z])\s*\)/gu;
 var HAS_POINTS_ON = /(?:trên|thuộc)\s+(?:nửa\s+)?(?:đường\s*tròn|cung|\(\s*[A-Z]\s*\))/u;
+var HAS_TANGENT_OR_SECANT = /tiếp\s*tuyến|cát\s*tuyến/u;
 var givenNamedCircleRule = {
   id: "givenNamedCircle",
   priority: 74,
@@ -6629,7 +7514,7 @@ var givenNamedCircleRule = {
   languages: ["vi"],
   patterns: [/\(\s*[A-Z]\s*\)/u],
   match(ctx) {
-    if (!HAS_POINTS_ON.test(ctx.problem)) return [];
+    if (!HAS_POINTS_ON.test(ctx.problem) && !HAS_TANGENT_OR_SECANT.test(ctx.problem)) return [];
     const out = [];
     const seen = /* @__PURE__ */ new Set();
     BARE_PAREN2.lastIndex = 0;
@@ -6637,12 +7522,14 @@ var givenNamedCircleRule = {
       const center = m[1];
       if (seen.has(center)) continue;
       const c = center;
-      if (new RegExp(`\\(\\s*${c}\\s*[;,]`, "u").test(ctx.problem)) continue;
-      if (new RegExp(`\\(\\s*${c}\\s*\\)[^.]{0,30}?\u0111\u01B0\u1EDDng\\s*k\xEDnh|\u0111\u01B0\u1EDDng\\s*k\xEDnh[^.]{0,30}?\\(\\s*${c}\\s*\\)`, "u").test(ctx.problem)) continue;
-      if (new RegExp(`(?:n\u1ED9i|ngo\u1EA1i)\\s*ti\u1EBFp[^.]{0,30}?\\(\\s*${c}\\s*\\)|\\(\\s*${c}\\s*\\)[^.]{0,30}?(?:n\u1ED9i|ngo\u1EA1i)\\s*ti\u1EBFp`, "u").test(ctx.problem)) continue;
-      if (!new RegExp(`${CIRCLE_KW}\\s*\\(\\s*${c}\\s*\\)`, "u").test(ctx.problem)) continue;
+      if (new RegExp(`\\(\\s*${escapeRe(c)}\\s*[;,]`, "u").test(ctx.problem)) continue;
+      if (new RegExp(`\\(\\s*${escapeRe(c)}\\s*\\)[^.]{0,30}?\u0111\u01B0\u1EDDng\\s*k\xEDnh|\u0111\u01B0\u1EDDng\\s*k\xEDnh[^.]{0,30}?\\(\\s*${escapeRe(c)}\\s*\\)`, "u").test(ctx.problem)) continue;
+      if (new RegExp(`(?:n\u1ED9i|ngo\u1EA1i)\\s*ti\u1EBFp[^.]{0,30}?\\(\\s*${escapeRe(c)}\\s*\\)|\\(\\s*${escapeRe(c)}\\s*\\)[^.]{0,30}?(?:n\u1ED9i|ngo\u1EA1i)\\s*ti\u1EBFp`, "u").test(ctx.problem)) continue;
+      const isNamedCircle = new RegExp(`${CIRCLE_KW}\\s*\\(\\s*${escapeRe(c)}\\s*\\)`, "u").test(ctx.problem);
+      const isOpenedBare = new RegExp(`^[Cc]ho\\s+\\(\\s*${escapeRe(c)}\\s*\\)`, "u").test(ctx.problem.trimStart());
+      if (!isNamedCircle && !isOpenedBare) continue;
       seen.add(center);
-      const owner = ctx.clauses.find((cl) => new RegExp(`\\(\\s*${c}\\s*\\)`, "u").test(cl.text));
+      const owner = ctx.clauses.find((cl) => new RegExp(`\\(\\s*${escapeRe(c)}\\s*\\)`, "u").test(cl.text));
       out.push({
         ruleId: "givenNamedCircle",
         clauseIds: owner ? [owner.id] : [],
@@ -6654,12 +7541,16 @@ var givenNamedCircleRule = {
 };
 
 // src/stamps/geometry-2d/ai/rules/twoPerpLinesMeet.ts
-var PREFILTER51 = /[Đđ]ường\s*thẳng\s+qua\s+[A-Z][^.]{0,30}?(?:vuông\s*góc|⊥)[^.]{0,40}?cắt\s+(?:[Đđ]ường\s*thẳng\s+qua|nhau)/u;
+var PREFILTER52 = /(?:[Đđ]ường\s*thẳng\s+qua|(?:Qua|qua|Từ|từ)\s+[A-Z][^.]{0,20}?(?:vẽ|kẻ|dựng)\s+đường\s*thẳng)\s*[^.]{0,30}?(?:vuông\s*góc|⊥)[^.]{0,40}?cắt\s+(?:[Đđ]ường\s*thẳng\s+qua|nhau)/u;
 var RE25 = new RegExp(
   "[\u0110\u0111]\u01B0\u1EDDng\\s*th\u1EB3ng\\s+qua\\s+([A-Z])(?!\\p{L})\\s+(?:vu\xF4ng\\s*g\xF3c|\u22A5)\\s+(?:v\u1EDBi\\s+)?([A-Z])([A-Z])(?![A-Z])[^.]{0,20}?c\u1EAFt\\s+[\u0110\u0111]\u01B0\u1EDDng\\s*th\u1EB3ng\\s+qua\\s+([A-Z])(?!\\p{L})\\s+(?:vu\xF4ng\\s*g\xF3c|\u22A5)\\s+(?:v\u1EDBi\\s+)?([A-Z])([A-Z])(?![A-Z])\\s+(?:t\u1EA1i|\u1EDF)\\s+(?:\u0111i\u1EC3m\\s+)?([A-Z])(?![A-Z])",
   "gu"
 );
-var RE_DISTRIB = new RegExp(
+var RE_DRAW_FIRST = new RegExp(
+  "(?:Qua|qua|T\u1EEB|t\u1EEB)\\s+(?:\u0111i\u1EC3m\\s+)?([A-Z])(?!\\p{L})\\s*[^.]{0,16}?(?:v\u1EBD|k\u1EBB|d\u1EF1ng)\\s+\u0111\u01B0\u1EDDng\\s*th\u1EB3ng\\s+(?:vu\xF4ng\\s*g\xF3c|\u22A5)\\s+(?:v\u1EDBi\\s+)?([A-Z])([A-Z])(?![A-Z])\\s*[^.]{0,16}?c\u1EAFt\\s+[\u0110\u0111]\u01B0\u1EDDng\\s*th\u1EB3ng\\s+qua\\s+([A-Z])(?!\\p{L})\\s+(?:vu\xF4ng\\s*g\xF3c|\u22A5)\\s+(?:v\u1EDBi\\s+)?([A-Z])([A-Z])(?![A-Z])\\s+(?:t\u1EA1i|\u1EDF)\\s+(?:\u0111i\u1EC3m\\s+)?([A-Z])(?![A-Z])",
+  "gu"
+);
+var RE_DISTRIB2 = new RegExp(
   "[\u0110\u0111]\u01B0\u1EDDng\\s*th\u1EB3ng\\s+qua\\s+([A-Z])(?!\\p{L})\\s*,\\s*([A-Z])(?!\\p{L})\\s+(?:l\u1EA7n\\s*l\u01B0\u1EE3t\\s+|theo\\s*th\u1EE9\\s*t\u1EF1\\s+)?(?:vu\xF4ng\\s*g\xF3c|\u22A5)\\s+(?:v\u1EDBi\\s+)?([A-Z])([A-Z])(?![A-Z])\\s*,\\s*([A-Z])([A-Z])(?![A-Z])[^.]{0,20}?c\u1EAFt\\s+nhau\\s+(?:t\u1EA1i|\u1EDF)\\s+(?:\u0111i\u1EC3m\\s+)?([A-Z])(?![A-Z])",
   "gu"
 );
@@ -6668,7 +7559,7 @@ var twoPerpLinesMeetRule = {
   priority: 49,
   // sau parallelPerp (dựng đường), trước/đủ để S tham chiếu 2 đường
   languages: ["vi"],
-  patterns: [PREFILTER51],
+  patterns: [PREFILTER52],
   match(ctx) {
     const out = [];
     const emit = (c, p1, l1, p2, l2, s) => {
@@ -6690,8 +7581,12 @@ var twoPerpLinesMeetRule = {
       for (const m of c.text.matchAll(RE25)) {
         emit(c, m[1], m[2] + m[3], m[4], m[5] + m[6], m[7]);
       }
-      RE_DISTRIB.lastIndex = 0;
-      for (const m of c.text.matchAll(RE_DISTRIB)) {
+      RE_DRAW_FIRST.lastIndex = 0;
+      for (const m of c.text.matchAll(RE_DRAW_FIRST)) {
+        emit(c, m[1], m[2] + m[3], m[4], m[5] + m[6], m[7]);
+      }
+      RE_DISTRIB2.lastIndex = 0;
+      for (const m of c.text.matchAll(RE_DISTRIB2)) {
         emit(c, m[1], m[3] + m[4], m[2], m[5] + m[6], m[7]);
       }
     }
@@ -6700,27 +7595,57 @@ var twoPerpLinesMeetRule = {
 };
 
 // src/stamps/geometry-2d/ai/rules/circumcircleCutsLine.ts
-var PREFILTER52 = /[Đđ]ường\s*tròn\s+ngoại\s*tiếp\s+(?:tam\s*giác\s+)?[A-Z]{3}[^.]{0,20}?cắt\s+[A-Z]{2}/u;
+var PREFILTER53 = /[Đđ]ường\s*tròn\s+ngoại\s*tiếp\s+(?:tam\s*giác\s+)?[A-Z]{3}[^.]{0,20}?cắt\s+[A-Z]{2}|[Đđ]ường\s*tròn\s+\([A-Z]{3}\)[^.]{0,20}?cắt\s+[A-Z]{2}|\([A-Z]{3}\)\s*∩\s*[A-Z]{2}\s*=\s*\{/u;
 var RE26 = new RegExp(
   "[\u0110\u0111]\u01B0\u1EDDng\\s*tr\xF2n\\s+ngo\u1EA1i\\s*ti\u1EBFp\\s+(?:tam\\s*gi\xE1c\\s+)?([A-Z]{3})(?![A-Z])\\s+c\u1EAFt\\s+(?:l\u1EA1i\\s+)?(?:\u0111\u01B0\u1EDDng\\s*th\u1EB3ng\\s+|\u0111o\u1EA1n\\s+|tia\\s+|c\u1EA1nh\\s+)?([A-Z]{2})(?![A-Z])\\s+(?:t\u1EA1i|\u1EDF)\\s+(?:\u0111i\u1EC3m\\s+(?:th\u1EE9\\s+hai\\s+)?)?([A-Z])(?![A-Z])(?:\\s+kh\xE1c\\s+([A-Z])(?![A-Z]))?",
   "gu"
 );
+var RE_PAREN = new RegExp(
+  "[\u0110\u0111]\u01B0\u1EDDng\\s*tr\xF2n\\s+\\(([A-Z]{3})\\)\\s+c\u1EAFt\\s+(?:l\u1EA1i\\s+)?(?:\u0111\u01B0\u1EDDng\\s*th\u1EB3ng\\s+|\u0111o\u1EA1n\\s+|tia\\s+|c\u1EA1nh\\s+)?([A-Z]{2})(?![A-Z])\\s+(?:t\u1EA1i|\u1EDF)\\s+(?:\u0111i\u1EC3m\\s+(?:th\u1EE9\\s+(?:hai|2)\\s+)?)?(?:l\xE0\\s+)?([A-Z])(?![A-Z])(?:\\s+kh\xE1c\\s+([A-Z])(?![A-Z]))?",
+  "gu"
+);
+var RE_SET = new RegExp(
+  "\\(([A-Z]{3})\\)\\s*\u2229\\s*(?:\u0111\u01B0\u1EDDng\\s*th\u1EB3ng\\s+|\u0111o\u1EA1n\\s+|tia\\s+|c\u1EA1nh\\s+)?([A-Z]{2})(?![A-Z])\\s*=\\s*\\{\\s*([A-Z])(?![A-Z])\\s*,\\s*([A-Z])(?![A-Z])\\s*\\}",
+  "gu"
+);
 var circumcircleCutsLineRule = {
   id: "circumcircleCutsLine",
   priority: 58,
   // sau circleTriangle/cevian; trước intersection(45)
   languages: ["vi"],
-  patterns: [PREFILTER52],
+  patterns: [PREFILTER53],
   match(ctx) {
     const out = [];
     for (const c of ctx.clauses) {
-      RE26.lastIndex = 0;
-      for (const m of c.text.matchAll(RE26)) {
+      for (const re of [RE26, RE_PAREN]) {
+        re.lastIndex = 0;
+        for (const m of c.text.matchAll(re)) {
+          const tri = m[1].split("");
+          const line = m[2];
+          const k = m[3];
+          const shared = m[4] ?? line.split("").find((v) => tri.includes(v));
+          if (!shared || tri.includes(k) || line.includes(k)) continue;
+          const w = `w${m[1]}`;
+          out.push({
+            ruleId: "circumcircleCutsLine",
+            clauseIds: [c.id],
+            intents: [
+              drawCircle(w, "through3", { points: tri }),
+              addPoint(k, { kind: "secondIntersection", line, circle: w, other: shared })
+            ]
+          });
+        }
+      }
+      RE_SET.lastIndex = 0;
+      for (const m of c.text.matchAll(RE_SET)) {
         const tri = m[1].split("");
         const line = m[2];
-        const k = m[3];
-        const shared = m[4] ?? line.split("").find((v) => tri.includes(v));
-        if (!shared || tri.includes(k) || line.includes(k)) continue;
+        const set = [m[3], m[4]];
+        const onLine = set.filter((v) => line.includes(v));
+        if (onLine.length !== 1) continue;
+        const shared = onLine[0];
+        const k = set.find((v) => v !== shared);
+        if (tri.includes(k) || line.includes(k)) continue;
         const w = `w${m[1]}`;
         out.push({
           ruleId: "circumcircleCutsLine",
@@ -6750,7 +7675,7 @@ var LINE_TYPES = [
 var CONCURRENCY = /(?:cắt\s+nhau|đồng\s*quy|gặp\s+nhau|cùng\s+đi\s+qua)\s+(?:tại\s+|qua\s+)?(?:điểm\s+)?([A-Z])(?!\p{L})/u;
 var VERTEX_PAIR = /(?<!\p{L})[A-Z][A-Z](?:['′])?(?!\p{L})/gu;
 var TRI_G9 = /tam\s*giác\s+(?:(?:nhọn|cân|đều|vuông|tù)\s+)*([A-Z])([A-Z])([A-Z])(?![A-Z])/gu;
-var PREFILTER53 = LINE_TYPES.map((t) => t.kw);
+var PREFILTER54 = LINE_TYPES.map((t) => t.kw);
 function trianglesIn4(text) {
   const out = [];
   TRI_G9.lastIndex = 0;
@@ -6783,7 +7708,7 @@ var lineConcurrencyRule = {
   id: "lineConcurrency",
   priority: 69,
   languages: ["vi"],
-  patterns: PREFILTER53,
+  patterns: PREFILTER54,
   match(ctx) {
     const fallbackTri = uniqueTriangle5(ctx.problem);
     const out = [];
@@ -6815,7 +7740,7 @@ var lineConcurrencyRule = {
 };
 
 // src/stamps/geometry-2d/ai/rules/twoCirclesMeet.ts
-var PREFILTER54 = /hai\s+đường\s*tròn[^.]{0,70}?cắt\s+nhau/u;
+var PREFILTER55 = /hai\s+đường\s*tròn[^.]{0,70}?cắt\s+nhau/u;
 var CIRCLE2 = "\\(\\s*([A-Z]['\u2032]?)(?:\\s*[;,]\\s*(?:[Rr]['\u2032]?|\\d+(?:[.,]\\d+)?\\s*[a-z]*))?\\s*\\)";
 var TWO_MEET2 = new RegExp(
   "hai\\s+\u0111\u01B0\u1EDDng\\s*tr\xF2n\\s*" + CIRCLE2 + "\\s*(?:[;,]\\s*)?v\xE0\\s*" + CIRCLE2 + "[^.]{0,50}?c\u1EAFt\\s+nhau\\s+(?:\u1EDF|t\u1EA1i)\\s+(?:hai\\s+\u0111i\u1EC3m\\s+)?([A-Z])(?![A-Za-z])\\s*(?:,|v\xE0)\\s*([A-Z])(?![A-Za-z])",
@@ -6828,7 +7753,7 @@ var twoCirclesMeetRule = {
   // phái sinh downstream → dựng sớm. DƯỚI circleRadius (75) cho nhất quán.
   priority: 74,
   languages: ["vi"],
-  patterns: [PREFILTER54],
+  patterns: [PREFILTER55],
   match(ctx) {
     const m = TWO_MEET2.exec(ctx.problem);
     if (!m) return [];
@@ -6855,7 +7780,7 @@ var twoCirclesMeetRule = {
 };
 
 // src/stamps/geometry-2d/ai/rules/radius.ts
-var PREFILTER55 = /bán\s*kính\s+[A-Z]{2}/u;
+var PREFILTER56 = /bán\s*kính\s+[A-Z]{2}/u;
 var DRAW_RADII = new RegExp(
   "(?:[Vv]\u1EBD|[Kk]\u1EBB|[Dd]\u1EF1ng)\\s+(?:hai\\s+|ba\\s+|2\\s+|3\\s+|c\xE1c\\s+)?b\xE1n\\s*k\xEDnh\\s+([A-Z]{2}(?:\\s*(?:,|v\xE0)\\s*[A-Z]{2})*)(?![A-Z])",
   "u"
@@ -6866,7 +7791,7 @@ var radiusRule = {
   id: "radius",
   priority: 60,
   languages: ["vi"],
-  patterns: [PREFILTER55],
+  patterns: [PREFILTER56],
   match(ctx) {
     const out = [];
     for (const c of ctx.clauses) {
@@ -6890,17 +7815,17 @@ var radiusRule = {
 };
 
 // src/stamps/geometry-2d/ai/rules/perpNamedLine.ts
-var PREFILTER56 = /(?:[Kk]ẻ|[Vv]ẽ|[Dd]ựng)\s+(?:đường\s*thẳng\s+)?[A-Z][a-z]\s*(?:⊥|vuông\s*góc)/u;
+var PREFILTER57 = /(?:[Kk]ẻ|[Vv]ẽ|[Dd]ựng)\s+(?:đường\s*thẳng\s+|tia\s+)?[A-Z][a-z]\s*(?:⊥|vuông\s*góc)/u;
 var RE27 = new RegExp(
   // `⊥\\s*` (KHÔNG `\\s+`): OCR hay dính "Ax⊥MN" (vao10:11). Dạng chữ giữ `\\s+`.
-  "(?:[Kk]\u1EBB|[Vv]\u1EBD|[Dd]\u1EF1ng)\\s+(?:\u0111\u01B0\u1EDDng\\s*th\u1EB3ng\\s+)?([A-Z][a-z])(?![A-Za-z])\\s*(?:\u22A5\\s*|vu\xF4ng\\s*g\xF3c(?:\\s+v\u1EDBi)?\\s+)(?:v\u1EDBi\\s+)?(?:\u0111\u01B0\u1EDDng\\s*th\u1EB3ng\\s+|c\u1EA1nh\\s+|\u0111o\u1EA1n\\s+)?([A-Z]{1,2})(?![A-Z])(?:\\s+(?:t\u1EA1i|\u1EDF)\\s+(?:\u0111i\u1EC3m\\s+)?([A-Z])(?![A-Za-z]))?",
+  "(?:[Kk]\u1EBB|[Vv]\u1EBD|[Dd]\u1EF1ng)\\s+(?:\u0111\u01B0\u1EDDng\\s*th\u1EB3ng\\s+|tia\\s+)?([A-Z][a-z])(?![A-Za-z])\\s*(?:\u22A5\\s*|vu\xF4ng\\s*g\xF3c(?:\\s+v\u1EDBi)?\\s+)(?:v\u1EDBi\\s+)?(?:\u0111\u01B0\u1EDDng\\s*th\u1EB3ng\\s+|c\u1EA1nh\\s+|\u0111o\u1EA1n\\s+)?([A-Z]{1,2})(?![A-Z])(?:\\s*,?\\s*c\u1EAFt\\s+[A-Z]{1,2})?(?:\\s+(?:t\u1EA1i|\u1EDF)\\s+(?:\u0111i\u1EC3m\\s+)?([A-Z])(?![A-Za-z]))?",
   "gu"
 );
 var perpNamedLineRule = {
   id: "perp-named-line",
   priority: 60,
   languages: ["vi"],
-  patterns: [PREFILTER56],
+  patterns: [PREFILTER57],
   match(ctx) {
     const out = [];
     for (const c of ctx.clauses) {
@@ -6926,7 +7851,7 @@ var perpNamedLineRule = {
 };
 
 // src/stamps/geometry-2d/ai/rules/parallelSidePoints.ts
-var PREFILTER57 = /thuộc\s+[A-Z]{2}\s+và\s+[A-Z]{2}\s+sao\s+cho[^.]*?(?:∥|\/\/|song\s*song)/u;
+var PREFILTER58 = /thuộc\s+[A-Z]{2}\s+và\s+[A-Z]{2}\s+sao\s+cho[^.]*?(?:∥|\/\/|song\s*song)/u;
 var PAR2 = "(?:\u2225|\\/\\/|song\\s*song(?:\\s+v\u1EDBi)?)";
 var RE28 = new RegExp(
   "([A-Z])\\s*,\\s*([A-Z])(?![A-Z])\\s+(?:l\u1EA7n\\s*l\u01B0\u1EE3t\\s+|theo\\s+th\u1EE9\\s+t\u1EF1\\s+)?thu\u1ED9c\\s+([A-Z]{2})\\s+v\xE0\\s+([A-Z]{2})(?![A-Z])\\s+sao\\s+cho\\s+([A-Z])([A-Z])(?![A-Z])\\s*" + PAR2 + "\\s*([A-Z]{2})(?![A-Z])\\s*(?:,|v\xE0)\\s*([A-Z])([A-Z])(?![A-Z])\\s*" + PAR2 + "\\s*([A-Z]{2})(?![A-Z])",
@@ -6936,7 +7861,7 @@ var parallelSidePointsRule = {
   id: "parallel-side-points",
   priority: 55,
   languages: ["vi"],
-  patterns: [PREFILTER57],
+  patterns: [PREFILTER58],
   match(ctx) {
     const out = [];
     for (const c of ctx.clauses) {
@@ -6959,36 +7884,370 @@ var parallelSidePointsRule = {
   }
 };
 
-// src/stamps/geometry-2d/ai/rules/parallelThroughCutsCircle.ts
-var DISTRIB4 = new RegExp(
-  String.raw`(?:[CcNn]ác\s+)?đường\s*thẳng\s+qua\s+(?:hai\s+điểm\s+)?([A-Z])(?!\p{L})\s+và\s+([A-Z])(?!\p{L})` + String.raw`\s+song\s*song\s+(?:với\s+)?(?:đường\s*thẳng\s+)?([A-Z])([A-Z])(?!\p{L})` + String.raw`[^.]{0,30}?cắt\s+(?:đường\s*tròn\s*)?\(\s*([A-Z])\s*\)` + String.raw`[^.]{0,30}?lần\s*lượt\s+(?:ở|tại)\s+([A-Z])\s+và\s+([A-Z])(?!\p{L})`,
-  "gu"
-);
-var DECL_NAMED = new RegExp(
-  String.raw`(?:[Qq]ua|[Tt]ừ)\s+(?:điểm\s+)?([A-Z])(?!\p{L})` + String.raw`\s+(?:kẻ|vẽ|dựng)\s+đường\s*thẳng\s+([a-z])(?!\p{L})` + String.raw`\s+song\s*song\s+(?:với\s+)?(?:đường\s*thẳng\s+)?([A-Z])([A-Z])(?!\p{L})`,
-  "u"
-);
-var NAMED_CUT_BOTH = new RegExp(
-  String.raw`[Đđ]ường\s*thẳng\s+([a-z])(?!\p{L})` + String.raw`\s+cắt\s+(?:đường\s*thẳng\s+|cạnh\s+|đoạn\s+)?([A-Z])([A-Z])(?!\p{L})\s+(?:ở|tại)\s+(?:điểm\s+)?([A-Z])(?!\p{L})` + String.raw`[^.]{0,8}?cắt\s+(?:đường\s*tròn\s*)?\(\s*([A-Z])\s*\)\s+(?:ở|tại)\s+(?:điểm\s+(?:thứ\s+hai\s+)?)?(?:là\s+)?([A-Z])(?!\p{L})`,
-  "u"
-);
-var PREFILTER58 = /(?:[Qq]ua|đường\s*thẳng\s+qua)\s+[^.]{0,60}?song\s*song[^.]{0,80}?cắt|(?:[Qq]ua|[Tt]ừ)\s+(?:điểm\s+)?[A-Z][^.]{0,20}?(?:kẻ|vẽ|dựng)\s+đường\s*thẳng\s+[a-z]\s+song\s*song/u;
-function lineNameOf2(through) {
-  return "par" + through;
+// src/stamps/geometry-2d/ai/intent-builders/shared.ts
+var SQRT3 = 1.7320508075688772;
+function triangleCanonical(variant) {
+  switch (variant) {
+    case "equilateral":
+      return [[0, 0], [4, 0], [2, 2 * SQRT3]];
+    case "isoceles-AB":
+      return [[0, 0], [4, 0], [2, 3]];
+    case "isoceles-BC":
+      return [[0, 3], [-2, 0], [2, 0]];
+    case "isoceles-CA":
+      return [[0, 0], [2, 3], [4, 0]];
+    case "right-at-A":
+      return [[0, 0], [4, 0], [0, 3]];
+    case "right-at-B":
+      return [[0, 0], [4, 0], [4, 3]];
+    case "right-at-C":
+      return [[0, 0], [6, 0], [3, 3]];
+    case "any":
+    default:
+      return [[0, 0], [5, 0], [2, 3]];
+  }
 }
-function resolveCircle4(problem) {
-  const m = /đường\s*tròn\s*\(\s*([A-Z])\s*\)|\(\s*([A-Z])\s*\)/u.exec(problem);
-  if (!m) return void 0;
-  return m[1] ?? m[2];
+function squareCanonical() {
+  return [[0, 0], [4, 0], [4, 4], [0, 4]];
 }
-function secondIntersection2(name, line, circle, other) {
-  return addPoint(name, { kind: "secondIntersection", line, circle, other });
+function rectangleCanonical(variant) {
+  if (variant === "tall") return [[0, 0], [2.5, 0], [2.5, 4], [0, 4]];
+  return [[0, 0], [4, 0], [4, 2.5], [0, 2.5]];
 }
-var parallelThroughCutsCircleRule = {
-  id: "parallelThroughCutsCircle",
-  priority: 46,
-  languages: ["vi"],
-  patterns: [PREFILTER58],
+function rhombusCanonical() {
+  return [[-2, 0], [0, -1.5], [2, 0], [0, 1.5]];
+}
+function trapezoidCanonical(variant) {
+  switch (variant) {
+    case "right":
+      return [[0, 0], [5, 0], [3, 3], [0, 3]];
+    case "isoceles":
+      return [[0, 0], [5, 0], [4, 3], [1, 3]];
+    case "general":
+    default:
+      return [[0, 0], [5, 0], [3.5, 3], [1, 3]];
+  }
+}
+function parallelogramCanonical() {
+  return [[0, 0], [4, 0], [5, 3], [1, 3]];
+}
+function quadrilateralCanonical() {
+  return [[0, 0], [5, 0], [4.5, 3.5], [0.5, 3]];
+}
+function addPoint2(s, p) {
+  if (s.pointNames.has(p.name)) {
+    if (p.kind !== "free") {
+      const idx = s.points.findIndex((q) => q.name === p.name);
+      if (idx >= 0 && s.points[idx].kind === "free") s.points[idx] = p;
+    }
+    return;
+  }
+  s.points.push(p);
+  s.pointNames.add(p.name);
+}
+var FREE_DEFAULT_SPREAD = [
+  [3, 3],
+  [-3, 3],
+  [3, -3],
+  [-3, -3],
+  [4, 0],
+  [-4, 0],
+  [0, 4],
+  [0, -4]
+];
+function defaultFreeCoord(s) {
+  let count = 0;
+  for (const p of s.points) if (p.kind === "free") count++;
+  return [...FREE_DEFAULT_SPREAD[count % FREE_DEFAULT_SPREAD.length]];
+}
+function addShape(s, sh) {
+  if (s.shapeNames.has(sh.name)) return;
+  s.shapes.push(sh);
+  s.shapeNames.add(sh.name);
+}
+function uniqueShapeName(s, base) {
+  if (!s.shapeNames.has(base)) return base;
+  let i = 2;
+  while (s.shapeNames.has(`${base}${i}`)) i++;
+  return `${base}${i}`;
+}
+function uniquePointName(s, base) {
+  if (!s.pointNames.has(base)) return base;
+  let i = 2;
+  while (s.pointNames.has(`${base}${i}`)) i++;
+  return `${base}${i}`;
+}
+function ensureSegment(s, a, b) {
+  const k1 = `${a}-${b}`;
+  const k2 = `${b}-${a}`;
+  const existing = s.segmentByEnds.get(k1) ?? s.segmentByEnds.get(k2);
+  if (existing) return existing;
+  const name = uniqueShapeName(s, `${a}${b}`);
+  addShape(s, { name, kind: "segment", p1: a, p2: b });
+  s.segmentByEnds.set(k1, name);
+  return name;
+}
+function resolveLineRefWithFallback(s, ref, anchor) {
+  if (/^[A-Za-z]$/.test(ref) && /^[A-Za-z]$/.test(anchor) && ref !== anchor && s.pointNames.has(ref) && s.pointNames.has(anchor)) {
+    const [a, b] = ref < anchor ? [ref, anchor] : [anchor, ref];
+    return ensureSegment(s, a, b);
+  }
+  return resolveSegmentRef(s, ref);
+}
+function resolveSegmentRef(s, ref) {
+  if (s.shapeNames.has(ref)) return ref;
+  if (/^[A-Z][A-Z]$/u.test(ref)) {
+    return ensureSegment(s, ref[0], ref[1]);
+  }
+  if (ref.length === 2 && s.pointNames.has(ref[0]) && s.pointNames.has(ref[1])) {
+    return ensureSegment(s, ref[0], ref[1]);
+  }
+  const dashMatch = ref.match(/^([A-Za-z][A-Za-z0-9'_]*)[-_]?([A-Za-z][A-Za-z0-9'_]*)$/);
+  if (dashMatch && s.pointNames.has(dashMatch[1]) && s.pointNames.has(dashMatch[2])) {
+    return ensureSegment(s, dashMatch[1], dashMatch[2]);
+  }
+  const sub2 = splitKnownPair(s, ref);
+  if (sub2) return ensureSegment(s, sub2[0], sub2[1]);
+  return ref;
+}
+function splitKnownPair(s, ref) {
+  for (let i = ref.length - 1; i >= 1; i--) {
+    const a = ref.slice(0, i);
+    const b = ref.slice(i);
+    if (s.pointNames.has(a) && s.pointNames.has(b)) return [a, b];
+  }
+  return null;
+}
+function parseEnds(ref) {
+  if (ref.length === 2) return [ref[0], ref[1]];
+  const m = ref.match(/^([A-Za-z][A-Za-z0-9'_]*)[-_]?([A-Za-z][A-Za-z0-9'_]*)$/);
+  if (m) return [m[1], m[2]];
+  return null;
+}
+var SHAPE_VARIANTS = {
+  triangle: ["any", "equilateral", "isoceles-AB", "isoceles-BC", "isoceles-CA", "right-at-A", "right-at-B", "right-at-C"],
+  square: ["standard"],
+  rectangle: ["standard", "wide", "tall"],
+  rhombus: ["standard"],
+  trapezoid: ["right", "isoceles", "general"],
+  parallelogram: ["standard"],
+  quadrilateral: ["any"]
+};
+
+// src/stamps/geometry-2d/ai/rules/inscribedSquare.ts
+function sub(p, q) {
+  return [p[0] - q[0], p[1] - q[1]];
+}
+function add(p, q) {
+  return [p[0] + q[0], p[1] + q[1]];
+}
+function mul(p, k) {
+  return [p[0] * k, p[1] * k];
+}
+function dot(p, q) {
+  return p[0] * q[0] + p[1] * q[1];
+}
+function cross(p, q) {
+  return p[0] * q[1] - p[1] * q[0];
+}
+function len(p) {
+  return Math.hypot(p[0], p[1]);
+}
+function norm2(p) {
+  const l = len(p) || 1;
+  return [p[0] / l, p[1] / l];
+}
+function inscribedSquareCoords(A, B, C) {
+  const u = norm2(sub(C, B));
+  const a = len(sub(C, B));
+  const tA = dot(sub(A, B), u);
+  const foot = add(B, mul(u, tA));
+  const h = len(sub(A, foot));
+  const s = a * h / (a + h);
+  const n = norm2(sub(A, foot));
+  const BA = sub(B, A);
+  const q0 = -(s * cross(n, BA)) / cross(u, BA);
+  const Q = add(B, mul(u, q0));
+  const P = add(B, mul(u, q0 + s));
+  const M = add(Q, mul(n, s));
+  const N = add(P, mul(n, s));
+  return { M, N, P, Q };
+}
+function paramOn(pt, X, Y) {
+  const d = sub(Y, X);
+  return dot(sub(pt, X), d) / (dot(d, d) || 1);
+}
+function inscribedSquareParams(A, B, C) {
+  const { M, N, P, Q } = inscribedSquareCoords(A, B, C);
+  return {
+    tM: paramOn(M, A, B),
+    tN: paramOn(N, A, C),
+    tP: paramOn(P, B, C),
+    tQ: paramOn(Q, B, C)
+  };
+}
+var PREFILTER59 = /hình\s*vuông[^.]*?(?:trên|∈|thuộc|\bNe\b|\bEe\b)/iu;
+var SQUARE_LABELS = /hình\s*vuông\s+([A-Z])\s*([A-Z])\s*([A-Z])\s*([A-Z])(?![A-Z])/u;
+var RIGHT_AT2 = /vuông\s+tại\s+([A-Z])(?![A-Za-z])/u;
+var RIGHT_BY_IDX2 = ["right-at-A", "right-at-B", "right-at-C"];
+var MEMBERSHIP_G = /(?:([A-Z])\s*(?:∈|trên|thuộc)|\b([A-Z])e\b)\s*([A-Z])([A-Z])(?![A-Z])/gu;
+var LIST_MEMBERSHIP_G = /([A-Z])\s*,\s*([A-Z])\s*(?:∈|trên|thuộc)\s*([A-Z])([A-Z])(?![A-Z])/gu;
+function parseMemberships(text) {
+  const out = [];
+  let m;
+  LIST_MEMBERSHIP_G.lastIndex = 0;
+  const listSpans = [];
+  while ((m = LIST_MEMBERSHIP_G.exec(text)) !== null) {
+    const side = [m[3], m[4]];
+    out.push({ pt: m[1], side });
+    out.push({ pt: m[2], side });
+    listSpans.push([m.index, m.index + m[0].length]);
+  }
+  MEMBERSHIP_G.lastIndex = 0;
+  while ((m = MEMBERSHIP_G.exec(text)) !== null) {
+    if (listSpans.some(([a, b]) => m.index >= a && m.index < b)) continue;
+    const pt = m[1] ?? m[2];
+    out.push({ pt, side: [m[3], m[4]] });
+  }
+  return out;
+}
+var inscribedSquareRule = {
+  id: "inscribed-square",
+  priority: 56,
+  languages: ["vi"],
+  patterns: [PREFILTER59],
+  match(ctx) {
+    const out = [];
+    for (const c of ctx.clauses) {
+      const labelM = SQUARE_LABELS.exec(c.text);
+      if (!labelM) continue;
+      const labels = [labelM[1], labelM[2], labelM[3], labelM[4]];
+      if (new Set(labels).size !== 4) continue;
+      const memberships = parseMemberships(c.text);
+      if (memberships.length < 4) continue;
+      const bySide = /* @__PURE__ */ new Map();
+      const ptSide = /* @__PURE__ */ new Map();
+      for (const mem of memberships) {
+        if (!labels.includes(mem.pt)) continue;
+        ptSide.set(mem.pt, mem.side);
+        const key = [...mem.side].sort().join("");
+        const arr = bySide.get(key) ?? [];
+        if (!arr.includes(mem.pt)) arr.push(mem.pt);
+        bySide.set(key, arr);
+      }
+      if (labels.some((l) => !ptSide.has(l))) continue;
+      const sideKeys = [...bySide.keys()];
+      const hypKey = sideKeys.find((k) => (bySide.get(k) ?? []).length === 2);
+      if (!hypKey) continue;
+      const legKeys = sideKeys.filter((k) => k !== hypKey);
+      if (legKeys.length !== 2) continue;
+      if ((bySide.get(legKeys[0]) ?? []).length !== 1) continue;
+      if ((bySide.get(legKeys[1]) ?? []).length !== 1) continue;
+      const triVerts = /* @__PURE__ */ new Set();
+      for (const [, side] of ptSide) side.forEach((v) => triVerts.add(v));
+      if (triVerts.size !== 3) continue;
+      const legVerts = legKeys.map((k) => k.split(""));
+      const apex = legVerts[0].find((v) => legVerts[1].includes(v));
+      if (!apex) continue;
+      const triLabels = [apex, ...[...triVerts].filter((v) => v !== apex).sort()];
+      const explicitRight = collectRightAt(ctx.clauses);
+      if (explicitRight && explicitRight !== apex) continue;
+      const tri = triangleCanonical("right-at-A");
+      const params = inscribedSquareParams(tri[0], tri[1], tri[2]);
+      const placement = assignSquarePlacement(
+        labels,
+        ptSide,
+        bySide.get(hypKey),
+        triLabels[0],
+        // apex (đỉnh góc vuông)
+        triLabels[1],
+        // đỉnh B của tam giác (đầu mút cạnh huyền gần Q)
+        triLabels[2],
+        // đỉnh C của tam giác (đầu mút cạnh huyền gần P)
+        params
+      );
+      if (!placement) continue;
+      const rightIdx = triLabels.indexOf(apex);
+      const variant = RIGHT_BY_IDX2[rightIdx] ?? "right-at-A";
+      const intents = [drawShape("triangle", triLabels, variant)];
+      for (const lbl of labels) {
+        const { of, t } = placement.get(lbl);
+        intents.push(addPoint(lbl, { kind: "onSegment", of, t }));
+      }
+      intents.push(markShape("quadrilateral", labels));
+      const claimed = /* @__PURE__ */ new Set([c.id]);
+      for (const cc of ctx.clauses) {
+        const rm = RIGHT_AT2.exec(cc.text);
+        if (rm && rm[1] === apex) claimed.add(cc.id);
+      }
+      out.push({ ruleId: "inscribed-square", clauseIds: [...claimed], intents });
+    }
+    return out;
+  }
+};
+function collectRightAt(clauses) {
+  for (const c of clauses) {
+    const m = RIGHT_AT2.exec(c.text);
+    if (m) return m[1];
+  }
+  return void 0;
+}
+function assignSquarePlacement(labels, ptSide, hypPts, triA, triB, triC, params) {
+  const place = /* @__PURE__ */ new Map();
+  const onAB = labels.find((l) => !hypPts.includes(l) && ptSide.get(l).includes(triB));
+  const onAC = labels.find((l) => !hypPts.includes(l) && ptSide.get(l).includes(triC));
+  if (!onAB || !onAC) return null;
+  place.set(onAB, { of: `${triA}${triB}`, t: params.tM });
+  place.set(onAC, { of: `${triA}${triC}`, t: params.tN });
+  const neighborInHyp = (anchor) => {
+    const i = labels.indexOf(anchor);
+    const next = labels[(i + 1) % labels.length];
+    const prev = labels[(i - 1 + labels.length) % labels.length];
+    if (hypPts.includes(next)) return next;
+    if (hypPts.includes(prev)) return prev;
+    return void 0;
+  };
+  const qVtx = neighborInHyp(onAB);
+  const pVtx = neighborInHyp(onAC);
+  const hyp = `${triB}${triC}`;
+  if (qVtx) place.set(qVtx, { of: hyp, t: params.tQ });
+  if (pVtx) place.set(pVtx, { of: hyp, t: params.tP });
+  for (const hp of hypPts) {
+    if (!place.has(hp)) place.set(hp, { of: hyp, t: hp === qVtx ? params.tQ : params.tP });
+  }
+  return labels.every((l) => place.has(l)) ? place : null;
+}
+
+// src/stamps/geometry-2d/ai/rules/parallelThroughCutsCircle.ts
+var DISTRIB4 = new RegExp(
+  String.raw`(?:[CcNn]ác\s+)?đường\s*thẳng\s+qua\s+(?:hai\s+điểm\s+)?([A-Z])(?!\p{L})\s+và\s+([A-Z])(?!\p{L})` + String.raw`\s+song\s*song\s+(?:với\s+)?(?:đường\s*thẳng\s+)?([A-Z])([A-Z])(?!\p{L})` + String.raw`[^.]{0,30}?cắt\s+(?:đường\s*tròn\s*)?\(\s*([A-Z])\s*\)` + String.raw`[^.]{0,30}?lần\s*lượt\s+(?:ở|tại)\s+([A-Z])\s+và\s+([A-Z])(?!\p{L})`,
+  "gu"
+);
+var DECL_NAMED = new RegExp(
+  String.raw`(?:[Qq]ua|[Tt]ừ)\s+(?:điểm\s+)?([A-Z])(?!\p{L})` + String.raw`\s+(?:kẻ|vẽ|dựng)\s+đường\s*thẳng\s+([a-z])(?!\p{L})` + String.raw`\s+song\s*song\s+(?:với\s+)?(?:đường\s*thẳng\s+)?([A-Z])([A-Z])(?!\p{L})`,
+  "u"
+);
+var NAMED_CUT_BOTH = new RegExp(
+  String.raw`[Đđ]ường\s*thẳng\s+([a-z])(?!\p{L})` + String.raw`\s+cắt\s+(?:đường\s*thẳng\s+|cạnh\s+|đoạn\s+)?([A-Z])([A-Z])(?!\p{L})\s+(?:ở|tại)\s+(?:điểm\s+)?([A-Z])(?!\p{L})` + String.raw`[^.]{0,8}?cắt\s+(?:đường\s*tròn\s*)?\(\s*([A-Z])\s*\)\s+(?:ở|tại)\s+(?:điểm\s+(?:thứ\s+hai\s+)?)?(?:là\s+)?([A-Z])(?!\p{L})`,
+  "u"
+);
+var PREFILTER60 = /(?:[Qq]ua|đường\s*thẳng\s+qua)\s+[^.]{0,60}?song\s*song[^.]{0,80}?cắt|(?:[Qq]ua|[Tt]ừ)\s+(?:điểm\s+)?[A-Z][^.]{0,20}?(?:kẻ|vẽ|dựng)\s+đường\s*thẳng\s+[a-z]\s+song\s*song/u;
+function lineNameOf2(through) {
+  return "par" + through;
+}
+function resolveCircle4(problem) {
+  const m = /đường\s*tròn\s*\(\s*([A-Z])\s*\)|\(\s*([A-Z])\s*\)/u.exec(problem);
+  if (!m) return void 0;
+  return m[1] ?? m[2];
+}
+function secondIntersection2(name, line, circle, other) {
+  return addPoint(name, { kind: "secondIntersection", line, circle, other });
+}
+var parallelThroughCutsCircleRule = {
+  id: "parallelThroughCutsCircle",
+  priority: 46,
+  languages: ["vi"],
+  patterns: [PREFILTER60],
   match(ctx) {
     const circle = resolveCircle4(ctx.problem);
     if (!circle) return [];
@@ -7064,12 +8323,12 @@ var RE29 = new RegExp(
   "(?:[Mm]\u1ED9t\\s+)?\u0111\u01B0\u1EDDng\\s*th\u1EB3ng\\s+(?:b\u1EA5t\\s*k[i\xECy\u1EF3]|t\xF9y\\s*\xFD)\\s+(?:n\xE0o\\s+)?(?:\u0111i\\s+)?qua\\s+(?:\u0111i\u1EC3m\\s+)?([A-Z])(?!\\p{L})[^.]{0,20}?c\u1EAFt\\s+(?:c\xE1c\\s+)?(?:\u0111\u01B0\u1EDDng\\s*th\u1EB3ng\\s+|c\u1EA1nh\\s+|\u0111o\u1EA1n(?:\\s+th\u1EB3ng)?\\s+)?([A-Z]\\s*[A-Z])(?![A-Z])\\s*(?:,|v\xE0)\\s*([A-Z]\\s*[A-Z])(?![A-Z])[^.]{0,20}?(?:l\u1EA7n\\s*l\u01B0\u1EE3t\\s+|theo\\s+th\u1EE9\\s+t\u1EF1\\s+)?(?:t\u1EA1i|\u1EDF)\\s+(?:\u0111i\u1EC3m\\s+)?([A-Z])\\s*(?:,|v\xE0)\\s*([A-Z])(?![A-Z])",
   "gu"
 );
-var PREFILTER59 = [/đường\s*thẳng\s+(?:bất\s*k[iìyỳ]|tùy\s*ý)\s+(?:nào\s+)?(?:đi\s+)?qua\s+[A-Z]/u];
+var PREFILTER61 = [/đường\s*thẳng\s+(?:bất\s*k[iìyỳ]|tùy\s*ý)\s+(?:nào\s+)?(?:đi\s+)?qua\s+[A-Z]/u];
 var lineThroughCutsTwoLinesRule = {
   id: "lineThroughCutsTwoLines",
   priority: 44,
   languages: ["vi"],
-  patterns: PREFILTER59,
+  patterns: PREFILTER61,
   match(ctx) {
     const out = [];
     for (const c of ctx.clauses) {
@@ -7154,47 +8413,644 @@ function detectSpec(problem) {
   }
   return null;
 }
-var rightAngleViewingRule = {
-  id: "rightAngleViewing",
-  priority: 63,
+var rightAngleViewingRule = {
+  id: "rightAngleViewing",
+  priority: 63,
+  languages: ["vi"],
+  patterns: [
+    /(?:[Gg]óc|∠)[^.;\n]{0,18}90/u,
+    /(?:[Gg]óc|∠)\s*[A-Z]{3}\s*vuông/u,
+    /[A-Z]{2}\s*(?:⊥|vuông\s*góc)\s*[A-Z]{2}/u
+  ],
+  match(ctx) {
+    const spec = detectSpec(ctx.problem);
+    if (!spec) return [];
+    const clauseIds = ctx.clauses.filter(
+      (c) => ANGLE_EQ_RE.test(c.text) || ANGLE_VUONG_RE.test(c.text) || PERP_RE.test(c.text) || findOnLine(c.text, spec.vertex) !== null
+    ).map((c) => c.id);
+    const out = [
+      {
+        ruleId: "rightAngleViewing",
+        clauseIds,
+        intents: [
+          addPoint(spec.vertex, {
+            kind: "rightAngleViewing",
+            a: spec.a,
+            b: spec.b,
+            onLine: spec.onLine
+          })
+        ]
+      }
+    ];
+    return out;
+  }
+};
+
+// src/stamps/geometry-2d/ai/rules/collinearPoints.ts
+var PREFILTER62 = /thẳng\s+hàng|(?:cùng\s+)?(?:thuộc|nằm\s+trên|ở\s+trên)\s+(?:một\s+)?(?:cùng\s+)?(?:một\s+)?[Đđ]ư[ờơ]ng\s*thẳng/u;
+var NAMES = "([A-Z](?:['\u2032])?(?:\\s*(?:,|v\xE0)\\s*[A-Z](?:['\u2032])?){2,})";
+var ON_LINE = new RegExp(
+  "(?:[Cc]\xE1c\\s+|[Cc]ho\\s+)?(?:\\d+\\s+|(?:hai|ba|b\u1ED1n|n\u0103m|s\xE1u)\\s+)?\u0111i\u1EC3m\\s+" + NAMES + "\\s+(?:c\xF9ng\\s+)?(?:thu\u1ED9c|n\u1EB1m\\s+tr\xEAn|\u1EDF\\s+tr\xEAn)\\s+(?:m\u1ED9t\\s+)?[\u0110\u0111]\u01B0[\u1EDD\u01A1]ng\\s*th\u1EB3ng",
+  "u"
+);
+var COLLINEAR = new RegExp(
+  "(?:[Cc]\xE1c\\s+|[Cc]ho\\s+)?(?:\\d+\\s+|(?:hai|ba|b\u1ED1n|n\u0103m|s\xE1u)\\s+)?\u0111i\u1EC3m\\s+" + NAMES + "\\s+th\u1EB3ng\\s+h\xE0ng",
+  "u"
+);
+function parseNames(blob) {
+  return blob.split(/\s*(?:,|và)\s*/u).map((s) => s.trim().replace("\u2032", "'")).filter((s) => /^[A-Z]'?$/u.test(s));
+}
+var collinearPointsRule = {
+  id: "collinear-points",
+  priority: 95,
+  // cao: dựng "bộ khung" điểm thẳng hàng sớm (như triangle/quad).
+  languages: ["vi"],
+  patterns: [PREFILTER62],
+  match(ctx) {
+    const out = [];
+    for (const c of ctx.clauses) {
+      const m = ON_LINE.exec(c.text) ?? COLLINEAR.exec(c.text);
+      if (!m) continue;
+      const names = parseNames(m[1]);
+      if (names.length < 3) continue;
+      if (new Set(names).size !== names.length) continue;
+      const first = names[0];
+      const last = names[names.length - 1];
+      const span = 12;
+      const intents = [
+        addPoint(first, { kind: "free", at: [-span / 2, 0] }),
+        addPoint(last, { kind: "free", at: [span / 2, 0] }),
+        // Điểm giữa: onSegment trên đoạn đầu-cuối, t cách đều theo thứ tự liệt kê.
+        ...names.slice(1, -1).map(
+          (nm, i) => addPoint(nm, { kind: "onSegment", of: `${first}${last}`, t: (i + 1) / (names.length - 1) })
+        ),
+        connect(first, last, "segment")
+      ];
+      out.push({ ruleId: "collinear-points", clauseIds: [c.id], intents });
+    }
+    return out;
+  }
+};
+
+// src/stamps/geometry-2d/ai/rules/quadDiagonals.ts
+var PREFILTER63 = /[A-Z]{4}\s+là\s+(?:một\s+)?tứ\s*giác|tứ\s*giác\s+[A-Z]{4}[^.]{0,60}?đường\s*chéo/u;
+var QUAD_DECL = /([A-Z])([A-Z])([A-Z])([A-Z])(?![A-Z])\s+là\s+(?:một\s+)?tứ\s*giác/u;
+var DIAGONALS = new RegExp(
+  "(?:hai\\s+|c\xE1c\\s+)?\u0111\u01B0\u1EDDng\\s*ch\xE9o\\s+([A-Z]{2})\\s+(?:v\xE0|,)\\s+([A-Z]{2})[^.]{0,40}?c\u1EAFt\\s+nhau\\s+(?:t\u1EA1i|\u1EDF)\\s+(?:\u0111i\u1EC3m\\s+)?([A-Z])(?![A-Z])",
+  "u"
+);
+var quadDiagonalsRule = {
+  id: "quad-diagonals",
+  priority: 99,
+  // ~quad (100): vẽ tứ giác sớm; intersection (45) dựng E sau.
+  languages: ["vi"],
+  patterns: [PREFILTER63],
+  match(ctx) {
+    const out = [];
+    for (const c of ctx.clauses) {
+      const q = QUAD_DECL.exec(c.text);
+      if (!q) continue;
+      const labels = [q[1], q[2], q[3], q[4]];
+      if (new Set(labels).size !== 4) continue;
+      const intents = [drawShape("quadrilateral", labels, "any")];
+      const d = DIAGONALS.exec(c.text);
+      if (d) {
+        const diag1 = d[1];
+        const diag2 = d[2];
+        const e = d[3];
+        const ends = [diag1[0], diag1[1], diag2[0], diag2[1]];
+        const okDiag = new Set(ends).size === 4 && ends.every((x) => labels.includes(x)) && !labels.includes(e);
+        if (okDiag) {
+          intents.push(connect(diag1[0], diag1[1], "segment"));
+          intents.push(connect(diag2[0], diag2[1], "segment"));
+          intents.push(addPoint(e, { kind: "intersection", of: [diag1, diag2] }));
+        }
+      }
+      out.push({ ruleId: "quad-diagonals", clauseIds: [c.id], intents });
+    }
+    return out;
+  }
+};
+
+// src/stamps/geometry-2d/ai/rules/twoCirclesTangent.ts
+var PREFILTER64 = /hai\s+[Đđ]ư[ờơ]ng\s*tròn[^.]{0,70}?tiếp\s*xúc/u;
+var CIRCLE3 = "\\(\\s*([A-Z]['\u2032]?)(?:\\s*[;,]\\s*(?:[Rr]['\u2032]?|\\d+(?:[.,]\\d+)?\\s*[a-z]*))?\\s*\\)";
+var TWO_TANGENT = new RegExp(
+  "hai\\s+[\u0110\u0111]\u01B0[\u1EDD\u01A1]ng\\s*tr\xF2n\\s*" + CIRCLE3 + "\\s*(?:[;,]\\s*)?v\xE0\\s*" + CIRCLE3 + "\\s*ti\u1EBFp\\s*x\xFAc\\s+(ngo\xE0i|trong|nhau)?\\s*(?:nhau\\s+)?(?:t\u1EA1i|\u1EDF)\\s+(?:\u0111i\u1EC3m\\s+)?([A-Z])(?![A-Za-z])",
+  "u"
+);
+var norm3 = (s) => s.replace(/′/g, "'");
+var twoCirclesTangentRule = {
+  id: "two-circles-tangent",
+  // TRÊN chord/externalPoint, cạnh twoCirclesMeet (74): tiếp điểm A là gốc nhiều
+  // phái sinh → dựng sớm.
+  priority: 74,
+  languages: ["vi"],
+  patterns: [PREFILTER64],
+  match(ctx) {
+    const m = TWO_TANGENT.exec(ctx.problem);
+    if (!m) return [];
+    const c1 = norm3(m[1]);
+    const c2 = norm3(m[2]);
+    const mode = m[3];
+    const a = m[4];
+    if (mode === "trong") return [];
+    if (c1 === c2) return [];
+    if (a === c1 || a === c2) return [];
+    const r2 = 2;
+    const declId = ctx.clauses.find((c) => /tiếp\s*xúc/u.test(c.text))?.id;
+    return [
+      {
+        ruleId: "two-circles-tangent",
+        clauseIds: declId === void 0 ? [] : [declId],
+        intents: [
+          // A = gốc; O bên trái cách r1, O' bên phải cách r2 → tiếp xúc ngoài tại A.
+          addPoint(a, { kind: "free", at: [0, 0] }),
+          addPoint(c1, { kind: "free", at: [-3, 0] }),
+          addPoint(c2, { kind: "free", at: [r2, 0] }),
+          drawCircle(`${c1}_t`, "centerThrough", { center: c1, through: a }),
+          drawCircle(`${c2}_t`, "centerThrough", { center: c2, through: a })
+        ]
+      }
+    ];
+  }
+};
+
+// src/stamps/geometry-2d/ai/rules/commonTangent.ts
+var PREFILTER65 = /[Tt]iếp\s*tuyến\s+chung/u;
+var TANGENT_GLUE = /[Tt]iếp\s*tuyến\s+chung\s+(?:(?:ngoài|trong)\s+)?([A-Z])([A-Z])(?![A-Za-z])/u;
+var TANGENT_NAMED_BEFORE2 = /([A-Z])([A-Z])(?![A-Za-z])\s+là\s+tiếp\s*tuyến\s+chung/u;
+var INTERNAL = /tiếp\s*tuyến\s+chung\s+trong/u;
+var CIRCLE_G = /\(\s*([A-Z]['′]?)(?:\s*[;,]\s*(?:[Rr]['′]?|\d+(?:[.,]\d+)?\s*[a-z]*))?\s*\)/gu;
+var CIRC2 = "\\(\\s*([A-Z]['\u2032]?)(?:\\s*[;,]\\s*(?:[Rr]['\u2032]?|\\d+(?:[.,]\\d+)?\\s*[a-z]*))?\\s*\\)";
+var TANGENT_TOUCH = new RegExp(
+  "ti\u1EBFp\\s*x\xFAc\\s+(?:v\u1EDBi\\s+)?" + CIRC2 + "\\s*(?:,|v\xE0)\\s*" + CIRC2 + "\\s+(?:l\u1EA7n\\s*l\u01B0\u1EE3t\\s+|t\u01B0\u01A1ng\\s+\u1EE9ng\\s+|theo\\s+th\u1EE9\\s+t\u1EF1\\s+)?(?:t\u1EA1i|\u1EDF)\\s+(?:c\xE1c\\s+)?(?:\u0111i\u1EC3m\\s+)?([A-Z]['\u2032]?)(?![A-Za-z])\\s*(?:,|v\xE0)\\s*([A-Z]['\u2032]?)(?![A-Za-z])",
+  "u"
+);
+var norm4 = (s) => s.replace(/′/g, "'");
+function membership(problem, pt) {
+  const re = new RegExp(
+    pt + "\\s*(?:\u2208|thu\u1ED9c|n\u1EB1m\\s+tr\xEAn)\\s*(?:[\u0110\u0111]\u01B0[\u1EDD\u01A1]ng\\s*tr\xF2n\\s*)?(?:\\(\\s*)?(?:t\xE2m\\s+)?([A-Z]['\u2032]?)",
+    "u"
+  );
+  const m = re.exec(problem);
+  return m ? norm4(m[1]) : void 0;
+}
+var commonTangentRule = {
+  id: "common-tangent",
+  // Cạnh twoCirclesTangent (74): 2 đtròn + tiếp điểm là gốc nhiều phái sinh.
+  priority: 73,
+  languages: ["vi"],
+  patterns: [PREFILTER65],
+  match(ctx) {
+    const p = ctx.problem;
+    let t1;
+    let t2;
+    let c1;
+    let c2;
+    const mt = TANGENT_TOUCH.exec(p);
+    if (mt) {
+      c1 = norm4(mt[1]);
+      c2 = norm4(mt[2]);
+      t1 = norm4(mt[3]);
+      t2 = norm4(mt[4]);
+    } else {
+      const mg = TANGENT_GLUE.exec(p);
+      if (mg) {
+        t1 = mg[1];
+        t2 = mg[2];
+      } else {
+        const mb = TANGENT_NAMED_BEFORE2.exec(p);
+        if (mb) {
+          t1 = mb[1];
+          t2 = mb[2];
+        }
+      }
+    }
+    if (!t1 || !t2 || t1 === t2) return [];
+    const m1 = c1 ? void 0 : membership(p, t1);
+    const m2 = c2 ? void 0 : membership(p, t2);
+    if (c1 && c2) ; else if (m1 && m2 && m1 !== m2) {
+      c1 = m1;
+      c2 = m2;
+    } else {
+      const seen = [];
+      CIRCLE_G.lastIndex = 0;
+      let cm;
+      while ((cm = CIRCLE_G.exec(p)) !== null) {
+        const nm = norm4(cm[1]);
+        if (!seen.includes(nm)) seen.push(nm);
+        if (seen.length === 2) break;
+      }
+      if (seen.length === 2) {
+        [c1, c2] = seen;
+      }
+    }
+    if (!c1 || !c2 || c1 === c2) return [];
+    if (t1 === c1 || t1 === c2 || t2 === c1 || t2 === c2) return [];
+    const variant = INTERNAL.test(p) ? "internal" : "external";
+    const r1 = 3;
+    const r2 = 2;
+    const declId = ctx.clauses.find((c) => /tiếp\s*tuyến\s+chung/u.test(c.text))?.id;
+    const intents = [
+      addPoint(c1, { kind: "free", at: [0, 0] }),
+      addPoint(c2, { kind: "free", at: [12, 0] }),
+      drawCircle(c1, "centerRadius", { center: c1, radius: r1 }),
+      drawCircle(c2, "centerRadius", { center: c2, radius: r2 }),
+      addPoint(t1, { kind: "commonTangentPoint", circles: [c1, c2], on: 0, variant, side: 0 }),
+      addPoint(t2, { kind: "commonTangentPoint", circles: [c1, c2], on: 1, variant, side: 0 }),
+      connect(t1, t2, "segment")
+    ];
+    return [
+      {
+        ruleId: "common-tangent",
+        clauseIds: declId === void 0 ? [] : [declId],
+        intents
+      }
+    ];
+  }
+};
+
+// src/stamps/geometry-2d/ai/rules/twoCirclesCenterRadiusMeet.ts
+var CENTER_RADIUS = new RegExp(
+  "([A-Z])(?![A-Za-z])\\s+l\xE0m\\s+t\xE2m\\s*,?\\s*(?:v\u1EBD|d\u1EF1ng|k\u1EBB)\\s+" + CIRCLE_KW + "\\s+b\xE1n\\s*k\xEDnh\\s+([A-Z])([A-Z])(?![A-Za-z])",
+  "gu"
+);
+var MEET = new RegExp(
+  "[Hh]ai\\s+" + CIRCLE_KW + "\\s*(?:n\xE0y\\s+)?c\u1EAFt\\s+nhau\\s+(?:(?:\u1EDF|t\u1EA1i)\\s+)?(?:\u0111i\u1EC3m\\s+th\u1EE9\\s+hai\\s+)?(?:l\xE0|t\u1EA1i)\\s+(?:\u0111i\u1EC3m\\s+)?([A-Z])(?![A-Za-z])",
+  "u"
+);
+var PREFILTER66 = /làm\s+tâm[^.]{0,40}?bán\s*kính/u;
+var twoCirclesCenterRadiusMeetRule = {
+  id: "two-circles-center-radius-meet",
+  // Cạnh twoCirclesMeet (74): 2 đtròn + giao điểm là gốc phái sinh.
+  priority: 73,
+  languages: ["vi"],
+  patterns: [PREFILTER66],
+  match(ctx) {
+    const p = ctx.problem;
+    CENTER_RADIUS.lastIndex = 0;
+    const circles = [];
+    let cm;
+    while ((cm = CENTER_RADIUS.exec(p)) !== null) {
+      const center = cm[1];
+      const a = cm[2];
+      const b = cm[3];
+      if (a !== center || b === center) continue;
+      circles.push({ center, through: b });
+    }
+    if (circles.length !== 2) return [];
+    const [k1, k2] = circles;
+    if (k1.center === k2.center) return [];
+    if (k1.through !== k2.through) return [];
+    const mm = MEET.exec(p);
+    if (!mm) return [];
+    const d = mm[1];
+    if (d === k1.center || d === k2.center || d === k1.through) return [];
+    const clauseIds = ctx.clauses.filter((c) => /làm\s+tâm/u.test(c.text) || /cắt\s+nhau/u.test(c.text)).map((c) => c.id);
+    const intents = [
+      drawCircle(k1.center, "centerThrough", { center: k1.center, through: k1.through }),
+      drawCircle(k2.center, "centerThrough", { center: k2.center, through: k2.through }),
+      addPoint(d, { kind: "circleIntersection", c1: k1.center, c2: k2.center, which: 1 })
+    ];
+    return [
+      {
+        ruleId: "two-circles-center-radius-meet",
+        clauseIds,
+        intents
+      }
+    ];
+  }
+};
+
+// src/stamps/geometry-2d/ai/rules/rightAngleVertexCircles.ts
+var PREFILTER67 = /góc\s+vuông\s+[a-z][A-Z][a-z]/u;
+var RIGHT_ANGLE = /góc\s+vuông\s+([a-z])([A-Z])([a-z])(?![\p{L}])/u;
+var TWO_ON_RAYS = new RegExp(
+  "L\u1EA5y\\s+(?:c\xE1c\\s+|hai\\s+)?\u0111i\u1EC3m\\s+([A-Z])\\s+v\xE0\\s+([A-Z])(?![A-Z])\\s+(?:l\u1EA7n\\s*l\u01B0\u1EE3t\\s+)?tr\xEAn\\s+(?:c\xE1c\\s+|hai\\s+)?tia\\s+[A-Z][a-z]\\s+v\xE0\\s+[A-Z][a-z]",
+  "u"
+);
+var CIRCLE_CUTS_RAY = new RegExp(
+  "[Vv]\u1EBD\\s+[\u0110\u0111]\u01B0[\u1EDD\u01A1]ng\\s*tr\xF2n\\s*\\(\\s*([A-Z])\\s*[;,]\\s*([A-Z])([A-Z])\\s*\\)\\s*c\u1EAFt\\s+tia\\s+([A-Z])([a-z])\\s+(?:t\u1EA1i|\u1EDF)\\s+(?:\u0111i\u1EC3m\\s+)?([A-Z])(?![A-Z])",
+  "gu"
+);
+var rightAngleVertexCirclesRule = {
+  id: "right-angle-vertex-circles",
+  priority: 76,
+  // dựng bộ khung góc + điểm sớm (trên twoCirclesMeet/tangent 74).
+  languages: ["vi"],
+  patterns: [PREFILTER67],
+  match(ctx) {
+    const ra = RIGHT_ANGLE.exec(ctx.problem);
+    if (!ra) return [];
+    const o = ra[2];
+    const xRay = ra[1];
+    const yRay = ra[3];
+    let pI = "";
+    let pK = "";
+    for (const c of ctx.clauses) {
+      const t = TWO_ON_RAYS.exec(c.text);
+      if (t) {
+        pI = t[1];
+        pK = t[2];
+        break;
+      }
+    }
+    if (!pI || !pK || pI === pK || pI === o || pK === o) return [];
+    const xEnd = xRay.toUpperCase() === o ? `${o}x` : xRay.toUpperCase();
+    const yEnd = yRay.toUpperCase() === o ? `${o}y` : yRay.toUpperCase();
+    const used = /* @__PURE__ */ new Set([o, pI, pK]);
+    const ax = used.has(xEnd) ? "X9" : xEnd;
+    const ay = used.has(yEnd) ? "Y9" : yEnd;
+    const intents = [
+      addPoint(o, { kind: "free", at: [0, 0] }),
+      addPoint(ax, { kind: "free", at: [8, 0] }),
+      addPoint(ay, { kind: "free", at: [0, 8] }),
+      addPoint(pI, { kind: "onSegment", of: `${o}${ax}`, t: 0.35 }),
+      addPoint(pK, { kind: "onSegment", of: `${o}${ay}`, t: 0.35 }),
+      connect(o, ax, "segment"),
+      connect(o, ay, "segment")
+    ];
+    for (const c of ctx.clauses) {
+      CIRCLE_CUTS_RAY.lastIndex = 0;
+      for (const m of c.text.matchAll(CIRCLE_CUTS_RAY)) {
+        const center = m[1];
+        const rayVertex = m[4];
+        const rayDir = m[5];
+        const hit = m[6];
+        if (![pI, pK, o].includes(center)) continue;
+        if (hit === center || hit === o) continue;
+        const rayAxisEnd = rayDir.toUpperCase() === xRay.toUpperCase() ? ax : rayDir.toUpperCase() === yRay.toUpperCase() ? ay : "";
+        if (!rayAxisEnd || rayVertex !== o) continue;
+        const otherCenter = center === pI ? pK : pI;
+        const circ = `${center}_c`;
+        intents.push(drawCircle(circ, "centerThrough", { center, through: otherCenter }));
+        intents.push(
+          addPoint(hit, { kind: "secondIntersection", line: `${o}${rayAxisEnd}`, circle: circ, other: o })
+        );
+      }
+    }
+    return [{ ruleId: "right-angle-vertex-circles", clauseIds: ctx.clauses.map((c) => c.id), intents }];
+  }
+};
+
+// src/stamps/geometry-2d/ai/rules/namedLine.ts
+var LC = String.raw`([a-z]{1,2}[0-9]?)(?!\p{L})`;
+var REF2 = String.raw`(?:${DUONG_KW}\s*thẳng\s+|đoạn(?:\s+thẳng)?\s+|cạnh\s+|tia\s+)?([A-Z]\s*[A-Z])(?![A-Z])`;
+var PT3 = String.raw`([A-Z])(?![A-Za-z])`;
+var VERB = String.raw`(?:[Cc]ho|[Vv]ẽ|[Kk]ẻ|[Dd]ựng)\s+(?:một\s+)?${DUONG_KW}\s*thẳng\s+`;
+var DECL = String.raw`(?:(?:và|[Cc]ho|[Vv]ẽ|[Kk]ẻ|[Dd]ựng)\s+)?(?:một\s+)?${DUONG_KW}\s*thẳng\s+`;
+var PERP = new RegExp(
+  DECL + LC + String.raw`\s*(?:⊥\s*|vuông\s*góc(?:\s+với)?\s+)(?:với\s+)?` + REF2 + String.raw`(?:\s*,?\s*cắt\s+[A-Z]{2})?\s+(?:tại|ở)\s+(?:điểm\s+)?` + PT3,
+  "gu"
+);
+var PARA_AFTER = new RegExp(
+  VERB + LC + String.raw`\s*(?://\s*|song\s*song(?:\s+với)?\s+)(?:với\s+)?` + REF2 + String.raw`\s+(?:đi\s+)?qua\s+(?:điểm\s+)?` + PT3,
+  "gu"
+);
+var PARA_BEFORE = new RegExp(
+  String.raw`(?:[Qq]ua|[Tt]ừ)\s+(?:điểm\s+)?` + PT3 + String.raw`[^.]{0,12}?` + VERB + LC + String.raw`\s*(?://\s*|song\s*song(?:\s+với)?\s+)(?:với\s+)?` + REF2,
+  "gu"
+);
+var THRU_TWO = new RegExp(
+  VERB + LC + String.raw`\s+(?:đi\s+)?qua\s+(?:hai\s+điểm\s+)?` + PT3 + String.raw`\s+và\s+(?:điểm\s+)?` + PT3,
+  "gu"
+);
+var SECANT_LINE = new RegExp(
+  DECL + LC + String.raw`[^.]{0,40}?cắt[^.]{0,30}?(?:tại|ở)\s+(?:2\s+|hai\s+)?(?:điểm\s+)?` + PT3 + String.raw`\s+và\s+(?:điểm\s+)?` + PT3,
+  "gu"
+);
+var FREE_DECL = new RegExp(
+  String.raw`(?:[Cc]ho|[Vv]ẽ|[Kk]ẻ|[Dd]ựng)\s+(?:một\s+)?${DUONG_KW}\s*thẳng\s+` + LC + // KHÔNG theo sau bởi ràng buộc: ⊥/vuông góc, //|song song, (đi)?qua, cắt,
+  // tiếp xúc. Cho phép ranh giới câu / "và" / "," / "(".
+  String.raw`(?!\s*(?:⊥|//|vuông\s*góc|song\s*song|(?:đi\s+)?qua|cắt|tiếp\s*xúc|tại|ở)\b)`,
+  "gu"
+);
+function lineReferenced(problem, name) {
+  const esc = escapeRe(name);
+  const N = String.raw`(?<![\p{L}\d])${esc}(?![\p{L}\d])`;
+  const REFS = [
+    // trước "d": "⊥ d", "song song d", "thuộc/trên/nằm trên d", "cắt … d", "của d"
+    new RegExp(String.raw`(?:⊥|vuông\s*góc(?:\s+với)?|//|song\s*song(?:\s+với)?|thuộc|trên|cắt|tiếp\s*tuyến\s+(?:của|với)?)\s+(?:${N})`, "u"),
+    // sau "d": "d cắt", "d tại", "d lấy", "d, "
+    new RegExp(N + String.raw`\s+(?:cắt|tại|ở|lấy)`, "u")
+  ];
+  return REFS.some((re) => re.test(problem));
+}
+var PREFILTER68 = new RegExp(
+  String.raw`${DUONG_KW}\s*thẳng\s+[a-z]{1,2}[0-9]?(?![\p{L}])`,
+  "u"
+);
+var namedLineRule = {
+  id: "named-line",
+  // Cao (63) như tangentLineNamedAtPoint — đường <d> phải dựng TRƯỚC điểm-trên-d
+  // / intersection tham chiếu d.
+  priority: 63,
+  languages: ["vi"],
+  patterns: [PREFILTER68],
+  match(ctx) {
+    const out = [];
+    const push = (clauseId, intents) => {
+      out.push({ ruleId: "named-line", clauseIds: [clauseId], intents });
+    };
+    for (const c of ctx.clauses) {
+      const seen = /* @__PURE__ */ new Set();
+      PERP.lastIndex = 0;
+      for (const m of c.text.matchAll(PERP)) {
+        const line = m[1];
+        const to = m[2].replace(/\s+/g, "");
+        const anchor = m[3];
+        if (seen.has(line)) continue;
+        seen.add(line);
+        push(c.id, [drawLine(line, "perpThrough", { through: anchor, to })]);
+      }
+      PARA_AFTER.lastIndex = 0;
+      for (const m of c.text.matchAll(PARA_AFTER)) {
+        const line = m[1];
+        const to = m[2].replace(/\s+/g, "");
+        const anchor = m[3];
+        if (seen.has(line) || to.includes(anchor)) continue;
+        seen.add(line);
+        push(c.id, [drawLine(line, "parallelThrough", { through: anchor, to })]);
+      }
+      PARA_BEFORE.lastIndex = 0;
+      for (const m of c.text.matchAll(PARA_BEFORE)) {
+        const anchor = m[1];
+        const line = m[2];
+        const to = m[3].replace(/\s+/g, "");
+        if (seen.has(line) || to.includes(anchor)) continue;
+        seen.add(line);
+        push(c.id, [drawLine(line, "parallelThrough", { through: anchor, to })]);
+      }
+      THRU_TWO.lastIndex = 0;
+      for (const m of c.text.matchAll(THRU_TWO)) {
+        const line = m[1];
+        const a = m[2];
+        const b = m[3];
+        if (seen.has(line) || a === b) continue;
+        seen.add(line);
+        push(c.id, [drawLine(line, "lineThrough", { points: [a, b] })]);
+      }
+      SECANT_LINE.lastIndex = 0;
+      for (const m of c.text.matchAll(SECANT_LINE)) {
+        const line = m[1];
+        const a = m[2];
+        const b = m[3];
+        if (seen.has(line) || a === b) continue;
+        seen.add(line);
+        push(c.id, [drawLine(line, "lineThrough", { points: [a, b] })]);
+      }
+      FREE_DECL.lastIndex = 0;
+      for (const m of c.text.matchAll(FREE_DECL)) {
+        const line = m[1];
+        if (seen.has(line) || !lineReferenced(ctx.problem, line)) continue;
+        seen.add(line);
+        const p1 = `${line}_p1`;
+        const p2 = `${line}_p2`;
+        push(c.id, [
+          addPoint(p1, { kind: "free" }),
+          addPoint(p2, { kind: "free" }),
+          drawLine(line, "lineThrough", { points: [p1, p2] })
+        ]);
+      }
+    }
+    return out;
+  }
+};
+
+// src/stamps/geometry-2d/ai/rules/bisectorsMeet.ts
+var ANG_HEAD = "(?:\u2220\\s*|g\xF3c\\s+)([A-Z])([A-Z])([A-Z])(?![A-Z])";
+var ANG_TAIL = "(?:\u2220\\s*|g\xF3c\\s+)?([A-Z])([A-Z])([A-Z])(?![A-Z])";
+var RE30 = new RegExp(
+  "[Pp]h\xE2n\\s*gi\xE1c\\s+" + ANG_HEAD + "\\s+v\xE0\\s+" + ANG_TAIL + "\\s+(?:c\u1EAFt|giao)\\s+nhau\\s+(?:t\u1EA1i|\u1EDF)\\s+(?:\u0111i\u1EC3m\\s+)?([A-Z])(?![A-Z])",
+  "gu"
+);
+var PREFILTER69 = /[Pp]hân\s*giác[^.]{0,80}?(?:cắt|giao)\s+nhau\s+(?:tại|ở)/u;
+var bisectorsMeetRule = {
+  id: "bisectorsMeet",
+  // Trên intersection (45) để các tia phân giác (draw-line) + điểm giao gom cùng
+  // 1 match; intent-layer order-retry topo lo thứ tự build. 49 = ngang
+  // twoPerpLinesMeet (cùng họ "2 đường đặt-tên giao nhau").
+  priority: 49,
+  languages: ["vi"],
+  patterns: [PREFILTER69],
+  match(ctx) {
+    const out = [];
+    for (const c of ctx.clauses) {
+      RE30.lastIndex = 0;
+      for (const m of c.text.matchAll(RE30)) {
+        const a1 = [m[1], m[2], m[3]];
+        const a2 = [m[4], m[5], m[6]];
+        const p = m[7];
+        const n1 = `bis${a1[0]}${a1[1]}${a1[2]}`;
+        const n2 = `bis${a2[0]}${a2[1]}${a2[2]}`;
+        const intents = [
+          drawLine(n1, "angleBisector", { p1: a1[0], vertex: a1[1], p2: a1[2] }),
+          drawLine(n2, "angleBisector", { p1: a2[0], vertex: a2[1], p2: a2[2] })
+        ];
+        const angleLetters = /* @__PURE__ */ new Set([...a1, ...a2]);
+        if (n1 !== n2 && !angleLetters.has(p)) {
+          intents.push(addPoint(p, { kind: "intersection", of: [n1, n2] }));
+        }
+        out.push({ ruleId: "bisectorsMeet", clauseIds: [c.id], intents });
+      }
+    }
+    return out;
+  }
+};
+
+// src/stamps/geometry-2d/ai/rules/hexagon.ts
+var HEX = "([A-Z])([A-Z])([A-Z])([A-Z])([A-Z])([A-Z])(?![A-Z])";
+var HEXAGON_DECL = new RegExp("[Ll]\u1EE5c\\s+gi\xE1c\\s+" + HEX, "gu");
+var PREFILTER70 = /[Ll]ục\s+giác/u;
+var HEX_RADIUS = 5;
+var HEX_APOTHEM = HEX_RADIUS * Math.cos(Math.PI / 6);
+var HEX_THETAS = Array.from(
+  { length: 6 },
+  (_, i) => Math.PI / 2 - i * Math.PI / 3
+);
+function hexVertexCoord(i) {
+  const t = HEX_THETAS[i];
+  return [
+    +(HEX_RADIUS * Math.cos(t)).toFixed(4),
+    +(HEX_RADIUS * Math.sin(t)).toFixed(4)
+  ];
+}
+var CENTER4 = "(?:\\(\\s*([A-Z])\\s*\\)|t\xE2m\\s+([A-Z]))";
+var HEX_CIRCUMSCRIBES = new RegExp(
+  "^[\\s,]*ngo\u1EA1i\\s*ti\u1EBFp\\s+(?:(?:" + CIRCLE_KW + ")\\s*)?" + CENTER4,
+  "u"
+);
+var HEX_INSCRIBED_BY = new RegExp(
+  "(?:" + CIRCLE_KW + ")\\s*" + CENTER4 + "\\s*n\u1ED9i\\s*ti\u1EBFp\\s+$",
+  "u"
+);
+function detectInscribedCircle(text, start, afterEnd) {
+  const a = HEX_CIRCUMSCRIBES.exec(text.slice(afterEnd));
+  if (a) return a[1] ?? a[2] ?? "O";
+  const b = HEX_INSCRIBED_BY.exec(text.slice(0, start));
+  if (b) return b[1] ?? b[2] ?? "O";
+  return void 0;
+}
+var hexagonRule = {
+  id: "hexagon",
+  priority: 100,
+  // ngang quad (đa giác cơ sở) — gate riêng prefilter "lục giác".
   languages: ["vi"],
-  patterns: [
-    /(?:[Gg]óc|∠)[^.;\n]{0,18}90/u,
-    /(?:[Gg]óc|∠)\s*[A-Z]{3}\s*vuông/u,
-    /[A-Z]{2}\s*(?:⊥|vuông\s*góc)\s*[A-Z]{2}/u
-  ],
+  patterns: [PREFILTER70],
   match(ctx) {
-    const spec = detectSpec(ctx.problem);
-    if (!spec) return [];
-    const clauseIds = ctx.clauses.filter(
-      (c) => ANGLE_EQ_RE.test(c.text) || ANGLE_VUONG_RE.test(c.text) || PERP_RE.test(c.text) || findOnLine(c.text, spec.vertex) !== null
-    ).map((c) => c.id);
-    const out = [
-      {
-        ruleId: "rightAngleViewing",
-        clauseIds,
-        intents: [
-          addPoint(spec.vertex, {
-            kind: "rightAngleViewing",
-            a: spec.a,
-            b: spec.b,
-            onLine: spec.onLine
-          })
-        ]
+    const out = [];
+    for (const c of ctx.clauses) {
+      HEXAGON_DECL.lastIndex = 0;
+      for (const m of c.text.matchAll(HEXAGON_DECL)) {
+        const labels = [m[1], m[2], m[3], m[4], m[5], m[6]];
+        const start = m.index ?? 0;
+        const afterEnd = start + m[0].length;
+        const vertices = labels.map(
+          (lbl, i) => addPoint(lbl, { kind: "free", at: hexVertexCoord(i) })
+        );
+        const center = detectInscribedCircle(c.text, start, afterEnd);
+        const intents = [...vertices];
+        if (center !== void 0) {
+          const centerName = escapeRe(center) === center ? center : "O";
+          intents.unshift(
+            addPoint(centerName, {
+              kind: "circumcenter",
+              of: [labels[0], labels[2], labels[4]]
+            })
+          );
+          intents.push(
+            drawCircle(centerName, "centerRadius", {
+              center: centerName,
+              radius: HEX_APOTHEM
+            })
+          );
+        }
+        intents.push(markShape("polygon", labels));
+        out.push({ ruleId: "hexagon", clauseIds: [c.id], intents });
       }
-    ];
+    }
     return out;
   }
 };
 
 // src/stamps/geometry-2d/ai/rules/registry.ts
 var RULES = [
+  namedLineRule,
+  collinearPointsRule,
+  quadDiagonalsRule,
+  twoCirclesTangentRule,
+  commonTangentRule,
+  twoCirclesCenterRadiusMeetRule,
+  rightAngleVertexCirclesRule,
   circumcircleCutsLineRule,
   lineConcurrencyRule,
   parallelThroughCutsCircleRule,
   lineThroughCutsTwoLinesRule,
   rightAngleViewingRule,
   triangleRule,
+  inscribedSquareRule,
+  hexagonRule,
   quadRule,
   connectRule,
   midpointRule,
@@ -7207,6 +9063,7 @@ var RULES = [
   circleTriangleRule,
   tangentFromExtRule,
   externalPointRule,
+  externalPointAtRadiusRule,
   arcMidpointRule,
   excenterRule,
   parallelPerpRule,
@@ -7246,6 +9103,7 @@ var RULES = [
   tangentAtCutsLinesRule,
   diameterEndpointRule,
   circleThroughTwoCutsSidesRule,
+  circleCenterRadiusCutsSidesRule,
   circumcircleNamedDistribRule,
   circumcirclePairMeetRule,
   tangentCircleAtPointRule,
@@ -7274,7 +9132,8 @@ var RULES = [
   twoCirclesMeetRule,
   radiusRule,
   perpNamedLineRule,
-  parallelSidePointsRule
+  parallelSidePointsRule,
+  bisectorsMeetRule
 ];
 var ALL_RULES = [...RULES].sort(
   (a, b) => b.priority - a.priority
@@ -7289,20 +9148,329 @@ function runRules(ctx) {
 }
 
 // src/stamps/geometry-2d/ai/deterministic/normalizeText.ts
-var TRIANGLE_SYMBOL = /[Δ∆]\s*(?=[A-Z])/gu;
+var TRIANGLE_SYMBOL = /[Δ∆]\s*(?=[A-Z])/gu;
 var CIRCLE_SYNONYM = /vòng\s+tròn/giu;
+var CIRCLE_PAREN_RESTORE = /(đường\s*tròn\s+)([A-Z])(['′]?)\s*;\s*([Rr])(['′]?)(?![A-Za-z'′])/gu;
 var QUAD_SYMBOL = /[◊▱□]\s*(?=[A-Z])/gu;
+var MIDPOINT_TYPO = /trung\s*điển(?!\p{L})/gu;
 var SQRT_NOISE = /√/gu;
 var PRIME_VARIANT = /([A-Za-z0-9])[’′´]/gu;
+var DIAERESIS_O = /(?<!\p{Ll})Ö(?!\p{Ll})/gu;
+var INTERSECT_PAREN = /(\([A-Z]{3}\))\s+N\s+([A-Z]{2})(\s*=\s*\{)/gu;
 var GLUE_WORD_LABEL = /(cắt|tâm|điểm|cạnh|tia|dây|cung|qua|của|và|tại|trên|đến)([A-Z])/gu;
 var GLUE_LABEL_WORD = /([A-Z])(sao|nằm|lần|thuộc|cắt|của|đến|trên|tại|và)/gu;
+var GLUE_RAYTOKEN_WORD = /([A-Z][a-z])(tại|cắt|và|của|đến|trên|thuộc)(?![\p{L}])/gu;
+var GLUE_VOCAB = [
+  "\u0111\u01B0\u1EDDng",
+  "ngo\u1EA1i",
+  "trung",
+  "ph\xE2n",
+  "\u0111i\u1EC3m",
+  "gi\xE1c",
+  "tr\xF2n",
+  "c\u1EA1nh",
+  "k\xEDnh",
+  "n\u1ED9i",
+  "ti\u1EBFp",
+  "cung",
+  "d\xE2y",
+  "tam",
+  "t\u1EE9",
+  "g\xF3c",
+  "vu\xF4ng",
+  "c\xE2n",
+  "nh\u1ECDn",
+  "n\u1EEDa",
+  "\u0111o\u1EA1n",
+  "h\xECnh",
+  "qua",
+  "c\u1EAFt",
+  "l\u1EA1i",
+  "c\xE1c",
+  "v\xE0",
+  "t\u1EA1i",
+  "m\u1ED9t",
+  "ba",
+  "b\u1EA5t",
+  "k\xEC",
+  "k\u1EF3",
+  "c\xF3",
+  "\u0111i",
+  "v\u1EDBi",
+  "l\u1EA5y",
+  "c\u1EE7a",
+  "l\u1EA7n",
+  "l\u01B0\u1EE3t",
+  "th\u1EE9",
+  "hai",
+  "g\u1ECDi",
+  "k\u1EBB",
+  "v\u1EBD",
+  "cho",
+  "t\xE2m",
+  "b\xE1n",
+  // 'là' (hệ từ) + từ-vựng hình-chiếu/⊥ — tách glue "làtrung"/"làhình"/
+  // "chiếucủa"/"xuốngđường" (OCR HHP dày). Whitelist↔whitelist nên 'là' chỉ tách
+  // khi theo NGAY bởi một từ-khoá hình-học khác (an toàn, regression-gated).
+  "l\xE0",
+  "chi\u1EBFu",
+  "xu\u1ED1ng",
+  "l\xEAn",
+  "\u0111\u1ED1i",
+  "x\u1EE9ng",
+  "song",
+  "th\u1EB3ng"
+];
+var GLUE_VOCAB_SORTED = [...GLUE_VOCAB].sort((a, b) => b.length - a.length);
+var GLUE_ALT = GLUE_VOCAB_SORTED.join("|");
+var GLUE_VOCAB_RE = new RegExp(`(${GLUE_ALT})(?=${GLUE_ALT})`, "gu");
+var GLUE_VOCAB_LABEL = new RegExp(
+  `(gi\xE1c|tr\xF2n|ti\u1EBFp|x\xFAc|k\xEDnh|\u0111i\u1EC3m|\u0111o\u1EA1n|c\u1EA1nh|d\xE2y|cung|t\u1EA1i|qua|\u0111i|v\u1EDBi|c\xF3|t\xE2m|th\u1EB3ng|l\xEAn|xu\u1ED1ng)([A-Z])`,
+  "gu"
+);
+var CAP_GLUE = /(Cho|Đường|Gọi|Trên|Vẽ|Kẻ|Lấy|Các|Một|Trung|Tâm|Nửa|Hình)(đường|tam|tứ|nửa|hình|điểm|các|cạnh|đoạn|trung|tròn|giác|một|ba|hai|tia|dây|cung)/gu;
+var GLUE_LABEL_VOCAB = new RegExp(`([A-Z])(${GLUE_ALT})(?![\\p{L}])`, "gu");
+var GLUE_PAREN_OPEN = /(\p{Ll})\(/gu;
+var GLUE_PAREN_CLOSE = /\)(\p{L})/gu;
+function deglueMultiWord(s) {
+  let out = s.replace(CAP_GLUE, "$1 $2");
+  for (let k = 0; k < 8; k++) {
+    const next = out.replace(GLUE_VOCAB_RE, "$1 ");
+    if (next === out) break;
+    out = next;
+  }
+  out = out.replace(GLUE_VOCAB_LABEL, "$1 $2").replace(GLUE_LABEL_VOCAB, "$1 $2").replace(GLUE_PAREN_OPEN, "$1 (").replace(GLUE_PAREN_CLOSE, ") $1");
+  return out;
+}
 function normalizeProblemText(problem) {
-  return problem.replace(TRIANGLE_SYMBOL, "tam gi\xE1c ").replace(QUAD_SYMBOL, "t\u1EE9 gi\xE1c ").replace(CIRCLE_SYNONYM, "\u0111\u01B0\u1EDDng tr\xF2n").replace(SQRT_NOISE, " ").replace(PRIME_VARIANT, "$1'").replace(GLUE_WORD_LABEL, "$1 $2").replace(GLUE_LABEL_WORD, "$1 $2");
+  let s = problem.replace(TRIANGLE_SYMBOL, "tam gi\xE1c ").replace(QUAD_SYMBOL, "t\u1EE9 gi\xE1c ").replace(MIDPOINT_TYPO, "trung \u0111i\u1EC3m").replace(DIAERESIS_O, "O").replace(INTERSECT_PAREN, "$1 \u2229 $2$3").replace(CIRCLE_SYNONYM, "\u0111\u01B0\u1EDDng tr\xF2n");
+  if (!/\(\s*[A-Z]/u.test(s)) s = s.replace(CIRCLE_PAREN_RESTORE, "$1($2$3;$4$5)");
+  return deglueMultiWord(
+    s.replace(SQRT_NOISE, " ").replace(PRIME_VARIANT, "$1'").replace(GLUE_WORD_LABEL, "$1 $2").replace(GLUE_LABEL_WORD, "$1 $2").replace(GLUE_RAYTOKEN_WORD, "$1 $2")
+  );
+}
+
+// src/stamps/geometry-2d/ai/deterministic/correctUserInput.ts
+function foldVietnamese(s) {
+  return s.toLowerCase().replace(/đ/g, "d").normalize("NFD").replace(/[̀-ͯ]/g, "");
+}
+function levenshtein(a, b) {
+  const m = a.length;
+  const n = b.length;
+  if (m === 0) return n;
+  if (n === 0) return m;
+  let prev = new Array(n + 1);
+  for (let j = 0; j <= n; j++) prev[j] = j;
+  for (let i = 1; i <= m; i++) {
+    const cur = new Array(n + 1);
+    cur[0] = i;
+    for (let j = 1; j <= n; j++) {
+      const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+      cur[j] = Math.min(prev[j] + 1, cur[j - 1] + 1, prev[j - 1] + cost);
+    }
+    prev = cur;
+  }
+  return prev[n];
+}
+var CORRECTION_VOCAB = [
+  // circle / line core
+  "\u0111\u01B0\u1EDDng",
+  "tr\xF2n",
+  "b\xE1n",
+  "k\xEDnh",
+  "v\xF2ng",
+  // polygon / triangle (TAM before TÂM, THANG before THẲNG — see collision-winner warning above)
+  "tam",
+  "t\xE2m",
+  "thang",
+  "th\u1EB3ng",
+  "gi\xE1c",
+  "t\u1EE9",
+  "g\xF3c",
+  "c\u1EA1nh",
+  "\u0111o\u1EA1n",
+  "h\xECnh",
+  "ch\u1EEF",
+  "nh\u1EADt",
+  "vu\xF4ng",
+  "c\xE2n",
+  "nh\u1ECDn",
+  "\u0111\u1EC1u",
+  "thoi",
+  "b\xECnh",
+  "h\xE0nh",
+  // chord / arc / point
+  "d\xE2y",
+  "cung",
+  "\u0111i\u1EC3m",
+  "tia",
+  "n\u1EEDa",
+  // tangent / inscribed
+  "ti\u1EBFp",
+  "tuy\u1EBFn",
+  "n\u1ED9i",
+  "ngo\u1EA1i",
+  "x\xFAc",
+  // cevians / projection
+  "trung",
+  "tr\u1EF1c",
+  "cao",
+  "ph\xE2n",
+  "chi\u1EBFu",
+  "\u0111\u1ED1i",
+  "x\u1EE9ng",
+  // verbs / connectors phổ biến trong đề
+  "cho",
+  "g\u1ECDi",
+  "v\u1EBD",
+  "k\u1EBB",
+  "l\u1EA5y",
+  "qua",
+  "c\u1EAFt",
+  "tr\xEAn",
+  "d\u01B0\u1EDBi",
+  "\u0111\u1EBFn",
+  // 'đi' ĐÃ GỠ: "di"→"đi" net-harmful trên corpus (regress 7 bài locus "di động"
+  // → "đi động"). Từ TRẦN 2 ký tự đa-nghĩa: rủi ro cao, lợi ích thấp.
+  "song",
+  "v\u1EDBi",
+  "c\u1EE7a",
+  "v\xE0",
+  "l\xE0",
+  "c\xF3",
+  "n\u1EB1m",
+  "thu\u1ED9c",
+  "t\u1EA1i",
+  "m\u1ED9t",
+  "hai",
+  "ba",
+  "c\xE1c",
+  "l\u1EA7n",
+  "l\u01B0\u1EE3t",
+  "th\u1EE9",
+  "b\u1EA5t",
+  "k\xEC",
+  "k\u1EF3",
+  "trong",
+  "ngo\xE0i",
+  "l\xEAn",
+  "xu\u1ED1ng"
+];
+var FOLDED_VOCAB = (() => {
+  const m = /* @__PURE__ */ new Map();
+  for (const w of CORRECTION_VOCAB) {
+    const f = foldVietnamese(w);
+    if (!m.has(f)) m.set(f, w);
+  }
+  return m;
+})();
+var LETTERS_ONLY = /^\p{L}+$/u;
+var UPPER_LABEL = /^\p{Lu}{1,4}$/u;
+var HAS_UPPER = /\p{Lu}/u;
+function classifyToken(token) {
+  if (!LETTERS_ONLY.test(token)) return "protected";
+  if (UPPER_LABEL.test(token)) return "protected";
+  return HAS_UPPER.test(token) ? "upper" : "lower";
+}
+var DEFAULT_CORRECT_CONFIG = {
+  structure: true,
+  accents: true,
+  // Tầng 3 (fuzzy typo) MẶC ĐỊNH TẮT: trên corpus thật nó băm từ TRẦN hợp lệ
+  // ("nhau"→"nhật", "giao"→"giác", "di"→"đi") vì vocab hình-học trùng không-gian
+  // âm với văn xuôi Việt → net-harmful (đo qua diag-all). Vẫn cài đặt đầy đủ + bật
+  // được qua flag (mutation test / opt-in tương lai). accents+structure đủ an toàn.
+  typo: false,
+  maxTypoDistance: 1,
+  minTypoLen: 4
+};
+var SYMBOL_MAP = [
+  // "độ" có dấu = độ-góc rõ ràng → luôn đổi. "do" trần mơ hồ (do đó/do dai/lý do)
+  // → CHỈ đổi khi KHÔNG theo sau bởi một từ-chữ (cuối cụm / trước dấu câu), tránh
+  // băm "2 do dai"→"2° dai". "90 do"/"90 do." vẫn đổi.
+  [/(\d+)\s*độ(?!\p{L})/giu, "$1\xB0"],
+  [/(\d+)\s*do(?!\s*\p{L})/giu, "$1\xB0"]
+];
+function applyStructure(s) {
+  let out = s;
+  for (const [re, to] of SYMBOL_MAP) out = out.replace(re, to);
+  return out.replace(/\s+/g, " ").trim();
+}
+function applyLeadingCase(canonical, original) {
+  if (/^\p{Lu}/u.test(original)) {
+    return canonical.charAt(0).toUpperCase() + canonical.slice(1);
+  }
+  return canonical;
+}
+function fuzzyLookup(folded, cfg) {
+  if (folded.length < cfg.minTypoLen) return null;
+  let best = null;
+  let bestDist = cfg.maxTypoDistance + 1;
+  let tie = false;
+  for (const [key, canonical] of FOLDED_VOCAB) {
+    if (canonical === key) continue;
+    if (Math.abs(key.length - folded.length) > cfg.maxTypoDistance) continue;
+    const d = levenshtein(folded, key);
+    if (d < bestDist) {
+      bestDist = d;
+      best = canonical;
+      tie = false;
+    } else if (d === bestDist) {
+      tie = true;
+    }
+  }
+  if (best === null || bestDist > cfg.maxTypoDistance || tie) return null;
+  return best;
+}
+function letterFold(token) {
+  return foldVietnamese(token).replace(/[^a-z]+/g, "");
+}
+var DISAMBIG = {
+  // "tam giác" giữ "tam"; còn lại (tâm O, tâm đường tròn…) → "tâm".
+  tam: (_p, n) => n === "giac" ? "tam" : "t\xE2m",
+  // "hình thang" giữ "thang"; còn lại (đường thẳng, thẳng hàng…) → "thẳng".
+  thang: (p, _n) => p === "hinh" ? "thang" : "th\u1EB3ng",
+  // "ngoại tiếp" → "ngoại"; còn lại (nằm ngoài, điểm ngoài…) → "ngoài".
+  ngoai: (_p, n) => n === "tiep" ? "ngo\u1EA1i" : "ngo\xE0i"
+};
+function correctToken(token, cfg, prevFold = "", nextFold = "") {
+  const klass = classifyToken(token);
+  if (klass === "protected") return token;
+  const folded = foldVietnamese(token);
+  if (folded !== token.toLowerCase()) return token;
+  if (cfg.accents) {
+    const dis = DISAMBIG[folded];
+    if (dis) return applyLeadingCase(dis(prevFold, nextFold), token);
+    const exact = FOLDED_VOCAB.get(folded);
+    if (exact) return applyLeadingCase(exact, token);
+  }
+  if (cfg.typo && klass === "lower") {
+    const near = fuzzyLookup(folded, cfg);
+    if (near) return near;
+  }
+  return token;
+}
+function correctUserInput(input, cfg = DEFAULT_CORRECT_CONFIG) {
+  let s = input;
+  if (cfg.structure) s = applyStructure(s);
+  if (!cfg.accents && !cfg.typo) return s;
+  const parts = s.split(/(\s+)/);
+  const wordIdx = [];
+  for (let i = 0; i < parts.length; i++) {
+    if (parts[i] !== "" && !/\s/.test(parts[i])) wordIdx.push(i);
+  }
+  const out = parts.slice();
+  for (let w = 0; w < wordIdx.length; w++) {
+    const i = wordIdx[w];
+    const prevFold = w > 0 ? letterFold(parts[wordIdx[w - 1]]) : "";
+    const nextFold = w < wordIdx.length - 1 ? letterFold(parts[wordIdx[w + 1]]) : "";
+    out[i] = correctToken(parts[i], cfg, prevFold, nextFold);
+  }
+  return out.join("");
 }
 
 // src/stamps/geometry-2d/ai/deterministic/runDeterministicIntents.ts
 function collectDeterministic(rawProblem) {
-  const problem = normalizeProblemText(rawProblem);
+  const problem = normalizeProblemText(correctUserInput(rawProblem));
   const clauses = segmentClauses(problem);
   const drawableClauses = clauses.filter((c) => c.hasGeometry);
   let drawableProblem = problem;
@@ -7351,7 +9519,7 @@ var SHAPE_TRI = /tam giác\s+([A-Z]{3})(?![A-Z])/gu;
 var SHAPE_QUAD = /(?:tứ giác|hình\s+(?:vuông|chữ nhật|bình hành|thoi|thang))\s+([A-Z]{4})(?![A-Z])/gu;
 function collectExpectedNames(problem) {
   const names = /* @__PURE__ */ new Set();
-  const add = (re, groups) => {
+  const add2 = (re, groups) => {
     re.lastIndex = 0;
     let m;
     while ((m = re.exec(problem)) !== null) {
@@ -7361,9 +9529,9 @@ function collectExpectedNames(problem) {
       }
     }
   };
-  add(NAMED_INTRO, [[1, 2]]);
-  add(NAMED_LA, [[1, 2]]);
-  add(NAMED_LANLUOT, [[1, 2], [3, 4]]);
+  add2(NAMED_INTRO, [[1, 2]]);
+  add2(NAMED_LA, [[1, 2]]);
+  add2(NAMED_LANLUOT, [[1, 2], [3, 4]]);
   for (const re of [SHAPE_TRI, SHAPE_QUAD]) {
     re.lastIndex = 0;
     let m;
@@ -7614,6 +9782,12 @@ function rewriteCircleRefs(intent, rename) {
       if (newC1 !== c.c1 || newC2 !== c.c2) {
         return { ...intent, constraint: { ...c, c1: newC1, c2: newC2 } };
       }
+    } else if (c.kind === "commonTangentPoint") {
+      const n0 = rename.get(c.circles[0]) ?? c.circles[0];
+      const n1 = rename.get(c.circles[1]) ?? c.circles[1];
+      if (n0 !== c.circles[0] || n1 !== c.circles[1]) {
+        return { ...intent, constraint: { ...c, circles: [n0, n1] } };
+      }
     } else if (c.kind === "intersection") {
       const newOf = c.of.map((r) => rename.get(r) ?? r);
       if (newOf[0] !== c.of[0] || newOf[1] !== c.of[1]) {
@@ -7681,14 +9855,14 @@ function repairCircleIntersections(points, shapes) {
     const targetD = (lower + upper) / 2;
     let dx = mover.x - anchor[0];
     let dy = mover.y - anchor[1];
-    const len = Math.hypot(dx, dy);
-    if (len < 1e-9) {
+    const len2 = Math.hypot(dx, dy);
+    if (len2 < 1e-9) {
       dx = 1;
       dy = 0;
     }
-    const norm2 = Math.hypot(dx, dy) || 1;
-    mover.x = anchor[0] + targetD * dx / norm2;
-    mover.y = anchor[1] + targetD * dy / norm2;
+    const norm5 = Math.hypot(dx, dy) || 1;
+    mover.x = anchor[0] + targetD * dx / norm5;
+    mover.y = anchor[1] + targetD * dy / norm5;
   }
 }
 var NameZ = zod.z.string().regex(/^[A-Za-z][A-Za-z0-9_'₀-₉]{0,11}$/);
@@ -7785,6 +9959,7 @@ var onPerpBisectorModule = defineModule({
     t: zod.z.number().optional()
   }),
   collectRefs: (e) => [e.p1, e.p2],
+  refSpecs: [{ field: "p1", role: "point" }, { field: "p2", role: "point" }],
   emit: (e, ctx) => [{
     role: "primary",
     object: emitPointObject(ctx.resolveId(e.name), e.name, {
@@ -8428,6 +10603,7 @@ var circleDiameterModule = defineModule({
     visible: zod.z.boolean().optional()
   }),
   collectRefs: (e) => [e.p1, e.p2],
+  refSpecs: [{ field: "p1", role: "point" }, { field: "p2", role: "point" }],
   emit: (e, ctx) => [{
     role: "primary",
     object: {
@@ -8774,6 +10950,7 @@ var mixtilinearPointModule = defineModule({
     which: zod.z.union([zod.z.literal("center"), zod.z.literal("touch")])
   }),
   collectRefs: (e) => [...e.vertices],
+  refSpecs: [{ field: "vertices", role: "point", many: true }],
   emit: (e, ctx) => [{
     role: "primary",
     object: emitPointObject(ctx.resolveId(e.name), e.name, {
@@ -8888,6 +11065,32 @@ var pointAtDistanceModule = defineModule({
     }];
   }
 });
+var commonTangentPointModule = defineModule({
+  kind: "commonTangentPoint",
+  role: "point",
+  category: "points",
+  prefix: "p",
+  schema: zod.z.object({
+    name: NameZ,
+    kind: zod.z.literal("commonTangentPoint"),
+    circles: zod.z.tuple([NameZ, NameZ]),
+    on: zod.z.union([zod.z.literal(0), zod.z.literal(1)]),
+    variant: zod.z.enum(["external", "internal"]),
+    side: zod.z.union([zod.z.literal(0), zod.z.literal(1)])
+  }),
+  collectRefs: (e) => [e.circles[0], e.circles[1]],
+  refSpecs: [{ field: "circles", role: "circle", many: true }],
+  emit: (e, ctx) => [{
+    role: "primary",
+    object: emitPointObject(ctx.resolveId(e.name), e.name, {
+      kind: "commonTangentPoint",
+      circles: [ctx.resolveId(e.circles[0]), ctx.resolveId(e.circles[1])],
+      on: e.on,
+      variant: e.variant,
+      side: e.side
+    })
+  }]
+});
 
 // src/stamps/geometry-2d/dsl/registry.ts
 var ALL_MODULES = [
@@ -8934,7 +11137,9 @@ var ALL_MODULES = [
   reflectPointModule,
   reflectLineModule,
   // Cụm B points
-  pointAtDistanceModule
+  pointAtDistanceModule,
+  // 2-circle relations (spec mục A)
+  commonTangentPointModule
 ];
 var KIND_REGISTRY = new Map(ALL_MODULES.map((m) => [m.kind, m]));
 var POINT_KINDS = new Set(
@@ -9137,156 +11342,6 @@ var IntentBuilderError = class extends Error {
   }
 };
 
-// src/stamps/geometry-2d/ai/intent-builders/shared.ts
-var SQRT3 = 1.7320508075688772;
-function triangleCanonical(variant) {
-  switch (variant) {
-    case "equilateral":
-      return [[0, 0], [4, 0], [2, 2 * SQRT3]];
-    case "isoceles-AB":
-      return [[0, 0], [4, 0], [2, 3]];
-    case "isoceles-BC":
-      return [[0, 3], [-2, 0], [2, 0]];
-    case "isoceles-CA":
-      return [[0, 0], [2, 3], [4, 0]];
-    case "right-at-A":
-      return [[0, 0], [4, 0], [0, 3]];
-    case "right-at-B":
-      return [[0, 0], [4, 0], [4, 3]];
-    case "right-at-C":
-      return [[0, 0], [6, 0], [3, 3]];
-    case "any":
-    default:
-      return [[0, 0], [5, 0], [2, 3]];
-  }
-}
-function squareCanonical() {
-  return [[0, 0], [4, 0], [4, 4], [0, 4]];
-}
-function rectangleCanonical(variant) {
-  if (variant === "tall") return [[0, 0], [2.5, 0], [2.5, 4], [0, 4]];
-  return [[0, 0], [4, 0], [4, 2.5], [0, 2.5]];
-}
-function rhombusCanonical() {
-  return [[-2, 0], [0, -1.5], [2, 0], [0, 1.5]];
-}
-function trapezoidCanonical(variant) {
-  switch (variant) {
-    case "right":
-      return [[0, 0], [5, 0], [3, 3], [0, 3]];
-    case "isoceles":
-      return [[0, 0], [5, 0], [4, 3], [1, 3]];
-    case "general":
-    default:
-      return [[0, 0], [5, 0], [3.5, 3], [1, 3]];
-  }
-}
-function parallelogramCanonical() {
-  return [[0, 0], [4, 0], [5, 3], [1, 3]];
-}
-function quadrilateralCanonical() {
-  return [[0, 0], [5, 0], [4.5, 3.5], [0.5, 3]];
-}
-function addPoint2(s, p) {
-  if (s.pointNames.has(p.name)) {
-    if (p.kind !== "free") {
-      const idx = s.points.findIndex((q) => q.name === p.name);
-      if (idx >= 0 && s.points[idx].kind === "free") s.points[idx] = p;
-    }
-    return;
-  }
-  s.points.push(p);
-  s.pointNames.add(p.name);
-}
-var FREE_DEFAULT_SPREAD = [
-  [3, 3],
-  [-3, 3],
-  [3, -3],
-  [-3, -3],
-  [4, 0],
-  [-4, 0],
-  [0, 4],
-  [0, -4]
-];
-function defaultFreeCoord(s) {
-  let count = 0;
-  for (const p of s.points) if (p.kind === "free") count++;
-  return [...FREE_DEFAULT_SPREAD[count % FREE_DEFAULT_SPREAD.length]];
-}
-function addShape(s, sh) {
-  if (s.shapeNames.has(sh.name)) return;
-  s.shapes.push(sh);
-  s.shapeNames.add(sh.name);
-}
-function uniqueShapeName(s, base) {
-  if (!s.shapeNames.has(base)) return base;
-  let i = 2;
-  while (s.shapeNames.has(`${base}${i}`)) i++;
-  return `${base}${i}`;
-}
-function uniquePointName(s, base) {
-  if (!s.pointNames.has(base)) return base;
-  let i = 2;
-  while (s.pointNames.has(`${base}${i}`)) i++;
-  return `${base}${i}`;
-}
-function ensureSegment(s, a, b) {
-  const k1 = `${a}-${b}`;
-  const k2 = `${b}-${a}`;
-  const existing = s.segmentByEnds.get(k1) ?? s.segmentByEnds.get(k2);
-  if (existing) return existing;
-  const name = uniqueShapeName(s, `${a}${b}`);
-  addShape(s, { name, kind: "segment", p1: a, p2: b });
-  s.segmentByEnds.set(k1, name);
-  return name;
-}
-function resolveLineRefWithFallback(s, ref, anchor) {
-  if (/^[A-Za-z]$/.test(ref) && /^[A-Za-z]$/.test(anchor) && ref !== anchor && s.pointNames.has(ref) && s.pointNames.has(anchor)) {
-    const [a, b] = ref < anchor ? [ref, anchor] : [anchor, ref];
-    return ensureSegment(s, a, b);
-  }
-  return resolveSegmentRef(s, ref);
-}
-function resolveSegmentRef(s, ref) {
-  if (s.shapeNames.has(ref)) return ref;
-  if (/^[A-Z][A-Z]$/u.test(ref)) {
-    return ensureSegment(s, ref[0], ref[1]);
-  }
-  if (ref.length === 2 && s.pointNames.has(ref[0]) && s.pointNames.has(ref[1])) {
-    return ensureSegment(s, ref[0], ref[1]);
-  }
-  const dashMatch = ref.match(/^([A-Za-z][A-Za-z0-9'_]*)[-_]?([A-Za-z][A-Za-z0-9'_]*)$/);
-  if (dashMatch && s.pointNames.has(dashMatch[1]) && s.pointNames.has(dashMatch[2])) {
-    return ensureSegment(s, dashMatch[1], dashMatch[2]);
-  }
-  const sub = splitKnownPair(s, ref);
-  if (sub) return ensureSegment(s, sub[0], sub[1]);
-  return ref;
-}
-function splitKnownPair(s, ref) {
-  for (let i = ref.length - 1; i >= 1; i--) {
-    const a = ref.slice(0, i);
-    const b = ref.slice(i);
-    if (s.pointNames.has(a) && s.pointNames.has(b)) return [a, b];
-  }
-  return null;
-}
-function parseEnds(ref) {
-  if (ref.length === 2) return [ref[0], ref[1]];
-  const m = ref.match(/^([A-Za-z][A-Za-z0-9'_]*)[-_]?([A-Za-z][A-Za-z0-9'_]*)$/);
-  if (m) return [m[1], m[2]];
-  return null;
-}
-var SHAPE_VARIANTS = {
-  triangle: ["any", "equilateral", "isoceles-AB", "isoceles-BC", "isoceles-CA", "right-at-A", "right-at-B", "right-at-C"],
-  square: ["standard"],
-  rectangle: ["standard", "wide", "tall"],
-  rhombus: ["standard"],
-  trapezoid: ["right", "isoceles", "general"],
-  parallelogram: ["standard"],
-  quadrilateral: ["any"]
-};
-
 // src/stamps/geometry-2d/ai/intent-builders/draw-shape.ts
 var buildDrawShape = (s, intent) => {
   const labels = intent.labels;
@@ -9559,6 +11614,25 @@ var buildPointAtDistance = (s, intent) => {
   addPoint2(s, { name: intent.name, kind: "pointAtDistance", from: c.from, through: c.through, distance: c.distance });
 };
 
+// src/stamps/geometry-2d/ai/intent-builders/add-point/commonTangentPoint.ts
+var buildCommonTangentPoint = (s, intent) => {
+  const c = intent.constraint;
+  if (c.kind !== "commonTangentPoint") return;
+  const isCircle = (name) => {
+    const sh = s.shapes.find((x) => x.name === name);
+    return !!sh && CIRCLE_KINDS.has(sh.kind);
+  };
+  if (!isCircle(c.circles[0]) || !isCircle(c.circles[1])) return;
+  addPoint2(s, {
+    name: intent.name,
+    kind: "commonTangentPoint",
+    circles: [c.circles[0], c.circles[1]],
+    on: c.on,
+    variant: c.variant,
+    side: c.side
+  });
+};
+
 // src/stamps/geometry-2d/ai/intent-builders/add-point/externalToCircle.ts
 var buildExternalToCircle = (s, intent) => {
   const c = intent.constraint;
@@ -9628,6 +11702,7 @@ var ADD_POINT_BUILDERS = {
   reflectPoint: buildReflectPoint,
   reflectLine: buildReflectLine,
   pointAtDistance: buildPointAtDistance,
+  commonTangentPoint: buildCommonTangentPoint,
   externalToCircle: buildExternalToCircle,
   onCircle: buildOnCircle,
   mixtilinearPoint: buildMixtilinearPoint
@@ -10283,6 +12358,8 @@ function constraintKey(c) {
       return `externalToCircle:${c.circle}`;
     case "onCircle":
       return `onCircle:${c.circle}:${c.theta ?? ""}`;
+    case "commonTangentPoint":
+      return `commonTangentPoint:${c.circles.join(",")}:${c.on}:${c.variant}:${c.side}`;
   }
 }
 function samePrefix(a, b, depth) {
@@ -10310,11 +12387,11 @@ function verifyGeometry(intents, dsl) {
     const other2 = apex === "A" ? pC : apex === "B" ? pC : pB;
     const v1 = [other1[0] - apexP[0], other1[1] - apexP[1]];
     const v2 = [other2[0] - apexP[0], other2[1] - apexP[1]];
-    const dot = v1[0] * v2[0] + v1[1] * v2[1];
-    if (Math.abs(dot) > 1e-6) {
+    const dot2 = v1[0] * v2[0] + v1[1] * v2[1];
+    if (Math.abs(dot2) > 1e-6) {
       issues.push({
         axis: "wrong",
-        detail: `triangle ${A}${B}${C} variant=right-at-${apex} kh\xF4ng vu\xF4ng (dot=${dot.toFixed(3)})`
+        detail: `triangle ${A}${B}${C} variant=right-at-${apex} kh\xF4ng vu\xF4ng (dot=${dot2.toFixed(3)})`
       });
     }
   }
@@ -10362,7 +12439,7 @@ function buildAndTranspile(intents) {
   return second.ok ? second : first;
 }
 function tryDeterministicFigure(rawProblem) {
-  const problem = normalizeProblemText(rawProblem);
+  const problem = normalizeProblemText(correctUserInput(rawProblem));
   const det = runDeterministicIntents(problem);
   if (!det.ok) return { ok: false, reason: det.reason, coverage: det.coverage };
   const built = buildAndTranspile(
@@ -10437,7 +12514,7 @@ function describeDeterministicMiss(miss) {
 // src/stamps/geometry-2d/ai/deterministic/partialFigure.ts
 var MAX_SALVAGE_ITERS = 6;
 function tryPartialFigure(rawProblem) {
-  const problem = normalizeProblemText(rawProblem);
+  const problem = normalizeProblemText(correctUserInput(rawProblem));
   const part = tryPartialDeterministic(problem);
   if (part.detIntents.length === 0) return null;
   const intents = resolveCircleNameCollisions(normalizeIntents(part.detIntents, problem));
@@ -10821,6 +12898,16 @@ var AddPointIntentZ = zod.z.object({
         zod.z.object({ kind: zod.z.literal("segmentLength"), p1: LabelZ, p2: LabelZ, scale: zod.z.number().positive().optional(), offset: zod.z.number().optional() }),
         zod.z.object({ kind: zod.z.literal("literal"), value: zod.z.number().positive(), scale: zod.z.number().positive().optional(), offset: zod.z.number().optional() })
       ])
+    }),
+    // Tiếp điểm tiếp tuyến CHUNG 2 đường tròn (spec mục A). circles = 2 tên đtròn;
+    // on = tiếp điểm trên đtròn 0 hay 1; variant = ngoài/trong; side = chọn 1 trong
+    // 2 tiếp tuyến cùng loại.
+    zod.z.object({
+      kind: zod.z.literal("commonTangentPoint"),
+      circles: zod.z.tuple([LabelZ, LabelZ]),
+      on: zod.z.union([zod.z.literal(0), zod.z.literal(1)]),
+      variant: zod.z.enum(["external", "internal"]),
+      side: zod.z.union([zod.z.literal(0), zod.z.literal(1)])
     })
   ])
 });
@@ -10871,8 +12958,8 @@ var DrawLineIntentZ = zod.z.object({
 });
 var MarkShapeIntentZ = zod.z.object({
   op: zod.z.literal("mark-shape"),
-  shape: zod.z.enum(["triangle", "quadrilateral"]),
-  labels: zod.z.array(LabelZ).min(3).max(4)
+  shape: zod.z.enum(["triangle", "quadrilateral", "polygon"]),
+  labels: zod.z.array(LabelZ).min(3).max(8)
 });
 var IntentZ = zod.z.discriminatedUnion("op", [
   DrawShapeIntentZ,
@@ -11184,7 +13271,7 @@ ho\u1EB7c
 - quadrilateral: any
 
 ## Constraint kinds (cho add-point)
-midpoint, perpFoot, centroid, circumcenter, incenter, orthocenter, intersection, onSegment, free, secondIntersection, circleIntersection, tangencyPoint, tangentPoint, angleBisectorFoot, externalAngleBisectorFoot, arcMidpoint, reflectPoint, reflectLine, excenter, rightAngleViewing, pointAtDistance
+midpoint, perpFoot, centroid, circumcenter, incenter, orthocenter, intersection, onSegment, free, secondIntersection, circleIntersection, tangencyPoint, tangentPoint, angleBisectorFoot, externalAngleBisectorFoot, arcMidpoint, reflectPoint, reflectLine, excenter, rightAngleViewing, pointAtDistance, commonTangentPoint
 
 ## Style enum (cho connect)
 segment, line, ray, perpBisector
@@ -11328,6 +13415,131 @@ async function runTesseractOcr(image, opts = {}) {
   }
 }
 
+// src/stamps/geometry-2d/ai/vision/repairOcrSymbols.ts
+var PT4 = `[A-Z]{2,3}['\u2032]?`;
+var PERP_RE2 = new RegExp(
+  `(?<![\\p{L}\\d])(${PT4})\\s+([1|L])\\s+(${PT4})(?![\\p{L}\\d])`,
+  "gu"
+);
+var TRI_STRICT_RE = /(?<!giác )(?<!thang )(?<![\p{L}\d])A([A-Z]{3})\s+(đều|cân|nhọn|vuông)(?![\p{L}])/gu;
+var TRI_DOUBLE_RE = /(?<![\p{L}\d])AA([A-Z]{2})(?![A-Z])/gu;
+var CIRCLE_O_RE = /\(0\)/gu;
+var ELEM_RE = /(?<![\p{L}\d])([A-Z](?:\s*,\s*[A-Z])+)\s*e\s*\((?:O|0)\)/gu;
+var INTERSECT_RE = /([A-Z]{2,3})N\s+([A-Z]\S{0,2})\s*=\s*\{/gu;
+var SQUARE_RE = /([A-Z])\?(?=\s*[-=+)])/gu;
+var HORN_O_C_RE = /(?<!\p{Ll})Ơ(?!\p{Ll})/gu;
+var DUONG_DBAR_RE = /D(?:ường|uong)(?= (?:tròn|tron|thẳng|kính|cao|chéo|trung|phân|vuông|nối|gấp|tâm))/gu;
+var DUONG_TRON_RE = /([Đđ]ường\s+)tron(?![\p{L}])/gu;
+var FLORIN_F_RE = /Ƒ/gu;
+var TAI_TAI_RE = /(?<![\p{L}])tai(\s+)(?=[A-Z(]|điểm)/gu;
+var TAM_TAM_RE = /(?<![\p{L}])tam(\s+)(?=đường|\(|đối xứng)/gu;
+var EURO_ELEM_RE = /€/gu;
+var PARALLEL_RE = /\|\|/gu;
+var CENT_C_RE = /¢/gu;
+var ETH_D_RE = /(?<!\p{Ll})Ð(?!\p{Ll})/gu;
+var SLASH_O_RE = /(?<!\p{Ll})Ø(?!\p{Ll})/gu;
+var GOI_RE = /(?<!\p{L})Goi(?!\p{L})/gu;
+var LAY_RE = /(?<!\p{L})Lay(?!\p{L})/gu;
+var DIQUA_RE = /(?<!\p{L})di qua(?!\p{L})/gu;
+var VA_VAND_RE = /(?<!\p{L})va (?=[A-Z(]|dây|đường)/gu;
+var TREN_RE = /([Tt])rén(?![\p{L}])/gu;
+var DUONG_LOWER_RE = /(?<![\p{L}])dường(?= (?:tròn|tron|thẳng|kính|cao|chéo|trung|phân|vuông|nối|gấp|tâm))/gu;
+var DAY_RE = /(?<![\p{L}])day(?=\s+(?:cung(?![\p{L}])|[A-Z]{2}))/gu;
+var CHUNG_MINH_RE = /([Cc]hứng )mình(?![\p{L}])/gu;
+var THANG_HANG_RE = /thẳng hang(?![\p{L}])/gu;
+var TINH_RE = /(?<![\p{L}])Tinh(?= (?:[A-Z]|do(?![\p{L}])|độ|diện|bán|chu|số|giá))/gu;
+var DO_DAI_RE = /(?<![\p{L}])do dai(?![\p{L}])/gu;
+var NIM_RE = /(?<![\p{L}])nim(?= (?:giữa|trên|trong)(?![\p{L}]))/gu;
+var NAM_GIUA_RE = /(?<![\p{L}])năm(?= (?:giữa|trên) [A-Z])/gu;
+var ANGLE_Z_RE = /(?<![\p{L}\d])4?Z([A-Z]{2,3})(?![A-Z])/gu;
+var DE_PAREN_RE = /\(Dé /gu;
+var DE_VERB_RE = /(\(Đề )\S+( bởi)/gu;
+var DE_THI_LOWER_RE = /(?<![\p{L}])dé(?= thi)/gu;
+var DI_DONG_RE = /(?<![\p{L}])di dong(?![\p{L}])/gu;
+var POUND_E_RE = /£/gu;
+var TRI_SPACE_2_1 = /(tam\s*giác\s+)([A-Z])([A-Z])\s+([A-Z])(?![A-Z\p{Ll}])/gu;
+var TRI_SPACE_1_2 = /(tam\s*giác\s+)([A-Z])\s+([A-Z])([A-Z])(?![A-Z\p{Ll}])/gu;
+var DIAERESIS_O_RE = /(?<!\p{Ll})Ö(?!\p{Ll})/gu;
+var INTERSECT_PAREN_RE = /(\([A-Z]{3}\))\s+N\s+([A-Z]{2})(\s*=\s*\{)/gu;
+function repairOcrSymbols(text) {
+  let t = text;
+  t = t.replace(PERP_RE2, "$1 \u22A5 $3");
+  t = t.replace(TRI_STRICT_RE, "tam gi\xE1c $1 $2");
+  t = t.replace(TRI_DOUBLE_RE, "tam gi\xE1c A$1");
+  t = t.replace(CIRCLE_O_RE, "(O)");
+  t = t.replace(ELEM_RE, "$1 \u2208 (O)");
+  t = t.replace(INTERSECT_RE, "$1 \u2229 $2 = {");
+  t = t.replace(SQUARE_RE, "$1\xB2");
+  t = t.replace(HORN_O_C_RE, "C");
+  t = t.replace(DUONG_DBAR_RE, "\u0110\u01B0\u1EDDng");
+  t = t.replace(DUONG_LOWER_RE, "\u0111\u01B0\u1EDDng");
+  t = t.replace(DUONG_TRON_RE, "$1tr\xF2n");
+  t = t.replace(FLORIN_F_RE, "F");
+  t = t.replace(TAI_TAI_RE, "t\u1EA1i$1");
+  t = t.replace(TAM_TAM_RE, "t\xE2m$1");
+  t = t.replace(EURO_ELEM_RE, "\u2208");
+  t = t.replace(PARALLEL_RE, "\u2225");
+  t = t.replace(CENT_C_RE, "c");
+  t = t.replace(ETH_D_RE, "D");
+  t = t.replace(SLASH_O_RE, "O");
+  t = t.replace(GOI_RE, "G\u1ECDi");
+  t = t.replace(LAY_RE, "L\u1EA5y");
+  t = t.replace(DIQUA_RE, "\u0111i qua");
+  t = t.replace(VA_VAND_RE, "v\xE0 ");
+  t = t.replace(TREN_RE, "$1r\xEAn");
+  t = t.replace(DAY_RE, "d\xE2y");
+  t = t.replace(CHUNG_MINH_RE, "$1minh");
+  t = t.replace(THANG_HANG_RE, "th\u1EB3ng h\xE0ng");
+  t = t.replace(TINH_RE, "T\xEDnh");
+  t = t.replace(DO_DAI_RE, "\u0111\u1ED9 d\xE0i");
+  t = t.replace(NIM_RE, "n\u1EB1m");
+  t = t.replace(NAM_GIUA_RE, "n\u1EB1m");
+  t = t.replace(ANGLE_Z_RE, "\u2220$1");
+  t = t.replace(DE_PAREN_RE, "(\u0110\u1EC1 ");
+  t = t.replace(DE_VERB_RE, "$1xu\u1EA5t$2");
+  t = t.replace(DE_THI_LOWER_RE, "\u0111\u1EC1");
+  t = t.replace(DI_DONG_RE, "di \u0111\u1ED9ng");
+  t = t.replace(POUND_E_RE, "E");
+  t = t.replace(TRI_SPACE_2_1, "$1$2$3$4");
+  t = t.replace(TRI_SPACE_1_2, "$1$2$3$4");
+  t = t.replace(DIAERESIS_O_RE, "O");
+  t = t.replace(INTERSECT_PAREN_RE, "$1 \u2229 $2$3");
+  return t;
+}
+
+// src/stamps/geometry-2d/ai/vision/detectFormulaRisk.ts
+var SUP_RESIDUE = /[A-Z0-9]\?(?=\s*[-=+)(])/u;
+var ANGLE_DEG = /([\p{L}]{1,6})\s*=\s*\d+\s*°/gu;
+function hasManglingLtGt(text) {
+  const re = /[<>]/gu;
+  let m;
+  while ((m = re.exec(text)) !== null) {
+    const prev = text.slice(0, m.index).replace(/\s+$/u, "").slice(-1);
+    const next = text.slice(m.index + 1).replace(/^\s+/u, "").slice(0, 1);
+    const prevOperand = /[A-Za-z0-9]/.test(prev);
+    const nextOperand = /[A-Za-z0-9]/.test(next);
+    if (!(prevOperand && nextOperand)) return true;
+  }
+  return false;
+}
+function detectFormulaRisk(text) {
+  const reasons = [];
+  if (hasManglingLtGt(text)) {
+    reasons.push('ph\xE2n s\u1ED1/bi\u1EC3u th\u1EE9c nghi b\u1ECB nu\u1ED1t (k\xFD hi\u1EC7u "<"/">")');
+  }
+  if (SUP_RESIDUE.test(text)) {
+    reasons.push('s\u1ED1 m\u0169 ho\u1EB7c \u0111\u1ED9 nghi b\u1ECB m\u1EA5t (d\u1EA5u "?")');
+  }
+  for (const m of text.matchAll(ANGLE_DEG)) {
+    const tok = m[1];
+    if (/[A-Z]/.test(tok) && /[^\x00-\x7F]/u.test(tok)) {
+      reasons.push("t\xEAn g\xF3c nghi b\u1ECB nh\u1EADn d\u1EA1ng sai (k\xFD t\u1EF1 c\xF3 d\u1EA5u)");
+      break;
+    }
+  }
+  return reasons;
+}
+
 // src/stamps/geometry-2d/ai/vision/extractProblem.ts
 var MIN_HIGH_CONFIDENCE_CHARS = 10;
 var MAX_TEXT_CHARS = 2e3;
@@ -11358,6 +13570,7 @@ async function extractProblemFromImage(image, opts = {}) {
     ok: true,
     text,
     confidence,
+    warnings: detectFormulaRisk(text),
     usage: { inputTokens: 0, outputTokens: 0 }
   };
 }
@@ -11369,6 +13582,7 @@ function postProcess(raw) {
   t = t.replace(/```[\s\S]*?```/g, "").replace(/`([^`]+)`/g, "$1");
   t = t.replace(/\s+/g, " ").trim();
   t = t.normalize("NFC");
+  t = repairOcrSymbols(t);
   if (t.length > MAX_TEXT_CHARS) t = t.slice(0, MAX_TEXT_CHARS);
   return t;
 }
@@ -11378,6 +13592,14 @@ async function handleExtractProblem(image, opts = {}) {
   try {
     const r = await extractProblemFromImage(image, opts);
     if (r.ok) {
+      if (r.warnings.length > 0) {
+        return {
+          kind: "low-confidence",
+          text: r.text,
+          warning: `C\xF3 th\u1EC3 c\xF3 c\xF4ng th\u1EE9c/k\xFD hi\u1EC7u b\u1ECB nh\u1EADn d\u1EA1ng sai (${r.warnings.join("; ")}). Ki\u1EC3m tra k\u1EF9 tr\u01B0\u1EDBc khi v\u1EBD.`,
+          usage: r.usage
+        };
+      }
       if (r.confidence === "low") {
         return {
           kind: "low-confidence",