pythonocc-step-editor/step_editor/operations.py

from __future__ import annotations

import math
from pathlib import Path
from typing import Callable, Iterable

from OCC.Core.BRep import BRep_Tool
from OCC.Core.BRepAdaptor import BRepAdaptor_Curve, BRepAdaptor_Surface
from OCC.Core.BRepAlgoAPI import BRepAlgoAPI_Cut, BRepAlgoAPI_Defeaturing, BRepAlgoAPI_Fuse
from OCC.Core.BRepBndLib import brepbndlib
from OCC.Core.BOPAlgo import BOPAlgo_GlueFull
from OCC.Core.BRepBuilderAPI import (
    BRepBuilderAPI_MakeEdge,
    BRepBuilderAPI_GTransform,
    BRepBuilderAPI_MakeFace,
    BRepBuilderAPI_MakePolygon,
    BRepBuilderAPI_MakeWire,
    BRepBuilderAPI_MakeSolid,
    BRepBuilderAPI_Sewing,
    BRepBuilderAPI_Transform,
)
from OCC.Core.BRepCheck import BRepCheck_Analyzer
from OCC.Core.BRepClass3d import BRepClass3d_SolidClassifier
from OCC.Core.BRepFilletAPI import BRepFilletAPI_MakeChamfer, BRepFilletAPI_MakeFillet
from OCC.Core.BRepGProp import brepgprop
from OCC.Core.BRepMesh import BRepMesh_IncrementalMesh
from OCC.Core.BRepPrimAPI import BRepPrimAPI_MakeCone, BRepPrimAPI_MakeCylinder, BRepPrimAPI_MakePrism
from OCC.Core.Bnd import Bnd_Box
from OCC.Core.GeomAbs import (
    GeomAbs_BSplineCurve,
    GeomAbs_BSplineSurface,
    GeomAbs_BezierCurve,
    GeomAbs_BezierSurface,
    GeomAbs_Circle,
    GeomAbs_Cone,
    GeomAbs_Cylinder,
    GeomAbs_Ellipse,
    GeomAbs_Hyperbola,
    GeomAbs_Line,
    GeomAbs_OffsetSurface,
    GeomAbs_OtherCurve,
    GeomAbs_OtherSurface,
    GeomAbs_Parabola,
    GeomAbs_Plane,
    GeomAbs_Sphere,
    GeomAbs_SurfaceOfExtrusion,
    GeomAbs_SurfaceOfRevolution,
    GeomAbs_Torus,
)
from OCC.Core.GProp import GProp_GProps
from OCC.Core.GC import GC_MakeArcOfCircle
from OCC.Core.GeomAPI import GeomAPI_PointsToBSplineSurface
from OCC.Core.ShapeFix import ShapeFix_Shape
from OCC.Core.ShapeUpgrade import ShapeUpgrade_UnifySameDomain
from OCC.Core.TColgp import TColgp_Array2OfPnt
from OCC.Core.TopAbs import (
    TopAbs_EDGE,
    TopAbs_EXTERNAL,
    TopAbs_FACE,
    TopAbs_FORWARD,
    TopAbs_IN,
    TopAbs_INTERNAL,
    TopAbs_OUT,
    TopAbs_REVERSED,
    TopAbs_SHELL,
    TopAbs_SOLID,
    TopAbs_VERTEX,
    TopAbs_WIRE,
)
from OCC.Core.TopExp import TopExp_Explorer, topexp
from OCC.Core.TopLoc import TopLoc_Location
from OCC.Core.TopoDS import TopoDS_Compound, TopoDS_Shape, topods
from OCC.Core.TopTools import TopTools_IndexedDataMapOfShapeListOfShape, TopTools_IndexedMapOfShape
from OCC.Core.gp import gp_Ax1, gp_Ax2, gp_Dir, gp_GTrsf, gp_Pnt, gp_Trsf, gp_Vec, gp_XYZ
from OCC.Extend.TopologyUtils import TopologyExplorer, discretize_edge

from .constants import CURVE_TYPES, SNAPSHOT_FACE_LOGICAL_IDS_KEY, SURFACE_TYPES
from .geometry_utils import *  # noqa: F403
from .step_io import _prepare_shape_for_step_export


def _int_or_none(value: object) -> int | None:
    if value in {"", None}:
        return None
    try:
        return int(value)
    except (TypeError, ValueError):
        return None


def _angle_degrees_or_none(value: object) -> float | None:
    radians = _float_or_none(value)
    if radians is None:
        return None
    return abs(math.degrees(radians))


def _effective_cylinder_angular_span(info: dict[str, object]) -> float | None:
    if bool(info.get("is_full_cylinder")):
        return math.tau
    values: list[float] = []
    for key in ("same_domain_angular_span", "angular_span"):
        value = _float_or_none(info.get(key))
        if value is not None:
            values.append(value)
    return max(values) if values else None


def _is_effectively_full_cylinder(info: dict[str, object]) -> bool:
    angular_span = _effective_cylinder_angular_span(info)
    return angular_span is not None and angular_span >= math.tau * 0.92


def _result_value_error(actual: object, target: object) -> float:
    if isinstance(actual, tuple) and isinstance(target, tuple):
        if len(actual) != len(target):
            return math.inf
        return max(abs(float(actual[index]) - float(target[index])) for index in range(len(actual)))
    try:
        return abs(float(actual) - float(target))
    except (TypeError, ValueError):
        return math.inf


def _format_result_number(value: object) -> str:
    try:
        number = float(value)
    except (TypeError, ValueError):
        return str(value)
    if not math.isfinite(number):
        return str(number)
    return f"{number:g}"


class OperationMixin:
    def _face_first_level_plan_fields(self, face_id: int) -> dict[str, object]:
        boundary_info: dict[str, object] = {}
        try:
            source_info = self.quick_face_info(face_id)
            boundary_info = {
                "selected_boundary_wires": source_info.get("boundary_wires", 0),
                "selected_inner_boundary_wires": source_info.get("inner_boundary_wires", 0),
                "selected_has_inner_boundaries": bool(source_info.get("has_inner_boundaries")),
            }
        except Exception:
            boundary_info = {
                "selected_boundary_wires": 0,
                "selected_inner_boundary_wires": 0,
                "selected_has_inner_boundaries": False,
            }
        fact_fields = self._first_level_fact_plan_fields(face_id, "face")
        try:
            topology = self.face_first_level_topology(face_id)
        except Exception as exc:
            return {
                "topology_relation_depth": 1,
                "topology_relation_model": "STEP/B-Rep shared-edge first-level",
                "topology_relation_status": "unavailable",
                "topology_relation_message": str(exc),
                "first_level_adjacent_face_ids": (),
                "first_level_adjacent_face_count": 0,
                "first_level_boundary_edge_ids": (),
                "first_level_boundary_edge_count": 0,
                "first_level_boundary_vertex_count": 0,
                "same_domain_face_ids": (face_id,),
                "same_domain_face_count": 1,
                **boundary_info,
                **fact_fields,
            }
        fields = {
            "topology_relation_depth": topology.get("topology_relation_depth", 1),
            "topology_relation_model": topology.get("topology_relation_model"),
            "topology_relation_scope": topology.get("topology_relation_scope"),
            "topology_relation_boundary": topology.get("topology_relation_boundary"),
            "topology_relation_status": "ready",
            "topology_ignored_relation_depths": topology.get("topology_ignored_relation_depths", ()),
            "topology_ignored_relation_note": topology.get("topology_ignored_relation_note", ""),
            "same_domain_face_ids": topology.get("same_domain_face_ids", (face_id,)),
            "same_domain_face_count": topology.get("same_domain_face_count", 1),
            "same_domain_region_kind": topology.get("same_domain_region_kind", "single-face"),
            "selected_boundary_edge_ids": topology.get("selected_boundary_edge_ids", ()),
            "selected_boundary_edge_count": topology.get("selected_boundary_edge_count", 0),
            "first_level_boundary_edge_ids": topology.get("first_level_boundary_edge_ids", ()),
            "first_level_boundary_edge_count": topology.get("first_level_boundary_edge_count", 0),
            "first_level_boundary_vertex_count": topology.get("first_level_boundary_vertex_count", 0),
            "first_level_adjacent_face_ids": topology.get("first_level_adjacent_face_ids", ()),
            "first_level_adjacent_face_count": topology.get("first_level_adjacent_face_count", 0),
            "first_level_adjacent_surface_types": topology.get("first_level_adjacent_surface_types", ()),
            "first_level_shared_edges_by_face": topology.get("first_level_shared_edges_by_face", ()),
            "first_level_face_ids": topology.get("first_level_face_ids", ()),
            "first_level_face_count": topology.get("first_level_face_count", 0),
            "first_level_topology_note": topology.get("first_level_topology_note", ""),
            **boundary_info,
        }
        fields.update(fact_fields)
        fields["first_level_edit_semantics"] = (
            "当前 Face 阶段只使用一级共享边拓扑：当前同域 Face 区域会作为编辑对象，"
            "直接相邻 Face 会跟随重建或作为拉伸/切除侧壁参与结果校验；二级/三级关系暂不递归传播。"
        )
        return fields

    def _face_first_level_plan_blockers(
        self,
        fields: dict[str, object],
        *,
        operation_label: str,
        require_adjacent: bool = True,
    ) -> list[str]:
        blockers: list[str] = []
        topology_status = str(fields.get("topology_relation_status") or "")
        fact_status = str(fields.get("first_level_fact_status") or "")
        fact_scope = str(fields.get("first_level_fact_scope") or "")
        fact_boundary = str(fields.get("first_level_fact_relation_boundary") or "")
        try:
            fact_depth = int(fields.get("first_level_fact_relation_depth", 0) or 0)
        except (TypeError, ValueError):
            fact_depth = 0

        if topology_status != "ready":
            message = str(fields.get("topology_relation_message") or "").strip()
            blockers.append(
                f"{operation_label}需要先确认当前 Face 的一级共享边拓扑；当前拓扑关系不可用。"
                + (f" 原因：{message}" if message else "")
            )
        if fact_status != "ready" or fact_scope != "face" or fact_depth != 1 or fact_boundary != "shared-edge":
            blockers.append(
                f"{operation_label}需要当前 Face 的一级事实图处于 ready 状态；"
                f"当前 status={fact_status or 'unknown'}, scope={fact_scope or 'unknown'}, "
                f"depth={fact_depth}, boundary={fact_boundary or 'unknown'}。"
            )

        boundary_edges = int(fields.get("first_level_fact_boundary_edge_count", 0) or 0)
        boundary_vertices = int(fields.get("first_level_fact_boundary_vertex_count", 0) or 0)
        adjacent_faces = int(fields.get("first_level_fact_adjacent_face_count", 0) or 0)
        subject_faces = int(fields.get("first_level_fact_subject_face_count", 0) or 0)
        included_faces = int(fields.get("first_level_fact_included_face_count", 0) or 0)
        if subject_faces <= 0 or included_faces < subject_faces:
            blockers.append(
                f"{operation_label}没有拿到稳定的当前 Face 主体区域，不能判断哪些面要作为同一局部面处理。"
            )
        if boundary_edges < 3 or boundary_vertices < 3:
            blockers.append(
                f"{operation_label}需要至少 3 条边界 Edge 和 3 个边界 Vertex；"
                f"当前 Edge={boundary_edges}, Vertex={boundary_vertices}。"
            )
        if require_adjacent and adjacent_faces <= 0:
            blockers.append(f"{operation_label}没有识别到共享边的一级相邻 Face，不能稳定重建周边面。")

        ignored_depths = tuple(str(item) for item in fields.get("first_level_fact_ignored_relation_depths", ()) or ())
        if "second-level" not in ignored_depths or "third-level" not in ignored_depths:
            blockers.append(f"{operation_label}没有明确记录二级/三级关系暂不传播，当前计划不够明确。")

        role_groups = tuple(fields.get("first_level_fact_role_groups") or ())
        if not any(isinstance(item, dict) and item.get("role") == "selected-same-domain-region" for item in role_groups):
            blockers.append(f"{operation_label}缺少当前同域 Face 区域角色，不能确定局部编辑主体。")
        if require_adjacent and not any(isinstance(item, dict) and item.get("role") == "direct-adjacent" for item in role_groups):
            blockers.append(f"{operation_label}缺少直接相邻 Face 角色，不能确定一级联动范围。")
        return blockers

    def repair_model(self) -> str:
        before_stats = self.stats()
        repaired_parts = 0
        skipped_parts = 0
        for part in self.display_parts():
            if part.shape.IsNull():
                skipped_parts += 1
                continue
            repaired = _prepare_shape_for_step_export(part.shape)
            if repaired.IsNull():
                skipped_parts += 1
                continue
            part.shape = repaired
            repaired_parts += 1

        if repaired_parts == 0:
            raise RuntimeError("No valid part shape was available for repair.")

        self.refresh_topology()
        after_stats = self.stats()
        return (
            "Model repair completed: "
            f"parts repaired={repaired_parts}, skipped={skipped_parts}, "
            f"solids {before_stats.solids}->{after_stats.solids}, "
            f"faces {before_stats.faces}->{after_stats.faces}, "
            f"edges {before_stats.edges}->{after_stats.edges}."
        )

    def repair_part(self, part_id: int) -> str:
        part = self.part_by_id(part_id)
        if part is None:
            raise ValueError(f"未知零件 ID {part_id}")
        if part.shape.IsNull():
            raise RuntimeError(f"零件 {part_id} 为空 shape，无法修复。")
        before_stats = self.part_topology_stats(part_id)
        repaired = _prepare_shape_for_step_export(part.shape)
        if repaired.IsNull():
            raise RuntimeError(f"零件 {part_id} 修复结果为空 shape。")
        part.shape = repaired
        self.refresh_topology()
        after_stats = self.part_topology_stats(part_id)
        return (
            f"零件修复完成: 零件 {part_id}, "
            f"solids {before_stats.solids}->{after_stats.solids}, "
            f"faces {before_stats.faces}->{after_stats.faces}, "
            f"edges {before_stats.edges}->{after_stats.edges}."
        )

    def repair_solid(self, solid_id: int) -> str:
        if solid_id < 0 or solid_id >= len(self.solids):
            raise ValueError(f"Unknown solid id {solid_id}")
        part_id, solid = self.solids[solid_id]
        part = self.part_by_id(part_id)
        if part is None:
            raise ValueError(f"Unknown part id {part_id}")

        before_part_stats = self.part_topology_stats(part_id)
        repaired = _prepare_shape_for_step_export(solid)
        if repaired.IsNull():
            raise RuntimeError(f"Solid {solid_id} repair returned a null shape.")

        part_solids = _explore(part.shape, TopAbs_SOLID)
        if len(part_solids) <= 1:
            part.shape = repaired
        else:
            replaced = False
            shapes: list[TopoDS_Shape] = []
            for item in part_solids:
                if not replaced and _same_shape(item, solid):
                    shapes.append(repaired)
                    replaced = True
                else:
                    shapes.append(item)
            if not replaced:
                raise RuntimeError(f"Could not locate solid {solid_id} inside part {part_id}.")
            part.shape = _compound_from_shapes(shapes)

        _ensure_valid_shape(part.shape)
        self.refresh_topology()
        after_part_stats = self.part_topology_stats(part_id)
        return (
            f"Solid repair completed: solid {solid_id}, part {part_id}, "
            f"part solids {before_part_stats.solids}->{after_part_stats.solids}, "
            f"faces {before_part_stats.faces}->{after_part_stats.faces}, "
            f"edges {before_part_stats.edges}->{after_part_stats.edges}."
        )

    def _edge_first_level_plan_fields(self, edge_id: int) -> dict[str, object]:
        try:
            return self.edge_first_level_facts(edge_id)
        except Exception as exc:
            return {
                "first_level_fact_model": "STEP/B-Rep first-level fact graph",
                "first_level_fact_source_model": "edge",
                "first_level_fact_status": "unavailable",
                "first_level_fact_relation_depth": 1,
                "first_level_fact_relation_boundary": "shared-vertex/shared-face",
                "first_level_fact_scope": "edge",
                "first_level_fact_subject_role": "selected Edge",
                "first_level_fact_subject_edge_ids": (edge_id,),
                "first_level_fact_subject_edge_count": 1,
                "first_level_fact_boundary_edge_count": 1,
                "first_level_fact_boundary_vertex_count": 0,
                "first_level_fact_adjacent_edge_count": 0,
                "first_level_fact_adjacent_face_count": 0,
                "first_level_fact_ignored_relation_depths": ("second-level", "third-level", "deeper"),
                "first_level_fact_summary": f"Edge first-level facts are temporarily unavailable: {exc}",
            }

    def edge_fillet_plan(self, edge_id: int, radius: float) -> dict[str, object]:
        if edge_id < 0 or edge_id >= len(self.edges):
            raise ValueError(f"Unknown edge id {edge_id}")
        info = self.edge_info(edge_id)
        readiness = _edge_fillet_readiness(info, radius)
        part_id = int(info["part_id"])
        part_stats = None
        try:
            part_stats = self.part_topology_stats(part_id)
        except Exception:
            part_stats = None
        if part_stats is not None and part_stats.solids != 1:
            readiness = dict(readiness)
            if readiness["fillet_status"] != "blocked":
                readiness["fillet_status"] = "caution"
                readiness["fillet_risk"] = _max_risk(str(readiness["fillet_risk"]), "high")
                readiness["fillet_warnings"] = _join_nonempty(
                    readiness["fillet_warnings"],
                    f"当前零件包含 {part_stats.solids} 个Solid，Edge倒圆会作用在整个零件 shape 上，请导出前检查结果。",
                )
                readiness["fillet_note"] = _join_nonempty(readiness["fillet_note"], readiness["fillet_warnings"])

        length = float(info.get("length", 0.0))
        radius_to_length_ratio = radius / max(length, 1e-9)
        plan = {
            "status": readiness["fillet_status"],
            "risk": readiness["fillet_risk"],
            "message": readiness["fillet_note"],
            "warnings": readiness["fillet_warnings"],
            "blockers": readiness["fillet_blockers"],
            "edge_id": edge_id,
            "part_id": info["part_id"],
            "solid_id": info.get("solid_id", -1),
            "curve": info.get("curve"),
            "edge_length": length,
            "target_radius": radius,
            "radius_to_length_ratio": radius_to_length_ratio,
            "adjacent_face_ids": info.get("adjacent_face_ids", ()),
            "adjacent_face_count": info.get("adjacent_face_count", 0),
            "start_point": info.get("start_point"),
            "end_point": info.get("end_point"),
            "direction": info.get("direction"),
            "resize_strategy": "add-edge-fillet",
            "edit_strategy_label": "给Edge添加新圆角",
            "edit_semantics": (
                "在当前直线 Edge 及其相邻 Face 上调用 OCCT 倒圆；会替换这条边附近的局部拓扑，"
                "不是修改已有圆角面。"
            ),
        }
        plan.update(self._edge_first_level_plan_fields(edge_id))
        return plan

    def edge_chamfer_plan(self, edge_id: int, distance: float) -> dict[str, object]:
        if edge_id < 0 or edge_id >= len(self.edges):
            raise ValueError(f"Unknown edge id {edge_id}")
        info = self.edge_info(edge_id)
        readiness = _edge_chamfer_readiness(info, distance)
        part_id = int(info["part_id"])
        part_stats = None
        try:
            part_stats = self.part_topology_stats(part_id)
        except Exception:
            part_stats = None
        if part_stats is not None and part_stats.solids != 1:
            readiness = dict(readiness)
            if readiness["chamfer_status"] != "blocked":
                readiness["chamfer_status"] = "caution"
                readiness["chamfer_risk"] = _max_risk(str(readiness["chamfer_risk"]), "high")
                readiness["chamfer_warnings"] = _join_nonempty(
                    readiness["chamfer_warnings"],
                    f"当前零件包含 {part_stats.solids} 个Solid，Edge倒角会作用在整个零件 shape 上，请导出前检查结果。",
                )
                readiness["chamfer_note"] = _join_nonempty(readiness["chamfer_note"], readiness["chamfer_warnings"])

        length = float(info.get("length", 0.0))
        distance_to_length_ratio = distance / max(length, 1e-9)
        plan = {
            "status": readiness["chamfer_status"],
            "risk": readiness["chamfer_risk"],
            "message": readiness["chamfer_note"],
            "warnings": readiness["chamfer_warnings"],
            "blockers": readiness["chamfer_blockers"],
            "edge_id": edge_id,
            "part_id": info["part_id"],
            "solid_id": info.get("solid_id", -1),
            "curve": info.get("curve"),
            "edge_length": length,
            "target_distance": distance,
            "distance_to_length_ratio": distance_to_length_ratio,
            "adjacent_face_ids": info.get("adjacent_face_ids", ()),
            "adjacent_face_count": info.get("adjacent_face_count", 0),
            "start_point": info.get("start_point"),
            "end_point": info.get("end_point"),
            "direction": info.get("direction"),
            "resize_strategy": "add-edge-symmetric-chamfer",
            "edit_strategy_label": "给Edge添加对称倒角",
            "edit_semantics": (
                "在当前直线 Edge 及其相邻 Face 上调用 OCCT 对称倒角；会替换这条边附近的局部拓扑。"
            ),
        }
        plan.update(self._edge_first_level_plan_fields(edge_id))
        return plan

    def edge_asymmetric_chamfer_plan(
        self,
        edge_id: int,
        distance1: float,
        distance2: float,
        reference_face_id: int | None = None,
    ) -> dict[str, object]:
        distance1 = float(distance1)
        distance2 = float(distance2)
        max_distance = max(distance1, distance2)
        plan = self.edge_chamfer_plan(edge_id, max_distance)
        info = self.edge_info(edge_id)
        length = float(info.get("length", 0.0))
        adjacent_face_ids = _int_values(info.get("adjacent_face_ids"))
        blockers = [str(plan.get("blockers", ""))] if str(plan.get("blockers", "")).strip() else []
        warnings = [str(plan.get("warnings", ""))] if str(plan.get("warnings", "")).strip() else []
        risk = str(plan.get("risk", "medium"))

        if distance1 <= 0 or distance2 <= 0:
            blockers.append("Asymmetric chamfer distances D1 and D2 must both be greater than 0.")
        if length <= 1e-9:
            blockers.append("Current Edge length is invalid.")
        if len(adjacent_face_ids) < 2:
            blockers.append("Asymmetric chamfer needs at least two adjacent Faces on the selected Edge.")

        resolved_reference_face_id: int | None
        if reference_face_id is None:
            resolved_reference_face_id = adjacent_face_ids[0] if adjacent_face_ids else None
        else:
            try:
                resolved_reference_face_id = int(reference_face_id)
            except (TypeError, ValueError):
                resolved_reference_face_id = None
                blockers.append("Reference Face ID must be an integer.")

        if resolved_reference_face_id is None:
            blockers.append("Could not resolve an adjacent reference Face for asymmetric chamfer.")
        elif resolved_reference_face_id not in adjacent_face_ids:
            blockers.append(
                f"Reference Face {resolved_reference_face_id} is not adjacent to Edge {edge_id}; "
                f"available adjacent Faces: {tuple(adjacent_face_ids)}."
            )
        elif resolved_reference_face_id < 0 or resolved_reference_face_id >= len(self.faces):
            blockers.append(f"Reference Face {resolved_reference_face_id} does not exist.")

        ratio1 = distance1 / max(length, 1e-9)
        ratio2 = distance2 / max(length, 1e-9)
        if length > 1e-9:
            if max(ratio1, ratio2) >= 0.45:
                blockers.append("D1 or D2 is close to half of the Edge length; asymmetric chamfer is blocked.")
            elif max(ratio1, ratio2) > 0.25:
                risk = _max_risk(risk, "high")
                warnings.append("D1 or D2 is larger than 25% of the Edge length; OCCT chamfer failure is more likely.")
            elif max(ratio1, ratio2) > 0.12:
                risk = _max_risk(risk, "medium")
                warnings.append("D1 or D2 is relatively large compared with the Edge length.")
        if abs(distance1 - distance2) <= max(max_distance * 1e-6, 1e-7):
            warnings.append("D1 and D2 are almost equal; the result will be close to a symmetric chamfer.")

        if blockers:
            status = "blocked"
            risk = "blocked"
            message = " ".join(blockers)
        elif risk != "low":
            status = "caution"
            message = " ".join(warnings) if warnings else "Asymmetric chamfer can be attempted, but it depends on OCCT."
        else:
            status = "ready"
            message = "Asymmetric chamfer can be attempted on this straight Edge."

        plan.update(
            {
                "status": status,
                "risk": risk,
                "message": message,
                "warnings": "; ".join(warnings),
                "blockers": "; ".join(blockers),
                "chamfer_mode": "asymmetric-distances",
                "target_distance": max_distance,
                "target_distance1": distance1,
                "target_distance2": distance2,
                "distance1_to_length_ratio": ratio1,
                "distance2_to_length_ratio": ratio2,
                "reference_face_id": resolved_reference_face_id,
                "reference_face_candidates": tuple(adjacent_face_ids),
                "resize_strategy": "add-edge-asymmetric-chamfer",
                "edit_strategy_label": "给Edge添加不等距倒角",
                "edit_semantics": (
                    "按 D1/D2 两个距离在当前 Edge 两侧生成不等距倒角；参考 Face 决定 D1/D2 的方向。"
                ),
            }
        )
        return plan

    def edge_distance_angle_chamfer_plan(
        self,
        edge_id: int,
        distance: float,
        angle_degrees: float,
        reference_face_id: int | None = None,
    ) -> dict[str, object]:
        distance = float(distance)
        angle_degrees = float(angle_degrees)
        angle_radians = math.radians(angle_degrees)
        plan = self.edge_chamfer_plan(edge_id, distance)
        info = self.edge_info(edge_id)
        length = float(info.get("length", 0.0))
        adjacent_face_ids = _int_values(info.get("adjacent_face_ids"))
        blockers = [str(plan.get("blockers", ""))] if str(plan.get("blockers", "")).strip() else []
        warnings = [str(plan.get("warnings", ""))] if str(plan.get("warnings", "")).strip() else []
        risk = str(plan.get("risk", "medium"))

        if distance <= 0:
            blockers.append("Distance-angle chamfer distance must be greater than 0.")
        if angle_degrees <= 0 or angle_degrees >= 89.0:
            blockers.append("Distance-angle chamfer angle must be greater than 0 and less than 89 degrees.")
        elif angle_degrees < 10.0 or angle_degrees > 80.0:
            risk = _max_risk(risk, "high")
            warnings.append("Chamfer angle is near an extreme value; OCCT failure is more likely.")
        elif angle_degrees < 20.0 or angle_degrees > 70.0:
            risk = _max_risk(risk, "medium")
            warnings.append("Chamfer angle is relatively steep; please check the result carefully.")
        if length <= 1e-9:
            blockers.append("Current Edge length is invalid.")
        if len(adjacent_face_ids) < 2:
            blockers.append("Distance-angle chamfer needs at least two adjacent Faces on the selected Edge.")

        resolved_reference_face_id: int | None
        if reference_face_id is None:
            resolved_reference_face_id = adjacent_face_ids[0] if adjacent_face_ids else None
        else:
            try:
                resolved_reference_face_id = int(reference_face_id)
            except (TypeError, ValueError):
                resolved_reference_face_id = None
                blockers.append("Reference Face ID must be an integer.")

        if resolved_reference_face_id is None:
            blockers.append("Could not resolve an adjacent reference Face for distance-angle chamfer.")
        elif resolved_reference_face_id not in adjacent_face_ids:
            blockers.append(
                f"Reference Face {resolved_reference_face_id} is not adjacent to Edge {edge_id}; "
                f"available adjacent Faces: {tuple(adjacent_face_ids)}."
            )
        elif resolved_reference_face_id < 0 or resolved_reference_face_id >= len(self.faces):
            blockers.append(f"Reference Face {resolved_reference_face_id} does not exist.")

        distance_ratio = distance / max(length, 1e-9)
        if length > 1e-9:
            if distance_ratio >= 0.45:
                blockers.append("Chamfer distance is close to half of the Edge length; distance-angle chamfer is blocked.")
            elif distance_ratio > 0.25:
                risk = _max_risk(risk, "high")
                warnings.append("Chamfer distance is larger than 25% of the Edge length.")
            elif distance_ratio > 0.12:
                risk = _max_risk(risk, "medium")
                warnings.append("Chamfer distance is relatively large compared with the Edge length.")

        if blockers:
            status = "blocked"
            risk = "blocked"
            message = " ".join(blockers)
        elif risk != "low":
            status = "caution"
            message = " ".join(warnings) if warnings else "Distance-angle chamfer can be attempted, but it depends on OCCT."
        else:
            status = "ready"
            message = "Distance-angle chamfer can be attempted on this straight Edge."

        plan.update(
            {
                "status": status,
                "risk": risk,
                "message": message,
                "warnings": "; ".join(warnings),
                "blockers": "; ".join(blockers),
                "chamfer_mode": "distance-angle",
                "target_distance": distance,
                "target_angle_degrees": angle_degrees,
                "target_angle_radians": angle_radians,
                "distance_to_length_ratio": distance_ratio,
                "reference_face_id": resolved_reference_face_id,
                "reference_face_candidates": tuple(adjacent_face_ids),
                "resize_strategy": "add-edge-distance-angle-chamfer",
                "edit_strategy_label": "给Edge添加距离+角度倒角",
                "edit_semantics": (
                    "按距离 D 和角度在当前 Edge 上生成倒角；参考 Face 决定距离和角度的方向。"
                ),
            }
        )
        return plan

    def general_edge_length_plan(
        self,
        edge_id: int,
        target_length: float,
        anchor_mode: str = "auto",
        strategy_mode: str = "auto",
    ) -> dict[str, object]:
        if edge_id < 0 or edge_id >= len(self.edges):
            raise ValueError(f"Unknown edge id {edge_id}")
        info = self.edge_info(edge_id)
        current_length = float(info.get("length", 0.0))
        target_length = float(target_length)
        delta_length = target_length - current_length
        curve = str(info.get("curve", ""))
        anchor_mode = self._edge_length_anchor_mode(anchor_mode)
        strategy_mode = self._edge_length_strategy_mode(strategy_mode)
        force_local = strategy_mode == "local-edge-only-deform"
        force_end_face = strategy_mode == "move-edge-end-plane-by-push-pull"
        force_cylinder = strategy_mode == "resize-adjacent-cylinder-from-circular-edge-length"
        base: dict[str, object] = {
            "edge_id": edge_id,
            "part_id": info.get("part_id"),
            "solid_id": info.get("solid_id", -1),
            "curve": curve,
            "edge_length_anchor_mode": anchor_mode,
            "edge_length_anchor_label": self._edge_length_anchor_label(anchor_mode),
            "edge_length_strategy_mode": strategy_mode,
            "edge_length_strategy_label": self._edge_length_strategy_label(strategy_mode),
            "current_length": current_length,
            "target_length": target_length,
            "delta_length": delta_length,
            "length_change_ratio": abs(delta_length) / max(current_length, 1e-9),
            "start_point": info.get("start_point"),
            "end_point": info.get("end_point"),
            "length_center": info.get("length_center"),
        }
        base.update(self._edge_first_level_plan_fields(edge_id))
        warnings: list[str] = [
            "Edge长度修改基于当前 STEP/B-Rep 结果几何，不是 CAD 建模历史里的参数编辑。"
        ]
        blockers: list[str] = []
        risk = "low"
        status = "ready"

        if current_length <= 1e-9:
            blockers.append("当前Edge长度无效。")
        if target_length <= 1e-9:
            blockers.append("Edge目标长度必须大于 0。")
        if abs(delta_length) <= max(current_length * 1e-7, 1e-7):
            blockers.append("Edge目标长度与当前Edge长度几乎相同，不需要修改。")

        if not blockers:
            ratio = abs(delta_length) / max(current_length, 1e-9)
            if ratio > 0.5:
                risk = _max_risk(risk, "high")
                warnings.append("长度变化超过当前Edge长度的 50%，形状异常或修复失败的概率较高。")
            elif ratio > 0.25:
                risk = _max_risk(risk, "medium")
                warnings.append("长度变化超过当前Edge长度的 25%，请确认预览范围。")

        if not blockers and force_local and curve != "line":
            blockers.append("“只改当前Edge”策略当前只支持直线Edge。")
        if not blockers and force_end_face and curve != "line":
            blockers.append("“移动端面/整体尺寸”策略当前只支持直线Edge。")
        if not blockers and force_cylinder and curve != "circle":
            blockers.append("“相邻圆柱直径”策略当前只支持圆形/圆弧Edge。")
        if not blockers and force_end_face and anchor_mode == "center":
            blockers.append("“移动端面/整体尺寸”需要固定起点、固定终点或自动基准，不能使用固定中心。")

        if not blockers and curve == "line" and strategy_mode in {"auto", "local-edge-only-deform"}:
            local_candidate, local_skip_note = self._local_edge_length_deform_candidate(
                info,
                target_length,
                anchor_mode=anchor_mode,
            )
            if local_candidate is not None:
                risk = _max_risk(risk, str(local_candidate.get("local_edge_deform_risk", "medium")))
                status = "caution" if risk != "low" else status
                warnings.append(
                    "将优先只移动当前 Edge 的端点并重建相邻平面；四点非共面面会优先重建为连续曲面。"
                )
                base.update(local_candidate)
            elif local_skip_note:
                if force_local:
                    blockers.append(local_skip_note)
                else:
                    warnings.append(local_skip_note)

        if not blockers and "resize_strategy" not in base and curve == "line" and anchor_mode != "center" and strategy_mode in {"auto", "move-edge-end-plane-by-push-pull"}:
            candidate = self._straight_edge_length_end_face_candidate(info, delta_length, anchor_mode=anchor_mode)
            if candidate is not None:
                push_plan = self.push_pull_plan(int(candidate["end_face_id"]), float(candidate["push_pull_distance"]))
                if push_plan["status"] != "blocked":
                    risk = _max_risk(risk, str(push_plan["risk"]))
                    push_warnings = str(push_plan.get("warnings", ""))
                    if push_warnings:
                        warnings.append(push_warnings)
                    base.update(candidate)
                    base.update(
                        {
                            "resize_strategy": "move-edge-end-plane-by-push-pull",
                            "push_pull_status": push_plan.get("status"),
                            "push_pull_risk": push_plan.get("risk"),
                            "push_pull_message": push_plan.get("message"),
                            "push_pull_scope_face_ids": push_plan.get("push_pull_scope_face_ids", ()),
                            "push_pull_scope_face_count": push_plan.get("push_pull_scope_face_count", 1),
                            "push_pull_scope_note": push_plan.get("push_pull_scope_note", ""),
                        }
                    )
                else:
                    message = f"端面拉伸/切除路径不可用：{push_plan['message']}"
                    if force_end_face:
                        blockers.append(message)
                    else:
                        warnings.append(f"{message} 将尝试通用仿射缩放。")
            elif anchor_mode in {"keep-start", "keep-end"}:
                message = f"未找到可用于{self._edge_length_anchor_label(anchor_mode)}的端面拉伸/切除路径。"
                if force_end_face:
                    blockers.append(message)
                else:
                    warnings.append(f"{message} 将尝试按该基准缩放所属对象。")
            elif force_end_face:
                blockers.append("未找到可用于当前Edge的端面拉伸/切除路径。")
        elif not blockers and curve == "line" and anchor_mode == "center" and strategy_mode in {"auto", "scale-owning-shape-from-edge"}:
            warnings.append("Edge长度基准为固定中心；将使用轴向仿射缩放，让Edge中心尽量保持不动。")

        if not blockers and "resize_strategy" not in base and curve == "circle" and strategy_mode in {"auto", "resize-adjacent-cylinder-from-circular-edge-length"}:
            cylinder_candidate, cylinder_notes = self._circular_edge_length_cylinder_candidate(info, target_length)
            if cylinder_candidate is not None:
                risk = _max_risk(risk, str(cylinder_candidate["cylinder_resize_risk"]))
                status = "caution" if risk != "low" else status
                warnings.append("识别到相邻圆柱面；将优先把Edge目标长度换算成圆柱直径做局部编辑。")
                cylinder_warnings = str(cylinder_candidate.get("cylinder_resize_warnings", ""))
                if cylinder_warnings:
                    warnings.append(cylinder_warnings)
                base.update(cylinder_candidate)
            elif cylinder_notes:
                if force_cylinder:
                    blockers.append("未找到可复用的相邻圆柱直径编辑路径：" + " ".join(cylinder_notes[:3]))
                else:
                    warnings.extend(cylinder_notes[:3])

        if not blockers and "resize_strategy" not in base and curve != "line" and strategy_mode in {"auto", "scale-owning-shape-from-edge"}:
            planar_candidate, planar_note = self._planar_edge_length_scale_candidate(info, target_length)
            if planar_candidate is not None:
                risk = _max_risk(risk, str(planar_candidate.get("affine_transform_risk", "medium")))
                status = "caution"
                warnings.append(str(planar_candidate.get("affine_transform_warning", "")))
                note = str(planar_candidate.get("affine_transform_note", ""))
                if note:
                    warnings.append(note)
                base.update(planar_candidate)
            elif planar_note:
                warnings.append(planar_note)

        if not blockers and "resize_strategy" not in base and strategy_mode in {"auto", "scale-owning-shape-from-edge"}:
            axis = self._edge_length_affine_axis(info, anchor_mode=anchor_mode)
            if axis is None:
                blockers.append("无法为当前 Edge 推断可靠的缩放方向。")
            else:
                part_id = int(info.get("part_id", -1))
                solid_id = int(info.get("solid_id", -1))
                part = self.part_by_id(part_id) if part_id >= 0 else None
                part_solid_count = len(_explore(part.shape, TopAbs_SOLID)) if part is not None else 0
                target_kind = "solid" if solid_id >= 0 and part_solid_count > 1 else "part"
                scale = target_length / max(current_length, 1e-9)
                transform_kind = "axis-affine" if curve == "line" else "uniform"
                transform_label = "沿Edge方向仿射缩放" if transform_kind == "axis-affine" else "以Edge中心整体缩放"
                risk = _max_risk(risk, "medium")
                if curve != "line" or abs(scale - 1.0) > 0.25:
                    risk = _max_risk(risk, "high")
                status = "caution"
                if transform_kind == "axis-affine":
                    warnings.append(
                        "未找到可拉伸/切除端面；将沿该Edge的几何方向对所属 "
                        f"{target_kind} 做仿射缩放。该 fallback 会影响同一 {target_kind} 上的其他尺寸。"
                    )
                else:
                    warnings.append(
                        "当前 Edge 不是直线；将以 Edge 中心为基准对所属 "
                        f"{target_kind} 做均匀缩放。该 fallback 会影响同一 {target_kind} 上的其他尺寸。"
                    )
                if curve != "line":
                    warnings.append("非直线Edge的目标长度通过整体比例缩放实现，执行后请复查周边尺寸。")
                base.update(
                    {
                        "resize_strategy": "scale-owning-shape-from-edge",
                        "affine_scale": scale,
                        "affine_transform_kind": transform_kind,
                        "affine_transform_label": transform_label,
                        "affine_transform_note": "",
                        "affine_axis_point": axis["axis_point"],
                        "affine_axis_direction": axis["axis_direction"],
                        "affine_axis_source": axis["axis_source"],
                        "affine_anchor_source": axis["anchor_source"],
                        "affine_target_kind": target_kind,
                        "part_solid_count": part_solid_count,
                    }
                )
        elif not blockers and "resize_strategy" not in base and strategy_mode != "auto":
            blockers.append(f"当前Edge不满足所选策略“{self._edge_length_strategy_label(strategy_mode)}”的执行条件。")

        if not blockers and base.get("resize_strategy") == "scale-owning-shape-from-edge":
            refine_note = self._refine_affine_edge_length_scale(base)
            if refine_note:
                warnings.append(refine_note)

        if blockers:
            status = "blocked"
            risk = "blocked"
            message = " ".join(blockers)
        elif risk != "low":
            status = "caution"
            message = " ".join(warnings)
        else:
            strategy = str(base.get("resize_strategy", ""))
            if strategy == "local-edge-only-deform":
                message = "可以通过局部边形变只调整这条直线Edge，并重建周边平面。"
            elif strategy == "move-edge-end-plane-by-push-pull":
                message = "可以通过端面拉伸/切除调整这条直线Edge长度。"
            elif strategy == "resize-adjacent-cylinder-from-circular-edge-length":
                message = "可以通过相邻圆柱直径编辑调整这条圆形/圆弧Edge长度。"
            elif strategy == "scale-owning-shape-from-edge":
                message = "可以通过几何缩放 fallback 尝试调整该Edge长度。"
            else:
                message = "可以尝试直接修改该Edge长度。"

        base.update(
            {
                "edge_length_constraint_summary": self._edge_length_constraint_summary(anchor_mode),
                "edge_length_impact_summary": self._edge_length_impact_summary(base),
                "edit_strategy_label": self._edge_length_strategy_label(str(base.get("resize_strategy") or strategy_mode)),
                "edit_semantics": self._edge_length_impact_summary(base),
                "status": status,
                "risk": risk,
                "message": message,
                "warnings": "；".join(warnings),
                "blockers": "；".join(blockers),
            }
        )
        return base

    def _local_edge_length_deform_candidate(
        self,
        edge_info: dict[str, object],
        target_length: float,
        anchor_mode: str = "auto",
    ) -> tuple[dict[str, object] | None, str]:
        if str(edge_info.get("curve", "")) != "line":
            return None, ""
        start = _tuple_or_none(edge_info.get("start_point"))
        end = _tuple_or_none(edge_info.get("end_point"))
        if start is None or end is None:
            return None, "局部边形变不可用：当前 Edge 缺少稳定起点或终点。"
        current_length = float(edge_info.get("length", 0.0))
        if current_length <= 1e-9:
            return None, "局部边形变不可用：当前Edge长度无效。"
        axis = _tuple_normalized(_tuple_sub(end, start))
        if axis is None:
            return None, "局部边形变不可用：当前 Edge 方向无效。"
        solid_id = int(edge_info.get("solid_id", -1))
        if solid_id < 0 or solid_id >= len(self.solids):
            return None, "局部边形变不可用：当前 Edge 没有关联到稳定 Solid。"
        part_id = int(edge_info.get("part_id", -1))
        part = self.part_by_id(part_id)
        if part is None:
            return None, "局部边形变不可用：找不到所属零件。"
        solid = self.solids[solid_id][1]
        solid_faces = _explore(solid, TopAbs_FACE)
        if not solid_faces:
            return None, "局部边形变不可用：所属Solid没有可重建Face。"
        if len(solid_faces) > 128:
            return None, "局部边形变暂只对较简单的平面多面体开放，复杂模型将使用后备策略。"
        for face in solid_faces:
            surf = BRepAdaptor_Surface(face)
            if surf.GetType() != GeomAbs_Plane:
                return None, "局部边形变暂只支持全平面多面体；含曲面的模型将使用后备策略。"
            if len(_explore(face, TopAbs_WIRE)) != 1:
                return None, "局部边形变暂不处理带内孔的Face；将使用后备策略。"
            if len(self._local_deform_face_vertex_points(face, max(_shape_diagonal(solid) * 1e-7, 1e-6))) < 3:
                return None, "局部边形变不可用：部分Face顶点环无法稳定读取。"

        anchor_mode = self._edge_length_anchor_mode(anchor_mode)
        target_length = float(target_length)
        delta_length = target_length - current_length
        if anchor_mode == "keep-end":
            start_move = _tuple_scale(axis, -delta_length)
            end_move = (0.0, 0.0, 0.0)
            moved_label = "移动起点，固定终点"
        elif anchor_mode == "center":
            start_move = _tuple_scale(axis, -delta_length * 0.5)
            end_move = _tuple_scale(axis, delta_length * 0.5)
            moved_label = "两端各移动一半，保持中心"
        else:
            start_move = (0.0, 0.0, 0.0)
            end_move = _tuple_scale(axis, delta_length)
            moved_label = "固定起点，移动终点"

        part_solid_count = len(_explore(part.shape, TopAbs_SOLID))
        target_kind = "solid" if part_solid_count > 1 else "part"
        ratio = abs(delta_length) / max(current_length, 1e-9)
        local_risk = "high" if ratio > 0.5 else "medium"
        return (
            {
                "resize_strategy": "local-edge-only-deform",
                "local_edge_deform_target_kind": target_kind,
                "local_edge_deform_face_count": len(solid_faces),
                "local_edge_deform_anchor": moved_label,
                "local_edge_deform_start_move": start_move,
                "local_edge_deform_end_move": end_move,
                "local_edge_deform_moved_endpoint_count": 2 if anchor_mode == "center" else 1,
                "local_edge_deform_risk": local_risk,
                "local_edge_deform_note": (
                    "只移动当前 Edge 的端点并重建所属平面多面体；四点非共面 Face 会优先重建为连续曲面。"
                ),
                "part_solid_count": part_solid_count,
            },
            "",
        )

    def edge_endpoint_move_plan(
        self,
        edge_id: int,
        endpoint_role: str,
        target_point: tuple[float, float, float],
    ) -> dict[str, object]:
        if edge_id < 0 or edge_id >= len(self.edges):
            raise ValueError(f"Unknown edge id {edge_id}")

        role = str(endpoint_role or "").strip().lower()
        role_aliases = {
            "start": "start",
            "edge-start": "start",
            "begin": "start",
            "起点": "start",
            "end": "end",
            "edge-end": "end",
            "finish": "end",
            "终点": "end",
        }
        role = role_aliases.get(role, role)
        if role not in {"start", "end"}:
            raise ValueError("endpoint_role must be 'start' or 'end'.")

        info = self.edge_info(edge_id)
        current_length = float(info.get("length", 0.0))
        curve = str(info.get("curve", ""))
        start = _tuple_or_none(info.get("start_point"))
        end = _tuple_or_none(info.get("end_point"))
        target = _tuple_or_none(target_point)
        base: dict[str, object] = {
            "edge_id": edge_id,
            "part_id": info.get("part_id"),
            "solid_id": info.get("solid_id", -1),
            "curve": curve,
            "current_length": current_length,
            "target_length": current_length,
            "delta_length": 0.0,
            "length_change_ratio": 0.0,
            "edge_endpoint_role": role,
            "edge_endpoint_label": "start point" if role == "start" else "end point",
            "start_point": start,
            "end_point": end,
            "target_endpoint_point": target,
            "length_center": info.get("length_center"),
            "resize_strategy": "local-edge-endpoint-deform",
        }
        base.update(self._edge_first_level_plan_fields(edge_id))
        warnings = [
            "Edge endpoint coordinate edit rebuilds the current STEP/B-Rep result geometry; it is not recovered CAD history."
        ]
        blockers: list[str] = []
        risk = "low"
        status = "ready"

        if curve != "line":
            blockers.append("Only straight line Edge endpoints can be moved directly.")
        if current_length <= 1e-9:
            blockers.append("Current Edge length is invalid.")
        if start is None or end is None:
            blockers.append("Current Edge does not have stable start/end coordinates.")
        if target is None:
            blockers.append("Target endpoint coordinate must be a valid X/Y/Z tuple.")

        if not blockers and start is not None and end is not None and target is not None:
            current_endpoint = start if role == "start" else end
            fixed_endpoint = end if role == "start" else start
            move = _tuple_sub(target, current_endpoint)
            move_distance = _vector_length(move)
            target_length = _vector_length(_tuple_sub(target, fixed_endpoint))
            delta_length = target_length - current_length
            length_change_ratio = abs(delta_length) / max(current_length, 1e-9)
            move_ratio = move_distance / max(current_length, 1e-9)
            base.update(
                {
                    "current_endpoint_point": current_endpoint,
                    "fixed_endpoint_point": fixed_endpoint,
                    "target_length": target_length,
                    "delta_length": delta_length,
                    "length_change_ratio": length_change_ratio,
                    "moved_endpoint_delta": move,
                    "moved_endpoint_distance": move_distance,
                    "moved_endpoint_ratio": move_ratio,
                    "edge_length_anchor_mode": "keep-end" if role == "start" else "keep-start",
                    "edge_length_anchor_label": "fixed end point" if role == "start" else "fixed start point",
                }
            )
            if move_distance <= max(current_length * 1e-7, 1e-7):
                blockers.append("Target endpoint coordinate is almost identical to the current coordinate.")
            if target_length <= 1e-9:
                blockers.append("Moving this endpoint would collapse the Edge length to zero.")
            if move_ratio > 0.5 or length_change_ratio > 0.5:
                risk = _max_risk(risk, "high")
                warnings.append("Endpoint movement or resulting length change is larger than 50% of the current Edge length.")
            elif move_ratio > 0.25 or length_change_ratio > 0.25:
                risk = _max_risk(risk, "medium")
                warnings.append("Endpoint movement or resulting length change is larger than 25% of the current Edge length.")

        if not blockers and start is not None and end is not None and target is not None:
            anchor_mode = "keep-end" if role == "start" else "keep-start"
            local_candidate, local_skip_note = self._local_edge_length_deform_candidate(
                info,
                float(base["target_length"]),
                anchor_mode=anchor_mode,
            )
            if local_candidate is None:
                blockers.append(local_skip_note or "Local endpoint deformation is not available for this Edge.")
            else:
                start_move = _tuple_sub(target, start) if role == "start" else (0.0, 0.0, 0.0)
                end_move = _tuple_sub(target, end) if role == "end" else (0.0, 0.0, 0.0)
                expected_start = _tuple_add(start, start_move)
                expected_end = _tuple_add(end, end_move)
                base.update(local_candidate)
                base.update(
                    {
                        "resize_strategy": "local-edge-endpoint-deform",
                        "local_edge_deform_anchor": "move start point, keep end point"
                        if role == "start"
                        else "move end point, keep start point",
                        "local_edge_deform_start_move": start_move,
                        "local_edge_deform_end_move": end_move,
                        "local_edge_deform_moved_endpoint_count": 1,
                        "local_edge_deform_note": (
                            "Move one endpoint of the selected straight Edge and rebuild the surrounding planar solid."
                        ),
                        "expected_start_point": expected_start,
                        "expected_end_point": expected_end,
                    }
                )
                risk = _max_risk(risk, str(local_candidate.get("local_edge_deform_risk", "medium")))
                warnings.append(
                    "The selected Edge endpoint will be moved and the surrounding planar faces will be rebuilt; four-point non-planar faces are rebuilt as continuous surfaces when possible."
                )

        if blockers:
            status = "blocked"
            risk = "blocked"
            message = " ".join(blockers)
        elif risk != "low":
            status = "caution"
            message = " ".join(warnings)
        else:
            message = "The straight Edge endpoint can be moved by local planar-solid deformation."

        base.update(
            {
                "status": status,
                "risk": risk,
                "message": message,
                "warnings": "; ".join(warnings),
                "blockers": "; ".join(blockers),
            }
        )
        return base

    def edge_center_move_plan(
        self,
        edge_id: int,
        target_center: tuple[float, float, float],
    ) -> dict[str, object]:
        if edge_id < 0 or edge_id >= len(self.edges):
            raise ValueError(f"Unknown edge id {edge_id}")

        info = self.edge_info(edge_id)
        current_length = float(info.get("length", 0.0))
        curve = str(info.get("curve", ""))
        start = _tuple_or_none(info.get("start_point"))
        end = _tuple_or_none(info.get("end_point"))
        current_center = _tuple_or_none(info.get("length_center"))
        target = _tuple_or_none(target_center)
        base: dict[str, object] = {
            "edge_id": edge_id,
            "part_id": info.get("part_id"),
            "solid_id": info.get("solid_id", -1),
            "curve": curve,
            "current_length": current_length,
            "target_length": current_length,
            "delta_length": 0.0,
            "length_change_ratio": 0.0,
            "start_point": start,
            "end_point": end,
            "length_center": current_center,
            "target_edge_center": target,
            "resize_strategy": "local-edge-center-deform",
        }
        base.update(self._edge_first_level_plan_fields(edge_id))
        warnings = [
            "Edge center coordinate edit rebuilds the current STEP/B-Rep result geometry; it is not recovered CAD history."
        ]
        blockers: list[str] = []
        risk = "low"
        status = "ready"

        if curve != "line":
            blockers.append("Only straight line Edge centers can be moved directly.")
        if current_length <= 1e-9:
            blockers.append("Current Edge length is invalid.")
        if start is None or end is None or current_center is None:
            blockers.append("Current Edge does not have stable start/end/center coordinates.")
        if target is None:
            blockers.append("Target Edge center coordinate must be a valid X/Y/Z tuple.")

        if not blockers and start is not None and end is not None and current_center is not None and target is not None:
            move = _tuple_sub(target, current_center)
            move_distance = _vector_length(move)
            move_ratio = move_distance / max(current_length, 1e-9)
            base.update(
                {
                    "current_edge_center": current_center,
                    "target_edge_center": target,
                    "moved_edge_center_delta": move,
                    "moved_edge_center_distance": move_distance,
                    "moved_edge_center_ratio": move_ratio,
                    "edge_length_anchor_mode": "center",
                    "edge_length_anchor_label": "move whole edge center",
                }
            )
            if move_distance <= max(current_length * 1e-7, 1e-7):
                blockers.append("Target Edge center coordinate is almost identical to the current coordinate.")
            if move_ratio > 0.5:
                risk = _max_risk(risk, "high")
                warnings.append("Edge center movement is larger than 50% of the current Edge length.")
            elif move_ratio > 0.25:
                risk = _max_risk(risk, "medium")
                warnings.append("Edge center movement is larger than 25% of the current Edge length.")

        if not blockers and start is not None and end is not None and current_center is not None and target is not None:
            local_candidate, local_skip_note = self._local_edge_length_deform_candidate(
                info,
                current_length,
                anchor_mode="center",
            )
            if local_candidate is None:
                blockers.append(local_skip_note or "Local Edge center deformation is not available for this Edge.")
            else:
                move = _tuple_sub(target, current_center)
                expected_start = _tuple_add(start, move)
                expected_end = _tuple_add(end, move)
                base.update(local_candidate)
                base.update(
                    {
                        "resize_strategy": "local-edge-center-deform",
                        "local_edge_deform_anchor": "move both endpoints equally",
                        "local_edge_deform_start_move": move,
                        "local_edge_deform_end_move": move,
                        "local_edge_deform_moved_endpoint_count": 2,
                        "local_edge_deform_note": (
                            "Move both endpoints of the selected straight Edge and rebuild the surrounding planar solid."
                        ),
                        "expected_start_point": expected_start,
                        "expected_end_point": expected_end,
                    }
                )
                risk = _max_risk(risk, str(local_candidate.get("local_edge_deform_risk", "medium")))
                warnings.append(
                    "Both endpoints of the selected Edge will be moved and the surrounding planar faces will be rebuilt; four-point non-planar faces are rebuilt as continuous surfaces when possible."
                )

        if blockers:
            status = "blocked"
            risk = "blocked"
            message = " ".join(blockers)
        elif risk != "low":
            status = "caution"
            message = " ".join(warnings)
        else:
            message = "The straight Edge center can be moved by local planar-solid deformation."

        base.update(
            {
                "status": status,
                "risk": risk,
                "message": message,
                "warnings": "; ".join(warnings),
                "blockers": "; ".join(blockers),
            }
        )
        return base

    def _edge_length_anchor_mode(self, anchor_mode: str | None) -> str:
        normalized = str(anchor_mode or "auto").strip().lower()
        aliases = {
            "自动": "auto",
            "auto": "auto",
            "center": "center",
            "centre": "center",
            "固定中心": "center",
            "keep-center": "center",
            "start": "keep-start",
            "起点": "keep-start",
            "固定起点": "keep-start",
            "keep-start": "keep-start",
            "end": "keep-end",
            "终点": "keep-end",
            "固定终点": "keep-end",
            "keep-end": "keep-end",
        }
        return aliases.get(normalized, "auto")

    def _edge_length_anchor_label(self, anchor_mode: str) -> str:
        return {
            "auto": "自动选择局部端面",
            "center": "固定中心",
            "keep-start": "固定起点",
            "keep-end": "固定终点",
        }.get(anchor_mode, "自动选择局部端面")

    def _edge_length_strategy_mode(self, strategy_mode: str | None) -> str:
        normalized = str(strategy_mode or "auto").strip().lower()
        aliases = {
            "自动": "auto",
            "auto": "auto",
            "local": "local-edge-only-deform",
            "local-edge": "local-edge-only-deform",
            "local-edge-only": "local-edge-only-deform",
            "local-edge-only-deform": "local-edge-only-deform",
            "只改当前edge": "local-edge-only-deform",
            "只改这条edge": "local-edge-only-deform",
            "只改当前边": "local-edge-only-deform",
            "只改这条边": "local-edge-only-deform",
            "只变当前edge": "local-edge-only-deform",
            "只变这条edge": "local-edge-only-deform",
            "只变当前边": "local-edge-only-deform",
            "只变这条边": "local-edge-only-deform",
            "局部边形变": "local-edge-only-deform",
            "end-face": "move-edge-end-plane-by-push-pull",
            "push-pull": "move-edge-end-plane-by-push-pull",
            "move-edge-end-plane": "move-edge-end-plane-by-push-pull",
            "move-edge-end-plane-by-push-pull": "move-edge-end-plane-by-push-pull",
            "移动端面": "move-edge-end-plane-by-push-pull",
            "移动端面/保持垂直": "move-edge-end-plane-by-push-pull",
            "保持垂直": "move-edge-end-plane-by-push-pull",
            "保持面垂直": "move-edge-end-plane-by-push-pull",
            "保持相邻面垂直": "move-edge-end-plane-by-push-pull",
            "端面拉伸/切除": "move-edge-end-plane-by-push-pull",
            "整体尺寸变化": "move-edge-end-plane-by-push-pull",
            "变成长方体": "move-edge-end-plane-by-push-pull",
            "cylinder": "resize-adjacent-cylinder-from-circular-edge-length",
            "adjacent-cylinder": "resize-adjacent-cylinder-from-circular-edge-length",
            "resize-adjacent-cylinder-from-circular-edge-length": "resize-adjacent-cylinder-from-circular-edge-length",
            "相邻圆柱": "resize-adjacent-cylinder-from-circular-edge-length",
            "相邻圆柱直径": "resize-adjacent-cylinder-from-circular-edge-length",
            "scale": "scale-owning-shape-from-edge",
            "scale-owning": "scale-owning-shape-from-edge",
            "scale-owning-shape-from-edge": "scale-owning-shape-from-edge",
            "缩放所属对象": "scale-owning-shape-from-edge",
            "整体缩放": "scale-owning-shape-from-edge",
        }
        return aliases.get(normalized, "auto")

    def _edge_length_strategy_label(self, strategy_mode: str) -> str:
        return {
            "auto": "自动选择",
            "local-edge-only-deform": "只改当前Edge",
            "move-edge-end-plane-by-push-pull": "移动端面/保持垂直",
            "resize-adjacent-cylinder-from-circular-edge-length": "相邻圆柱直径",
            "scale-owning-shape-from-edge": "缩放所属对象",
        }.get(strategy_mode, "自动选择")

    def _edge_length_constraint_summary(self, anchor_mode: str) -> str:
        anchor_mode = self._edge_length_anchor_mode(anchor_mode)
        return {
            "auto": "自动基准：默认尽量固定起点，移动终点；如果策略需要，会按可用端面调整。",
            "center": "固定中心：Edge中心尽量不动，两端或所属对象围绕中心变化。",
            "keep-start": "固定起点：起点尽量不动，终点或相关端面承担长度变化。",
            "keep-end": "固定终点：终点尽量不动，起点或相关端面承担长度变化。",
        }.get(anchor_mode, "自动基准：程序会选择更稳定的一端作为固定约束。")

    def _edge_length_impact_summary(self, plan: dict[str, object]) -> str:
        strategy = str(plan.get("resize_strategy") or plan.get("edge_length_strategy_mode") or "auto")
        target_kind = str(plan.get("affine_target_kind") or plan.get("local_edge_deform_target_kind") or "所属对象")
        if strategy == "local-edge-only-deform":
            return (
                "只改当前Edge：只移动被选Edge的端点并重建相邻平面；相邻面会自然变斜，"
                "四点非共面面会优先重建为连续曲面，整体端面不会一起平移。"
            )
        if strategy == "move-edge-end-plane-by-push-pull":
            end_face = plan.get("end_face_id")
            face_text = f" Face {end_face}" if end_face not in {None, ""} else ""
            return (
                f"移动端面：把长度变化转换为端面{face_text}拉伸/切除；端面和同一端面区域上的相关边会跟随，"
                "相邻平面会尽量保持垂直，正方体这类模型会更像变成长方体。"
            )
        if strategy == "resize-adjacent-cylinder-from-circular-edge-length":
            return (
                "相邻圆柱直径：把圆形/圆弧Edge目标长度换算成相邻圆柱直径，"
                "优先重切孔/槽或重建凸台，不会把整个模型按Edge长度缩放。"
            )
        if strategy == "scale-owning-shape-from-edge":
            return (
                f"缩放所属对象：对所属 {target_kind} 做轴向、径向或整体缩放；"
                "同一对象上的其它尺寸会跟随变化，适合作为明确选择的高风险兜底语义。"
            )
        return (
            "自动选择：程序会按局部Edge形变、端面移动、相邻圆柱编辑、缩放所属对象的顺序寻找可用路径；"
            "确认窗口会显示最终采用的实际策略。"
        )

    def _circular_edge_length_cylinder_candidate(
        self,
        edge_info: dict[str, object],
        target_length: float,
    ) -> tuple[dict[str, object] | None, list[str]]:
        current_length = float(edge_info.get("length", 0.0))
        current_radius = float(edge_info.get("radius", 0.0))
        if current_length <= 1e-9 or current_radius <= 1e-9:
            return None, []

        length_scale = float(target_length) / current_length
        target_radius = current_radius * length_scale
        target_diameter = target_radius * 2.0
        if target_diameter <= 1e-9:
            return None, []

        notes: list[str] = []
        candidates: list[tuple[tuple[int, int, int, int], dict[str, object]]] = []
        risk_rank = {"low": 0, "medium": 1, "high": 2, "blocked": 3}
        status_rank = {"ready": 0, "caution": 1, "blocked": 2}
        adjacent_face_ids = _int_values(edge_info.get("adjacent_face_ids"))
        if not adjacent_face_ids:
            return None, []

        for face_id in adjacent_face_ids:
            if face_id < 0 or face_id >= len(self.faces):
                continue
            face_info = self.face_info(face_id)
            if face_info.get("surface") != "cylinder" or "diameter" not in face_info:
                continue
            face_radius = float(face_info.get("radius", 0.0))
            if face_radius <= 1e-9:
                continue
            radius_tolerance = max(current_radius * 0.06, face_radius * 0.06, _shape_diagonal(self.faces[face_id]) * 1e-5, 1e-4)
            if abs(face_radius - current_radius) > radius_tolerance:
                continue

            feature_guess = str(face_info.get("feature_guess", "cylindrical face"))
            if feature_guess == "round/fillet candidate":
                notes.append(f"相邻圆柱Face {face_id} 更像已有圆角，未自动按孔/凸台直径改边长。")
                continue

            if feature_guess == "hole/groove candidate":
                mode_order = ("hole",)
            elif feature_guess == "boss/outer-round candidate":
                mode_order = ("boss",)
            else:
                notes.append(f"相邻圆柱Face {face_id} 尚未明确识别为孔/槽或凸台，未自动按圆柱直径改边长。")
                continue
            for mode_index, mode in enumerate(mode_order):
                mode_label = "圆柱凸台直径" if mode == "boss" else "圆柱孔/槽直径"
                try:
                    cylinder_plan = (
                        self.cylindrical_boss_resize_plan(face_id, target_diameter)
                        if mode == "boss"
                        else self.cylindrical_resize_plan(face_id, target_diameter)
                    )
                except Exception as exc:
                    notes.append(f"相邻圆柱Face {face_id} 的{mode_label}计划生成失败：{exc}")
                    continue

                plan_status = str(cylinder_plan.get("status", "blocked"))
                plan_risk = str(cylinder_plan.get("risk", "blocked"))
                if plan_status == "blocked":
                    notes.append(f"相邻圆柱Face {face_id} 的{mode_label}不可用：{cylinder_plan.get('message', '')}")
                    continue

                candidate = {
                    "resize_strategy": "resize-adjacent-cylinder-from-circular-edge-length",
                    "circular_edge_current_radius": current_radius,
                    "circular_edge_target_radius": target_radius,
                    "circular_edge_length_scale": length_scale,
                    "circular_edge_cylinder_face_id": face_id,
                    "circular_edge_cylinder_mode": mode,
                    "circular_edge_cylinder_mode_label": mode_label,
                    "cylinder_resize_face_id": face_id,
                    "cylinder_resize_operation": "resize_cylindrical_boss" if mode == "boss" else "resize_cylindrical_hole",
                    "cylinder_resize_current_diameter": cylinder_plan.get("current_diameter"),
                    "cylinder_resize_target_diameter": target_diameter,
                    "cylinder_resize_delta_diameter": cylinder_plan.get("delta_diameter"),
                    "cylinder_resize_delta_ratio": cylinder_plan.get("diameter_delta_ratio"),
                    "cylinder_resize_status": plan_status,
                    "cylinder_resize_risk": plan_risk,
                    "cylinder_resize_message": cylinder_plan.get("message"),
                    "cylinder_resize_warnings": cylinder_plan.get("warnings", ""),
                    "cylinder_resize_blockers": cylinder_plan.get("blockers", ""),
                    "cylinder_resize_feature_guess": cylinder_plan.get("feature_guess", feature_guess),
                    "cylinder_resize_confidence": cylinder_plan.get("confidence", face_info.get("confidence", "")),
                    "cylinder_resize_same_domain_face_ids": cylinder_plan.get("same_domain_face_ids", ()),
                    "cylinder_resize_same_domain_face_count": cylinder_plan.get("same_domain_face_count", ""),
                }
                score = (
                    status_rank.get(plan_status, 9),
                    risk_rank.get(plan_risk, 9),
                    mode_index,
                    face_id,
                )
                candidates.append((score, candidate))

        if not candidates:
            if notes:
                notes.insert(0, "圆边没有找到可直接复用的相邻圆柱直径编辑路径，将回退到几何缩放。")
            return None, notes

        candidates.sort(key=lambda item: item[0])
        return candidates[0][1], notes

    def circular_edge_axis_move_plan(
        self,
        edge_id: int,
        target_center: tuple[float, float, float],
    ) -> dict[str, object]:
        if edge_id < 0 or edge_id >= len(self.edges):
            raise ValueError(f"Unknown edge id {edge_id}")

        info = self.edge_info(edge_id)
        blockers: list[str] = []
        warnings: list[str] = [
            "圆Edge圆心/轴心移动会优先寻找相邻孔、槽或凸台圆柱面，再复用对应轴心移动路线。"
        ]
        risk = "medium"
        try:
            target = (float(target_center[0]), float(target_center[1]), float(target_center[2]))
        except (TypeError, ValueError, IndexError):
            target = (0.0, 0.0, 0.0)
            blockers.append("圆Edge目标圆心必须是 X, Y, Z 三个数字。")

        current_center = _tuple_or_none(info.get("center"))
        current_radius = _float_or_none(info.get("radius"))
        current_length = _float_or_none(info.get("length"))
        curve = str(info.get("curve", ""))
        if curve != "circle":
            blockers.append("只有圆形或圆弧 Edge 才能按相邻圆柱轴心移动。")
        if current_center is None:
            blockers.append("当前圆Edge缺少稳定圆心，不能换算轴心移动。")
        if current_radius is None or current_radius <= 1e-9:
            blockers.append("当前圆Edge缺少稳定半径，不能匹配相邻圆柱。")

        movement = (0.0, 0.0, 0.0)
        move_distance = 0.0
        if current_center is not None:
            movement = _tuple_sub(target, current_center)
            move_distance = _vector_length(movement)
            diagonal = max(_shape_diagonal(self.edges[edge_id]), current_radius or 0.0, 1.0)
            if move_distance <= max(diagonal * 1e-7, 1e-6):
                blockers.append("目标圆心和当前圆心几乎相同，无需移动。")
            elif current_radius is not None and current_radius > 0:
                ratio = move_distance / current_radius
                if ratio > 8.0:
                    risk = _max_risk(risk, "high")
                    warnings.append("圆心移动超过 8 个圆边半径，布尔操作可能影响无关几何。")
                elif ratio > 2.0:
                    risk = _max_risk(risk, "high")
                    warnings.append("圆心移动超过 2 个圆边半径，建议执行后重点检查周边壁厚。")

        candidate: dict[str, object] | None = None
        candidate_notes: list[str] = []
        if not blockers:
            candidate, candidate_notes = self._circular_edge_axis_move_cylinder_candidate(info, movement)
            if candidate is None:
                blockers.append(
                    "未找到可复用的相邻孔、槽或凸台圆柱轴心移动路径。"
                    + (" " + " ".join(candidate_notes[:3]) if candidate_notes else "")
                )
            else:
                risk = _max_risk(risk, str(candidate.get("move_axis_risk", "medium")))
                warnings.append(str(candidate.get("move_axis_warnings", "")))
                if candidate_notes:
                    warnings.extend(candidate_notes[:3])

        if blockers:
            status = "blocked"
            risk = "blocked"
            message = " ".join(blockers)
        else:
            status = "caution" if risk in {"medium", "high"} else "ready"
            mode_label = str(candidate.get("circular_edge_cylinder_mode_label", "相邻圆柱轴心")) if candidate else "相邻圆柱轴心"
            message = (
                f"可以通过{mode_label}移动来调整圆Edge圆心；"
                "圆边所在截面的圆心移动量会同步应用到相邻圆柱的中间轴心。 "
                + " ".join(part for part in warnings if part)
            )

        result = {
            "status": status,
            "risk": risk,
            "message": message,
            "warnings": "; ".join(part for part in warnings if part),
            "blockers": "; ".join(blockers),
            "edge_id": edge_id,
            "part_id": info.get("part_id"),
            "solid_id": info.get("solid_id"),
            "curve": curve,
            "current_edge_center": current_center,
            "target_edge_center": target,
            "circular_edge_center_move_vector": movement,
            "circular_edge_center_move_distance": move_distance,
            "circular_edge_current_radius": current_radius,
            "circular_edge_current_diameter": None if current_radius is None else current_radius * 2.0,
            "current_length": current_length,
            "resize_strategy": "move-adjacent-cylinder-from-circular-edge-center",
            "edit_strategy_label": "圆Edge相邻圆柱轴心移动",
            "edit_semantics": (
                "把圆Edge圆心的移动量应用到相邻孔、槽或凸台的圆柱轴心；"
                "这是移动局部圆柱特征，不是整体平移零件。"
            ),
        }
        if candidate:
            result.update(candidate)
        result.update(self._edge_first_level_plan_fields(edge_id))
        return result

    def _circular_edge_axis_move_cylinder_candidate(
        self,
        edge_info: dict[str, object],
        movement: tuple[float, float, float],
    ) -> tuple[dict[str, object] | None, list[str]]:
        current_radius = _float_or_none(edge_info.get("radius"))
        if current_radius is None or current_radius <= 1e-9:
            return None, []

        notes: list[str] = []
        candidates: list[tuple[tuple[int, int, int, int], dict[str, object]]] = []
        risk_rank = {"low": 0, "medium": 1, "high": 2, "blocked": 3}
        status_rank = {"ready": 0, "caution": 1, "blocked": 2}
        adjacent_face_ids = _int_values(edge_info.get("adjacent_face_ids"))
        if not adjacent_face_ids:
            return None, ["圆Edge没有相邻Face信息，无法判断它属于哪个孔/槽/凸台。"]

        for face_id in adjacent_face_ids:
            if face_id < 0 or face_id >= len(self.faces):
                continue
            face_info = self.face_info(face_id)
            if face_info.get("surface") != "cylinder" or "diameter" not in face_info:
                continue
            face_radius = _float_or_none(face_info.get("radius"))
            if face_radius is None or face_radius <= 1e-9:
                continue
            radius_tolerance = max(current_radius * 0.06, face_radius * 0.06, _shape_diagonal(self.faces[face_id]) * 1e-5, 1e-4)
            if abs(face_radius - current_radius) > radius_tolerance:
                continue

            feature_guess = str(face_info.get("feature_guess", "cylindrical face"))
            if feature_guess == "round/fillet candidate":
                notes.append(f"相邻圆柱Face {face_id} 更像已有圆角，未按孔/槽/凸台轴心移动。")
                continue

            feature: dict[str, object] = {}
            try:
                feature = self.feature_info(face_id)
            except Exception:
                feature = {}
            face_feature_info = {**face_info, **feature}
            axis_data = self._cylindrical_face_axis_mid_center(face_id, feature)
            if axis_data is None:
                notes.append(f"相邻圆柱Face {face_id} 缺少稳定中间轴心。")
                continue
            target_axis_center = _tuple_add(axis_data["current_axis_center"], movement)

            angular_span = _effective_cylinder_angular_span(face_feature_info)
            slot_kind = str(feature.get("slot_kind") or face_info.get("slot_kind") or "")
            if feature_guess == "hole/groove candidate":
                if not _is_effectively_full_cylinder(face_feature_info) and (
                    slot_kind == "partial-cylindrical-groove"
                    or (angular_span is not None and angular_span < math.tau * 0.92)
                ):
                    mode_order = ("slot", "hole")
                else:
                    mode_order = ("hole", "slot")
            elif feature_guess == "boss/outer-round candidate":
                mode_order = ("boss",)
            else:
                notes.append(f"相邻圆柱Face {face_id} 尚未明确识别为孔/槽或凸台。")
                continue

            for mode_index, mode in enumerate(mode_order):
                mode_label = {
                    "hole": "圆柱孔轴心",
                    "slot": "槽/半孔轴心",
                    "boss": "圆柱凸台轴心",
                }.get(mode, "相邻圆柱轴心")
                try:
                    axis_plan = (
                        self.cylindrical_slot_axis_move_plan(face_id, target_axis_center)
                        if mode == "slot"
                        else self.cylindrical_boss_axis_move_plan(face_id, target_axis_center)
                        if mode == "boss"
                        else self.cylindrical_axis_move_plan(face_id, target_axis_center)
                    )
                except Exception as exc:
                    notes.append(f"相邻圆柱Face {face_id} 的{mode_label}计划生成失败：{exc}")
                    continue

                plan_status = str(axis_plan.get("status", "blocked"))
                plan_risk = str(axis_plan.get("risk", "blocked"))
                if plan_status == "blocked":
                    notes.append(f"相邻圆柱Face {face_id} 的{mode_label}不可用：{axis_plan.get('message', '')}")
                    continue

                candidate = {
                    "circular_edge_cylinder_face_id": face_id,
                    "circular_edge_cylinder_mode": mode,
                    "circular_edge_cylinder_mode_label": mode_label,
                    "circular_edge_axis_operation": {
                        "hole": "move_cylindrical_hole_axis",
                        "slot": "move_cylindrical_slot_axis",
                        "boss": "move_cylindrical_boss_axis",
                    }[mode],
                    "circular_edge_target_axis_center": target_axis_center,
                    "current_axis_center": axis_plan.get("current_axis_center"),
                    "target_axis_center": axis_plan.get("target_axis_center"),
                    "axis_move_vector": axis_plan.get("axis_move_vector"),
                    "axis_move_distance": axis_plan.get("axis_move_distance"),
                    "axis_move_radial_distance": axis_plan.get("axis_move_radial_distance"),
                    "axis_move_axial_delta": axis_plan.get("axis_move_axial_delta"),
                    "target_diameter": axis_plan.get("target_diameter"),
                    "target_radius": axis_plan.get("target_radius"),
                    "move_axis_status": plan_status,
                    "move_axis_risk": plan_risk,
                    "move_axis_message": axis_plan.get("message"),
                    "move_axis_warnings": axis_plan.get("warnings", ""),
                    "move_axis_blockers": axis_plan.get("blockers", ""),
                    "move_axis_feature_guess": axis_plan.get("feature_guess", feature_guess),
                    "move_axis_confidence": axis_plan.get("confidence", face_info.get("confidence", "")),
                    "resize_strategy": "move-adjacent-cylinder-from-circular-edge-center",
                    "edit_strategy_label": f"通过{mode_label}移动圆Edge",
                    "edit_semantics": (
                        f"圆Edge圆心的目标移动量会转成相邻Face {face_id} 的{mode_label}移动；"
                        "这会重建局部孔/槽/凸台，不会整体平移零件。"
                    ),
                }
                score = (
                    status_rank.get(plan_status, 9),
                    risk_rank.get(plan_risk, 9),
                    mode_index,
                    face_id,
                )
                candidates.append((score, candidate))

        if not candidates:
            return None, notes
        candidates.sort(key=lambda item: item[0])
        return candidates[0][1], notes

    def _cylindrical_face_axis_mid_center(
        self,
        face_id: int,
        feature: dict[str, object] | None = None,
    ) -> dict[str, object] | None:
        if face_id < 0 or face_id >= len(self.faces):
            return None
        try:
            surf = BRepAdaptor_Surface(self.faces[face_id])
            if surf.GetType() != GeomAbs_Cylinder:
                return None
            if feature is None:
                feature = self.feature_info(face_id)
            cyl = surf.Cylinder()
            axis_range = self._cylindrical_axis_range(
                face_id,
                surf,
                _int_values((feature or {}).get("feature_side_face_ids")),
            )
            mid_parameter = (float(axis_range["v_min"]) + float(axis_range["v_max"])) * 0.5
            return {
                "current_axis_center": _point_tuple(_point_on_axis(cyl.Axis().Location(), cyl.Axis().Direction(), mid_parameter)),
                "axis_direction": _dir_tuple(cyl.Axis().Direction()),
                "same_domain_face_ids": axis_range.get("same_domain_face_ids", ()),
                "same_domain_face_count": axis_range.get("same_domain_face_count", 0),
                "same_domain_v_range": (axis_range.get("v_min"), axis_range.get("v_max")),
                "same_domain_range_source": axis_range.get("range_source", ""),
            }
        except Exception:
            return None

    def move_circular_edge_axis_center(
        self,
        edge_id: int,
        target_center: tuple[float, float, float],
    ) -> str:
        plan = self.circular_edge_axis_move_plan(edge_id, target_center)
        if plan["status"] == "blocked":
            raise ValueError(str(plan["message"]))

        face_id = int(plan.get("circular_edge_cylinder_face_id", -1))
        target_axis_center = _tuple_or_none(plan.get("target_axis_center"))
        mode = str(plan.get("circular_edge_cylinder_mode", ""))
        if face_id < 0 or target_axis_center is None:
            raise ValueError("圆Edge轴心移动缺少可执行的相邻圆柱Face或目标轴心。")

        if mode == "slot":
            delegated = self.move_cylindrical_slot_axis(face_id, target_axis_center)
        elif mode == "boss":
            delegated = self.move_cylindrical_boss_axis(face_id, target_axis_center)
        else:
            delegated = self.move_cylindrical_hole_axis(face_id, target_axis_center)

        return (
            "Circular Edge adjacent-cylinder axis move completed: "
            f"edge {edge_id}, face {face_id}, mode={plan.get('circular_edge_cylinder_mode_label')}, "
            f"edge_center={plan.get('current_edge_center')}->{plan.get('target_edge_center')}, "
            f"axis_center={plan.get('current_axis_center')}->{plan.get('target_axis_center')}. "
            f"{delegated}"
        )

    def _edge_length_affine_axis(
        self,
        edge_info: dict[str, object],
        anchor_mode: str = "auto",
    ) -> dict[str, object] | None:
        start = _tuple_or_none(edge_info.get("start_point"))
        end = _tuple_or_none(edge_info.get("end_point"))
        center = _tuple_or_none(edge_info.get("length_center"))
        anchor_mode = self._edge_length_anchor_mode(anchor_mode)
        if start is not None and end is not None:
            direction = _tuple_normalized(_tuple_sub(end, start))
            if direction is not None:
                midpoint = (
                    (start[0] + end[0]) * 0.5,
                    (start[1] + end[1]) * 0.5,
                    (start[2] + end[2]) * 0.5,
                )
                if anchor_mode == "keep-start":
                    axis_point = start
                    anchor_source = "edge start point"
                elif anchor_mode == "keep-end":
                    axis_point = end
                    anchor_source = "edge end point"
                else:
                    axis_point = center or midpoint
                    anchor_source = "edge center"
                return {
                    "axis_point": axis_point,
                    "axis_direction": direction,
                    "axis_source": "edge start/end chord",
                    "anchor_source": anchor_source,
                }
        bbox_min = _tuple_or_none(edge_info.get("bbox_min"))
        bbox_max = _tuple_or_none(edge_info.get("bbox_max"))
        if bbox_min is not None and bbox_max is not None:
            sizes = [abs(bbox_max[index] - bbox_min[index]) for index in range(3)]
            axis_index = max(range(3), key=lambda index: sizes[index])
            if sizes[axis_index] > 1e-9:
                direction = [0.0, 0.0, 0.0]
                direction[axis_index] = 1.0
                return {
                    "axis_point": center or (
                        (bbox_min[0] + bbox_max[0]) * 0.5,
                        (bbox_min[1] + bbox_max[1]) * 0.5,
                        (bbox_min[2] + bbox_max[2]) * 0.5,
                    ),
                    "axis_direction": tuple(direction),
                    "axis_source": "edge bounding-box longest axis",
                    "anchor_source": "edge bounding-box center",
                }
        return None

    def _planar_edge_length_scale_candidate(
        self,
        edge_info: dict[str, object],
        target_length: float,
    ) -> tuple[dict[str, object] | None, str]:
        curve = str(edge_info.get("curve", ""))
        if curve == "line":
            return None, ""
        current_length = float(edge_info.get("length", 0.0))
        if current_length <= 1e-9:
            return None, "平面曲线径向缩放不可用：当前Edge长度无效。"

        center = _tuple_or_none(edge_info.get("center"))
        axis = _tuple_normalized(_tuple_or_none(edge_info.get("axis")))
        axis_source = ""
        anchor_source = ""
        label = "围绕平面曲线法向径向缩放"
        sample_count: int | str = ""
        plane_deviation: float | str = ""
        if center is not None and axis is not None and curve in {"circle", "ellipse"}:
            axis_source = f"{curve} center/axis"
            anchor_source = f"{curve} center"
            label = "围绕圆边轴线径向缩放" if curve == "circle" else "围绕椭圆边法向径向缩放"
        else:
            frame, note = self._sampled_planar_edge_frame(edge_info)
            if frame is None:
                return None, note
            center = frame["center"]
            axis = frame["axis"]
            axis_source = "sampled edge best-fit plane"
            anchor_source = "sampled edge center"
            sample_count = int(frame["sample_count"])
            plane_deviation = float(frame["plane_deviation"])

        if center is None or axis is None:
            return None, "平面曲线径向缩放不可用：无法确定曲线中心或平面法向。"
        part_id = int(edge_info.get("part_id", -1))
        solid_id = int(edge_info.get("solid_id", -1))
        part = self.part_by_id(part_id) if part_id >= 0 else None
        if part is None:
            return None, "平面曲线径向缩放不可用：找不到所属零件。"
        part_solid_count = len(_explore(part.shape, TopAbs_SOLID))
        target_kind = "solid" if solid_id >= 0 and part_solid_count > 1 else "part"
        scale = float(target_length) / max(current_length, 1e-9)
        transform_risk = "high" if abs(scale - 1.0) > 0.25 or axis_source.startswith("sampled") else "medium"
        if curve == "circle":
            warning = (
                "圆边没有可复用的相邻圆柱直径编辑路径；将围绕圆边轴线对所属 "
                f"{target_kind} 做径向缩放，尽量保留轴向尺寸，但仍会影响同一 {target_kind} 上的其他径向尺寸。"
            )
        elif curve == "ellipse":
            warning = (
                "椭圆边将围绕自身平面法向对所属 "
                f"{target_kind} 做径向缩放，尽量保留法向尺寸，但会影响同一 {target_kind} 上的平面内其它尺寸。"
            )
        else:
            warning = (
                "当前非直线Edge可近似为平面曲线；将按采样平面法向对所属 "
                f"{target_kind} 做径向缩放。该路径依赖采样估算，执行后请复查周边尺寸。"
            )
        return (
            {
                "resize_strategy": "scale-owning-shape-from-edge",
                "affine_scale": scale,
                "affine_transform_kind": "radial-affine",
                "affine_transform_label": label,
                "affine_transform_note": "可能把解析圆/圆锥/圆柱/椭圆边面转换为 B-spline 几何。",
                "affine_transform_warning": warning,
                "affine_transform_risk": transform_risk,
                "affine_axis_point": center,
                "affine_axis_direction": axis,
                "affine_axis_source": axis_source,
                "affine_anchor_source": anchor_source,
                "affine_target_kind": target_kind,
                "part_solid_count": part_solid_count,
                "planar_edge_scale_sample_count": sample_count,
                "planar_edge_scale_plane_deviation": plane_deviation,
            },
            "",
        )

    def _sampled_planar_edge_frame(self, edge_info: dict[str, object]) -> tuple[dict[str, object] | None, str]:
        edge_id = int(edge_info.get("edge_id", -1))
        if edge_id < 0 or edge_id >= len(self.edges):
            return None, "平面曲线径向缩放不可用：Edge ID无效。"
        curve = BRepAdaptor_Curve(self.edges[edge_id])
        first = float(curve.FirstParameter())
        last = float(curve.LastParameter())
        if not math.isfinite(first) or not math.isfinite(last) or abs(last - first) <= 1e-12:
            return None, "平面曲线径向缩放不可用：Edge参数范围无效。"
        sample_count = 17
        points = [
            _point_tuple(curve.Value(first + (last - first) * index / (sample_count - 1)))
            for index in range(sample_count)
        ]
        distinct: list[tuple[float, float, float]] = []
        tolerance = max(float(edge_info.get("length", 0.0)) * 1e-7, _shape_diagonal(self.edges[edge_id]) * 1e-7, 1e-7)
        for point in points:
            if not any(_vector_length(_tuple_sub(point, existing)) <= tolerance for existing in distinct):
                distinct.append(point)
        if len(distinct) < 3:
            return None, "平面曲线径向缩放不可用：采样点不足以确定平面。"
        center = _tuple_or_none(edge_info.get("length_center"))
        if center is None:
            center = (
                sum(point[0] for point in distinct) / len(distinct),
                sum(point[1] for point in distinct) / len(distinct),
                sum(point[2] for point in distinct) / len(distinct),
            )
        normal = self._sampled_edge_plane_normal(distinct, center)
        if normal is None:
            return None, "平面曲线径向缩放不可用：采样点近似共线，无法确定平面法向。"
        plane_deviation = max(abs(_tuple_dot(_tuple_sub(point, center), normal)) for point in distinct)
        max_radius = max(_vector_length(_tuple_sub(point, center)) for point in distinct)
        allowed_deviation = max(max_radius * 1e-4, float(edge_info.get("length", 0.0)) * 1e-5, 1e-6)
        if plane_deviation > allowed_deviation:
            return None, (
                "平面曲线径向缩放不可用：Edge采样点不在稳定平面内，将使用更保守的缩放 fallback。"
            )
        return (
            {
                "center": center,
                "axis": normal,
                "sample_count": len(distinct),
                "plane_deviation": plane_deviation,
            },
            "",
        )

    def _sampled_edge_plane_normal(
        self,
        points: list[tuple[float, float, float]],
        center: tuple[float, float, float],
    ) -> tuple[float, float, float] | None:
        normal = (0.0, 0.0, 0.0)
        for index, point in enumerate(points):
            next_point = points[(index + 1) % len(points)]
            cross = _tuple_cross(_tuple_sub(point, center), _tuple_sub(next_point, center))
            normal = (
                normal[0] + cross[0],
                normal[1] + cross[1],
                normal[2] + cross[2],
            )
        normalized = _tuple_normalized(normal)
        if normalized is not None:
            return normalized
        best: tuple[float, float, float] | None = None
        best_length = 0.0
        count = len(points)
        for first_index in range(count - 2):
            for second_index in range(first_index + 1, count - 1):
                for third_index in range(second_index + 1, count):
                    candidate = _tuple_cross(
                        _tuple_sub(points[second_index], points[first_index]),
                        _tuple_sub(points[third_index], points[first_index]),
                    )
                    candidate_length = _vector_length(candidate)
                    if candidate_length > best_length:
                        best = candidate
                        best_length = candidate_length
        return _tuple_normalized(best)

    def ellipse_edge_axis_radius_plan(
        self,
        edge_id: int,
        target_radius: float,
        axis_kind: str = "major",
    ) -> dict[str, object]:
        if edge_id < 0 or edge_id >= len(self.edges):
            raise ValueError(f"Unknown edge id {edge_id}")
        info = self.edge_info(edge_id)
        axis_kind = "minor" if str(axis_kind).lower() in {"minor", "small", "y", "minor_radius"} else "major"
        radius_key = "minor_radius" if axis_kind == "minor" else "major_radius"
        direction_key = "minor_axis" if axis_kind == "minor" else "major_axis"
        axis_label = "小半径" if axis_kind == "minor" else "主半径"
        axis_direction_label = "小轴" if axis_kind == "minor" else "主轴"
        current_radius = _float_or_none(info.get(radius_key))
        other_radius = _float_or_none(info.get("major_radius" if axis_kind == "minor" else "minor_radius"))
        center = _tuple_or_none(info.get("center"))
        direction = _tuple_normalized(_tuple_or_none(info.get(direction_key)))
        other_direction = _tuple_normalized(
            _tuple_or_none(info.get("major_axis" if axis_kind == "minor" else "minor_axis"))
        )
        target_radius = float(target_radius)
        blockers: list[str] = []
        warnings: list[str] = [
            "椭圆Edge半径修改基于当前 STEP/B-Rep 结果几何；会对所属对象做单轴仿射缩放，不是恢复 CAD 草图约束。"
        ]
        risk = "medium"
        if info.get("curve") != "ellipse":
            blockers.append("当前Edge不是椭圆Edge。")
        if current_radius is None or current_radius <= 1e-9:
            blockers.append(f"当前椭圆Edge缺少稳定{axis_label}。")
        if other_radius is None or other_radius <= 1e-9:
            blockers.append("当前椭圆Edge缺少另一个半径，不能稳定校验结果。")
        if center is None:
            blockers.append("当前椭圆Edge缺少稳定中心。")
        if direction is None:
            blockers.append(f"当前椭圆Edge缺少稳定{axis_direction_label}方向。")
        if other_direction is None:
            blockers.append("当前椭圆Edge缺少另一个轴方向，不能稳定校验结果。")
        if target_radius <= 1e-9:
            blockers.append(f"椭圆Edge目标{axis_label}必须大于 0。")
        if current_radius is not None and current_radius > 0 and abs(target_radius - current_radius) <= max(current_radius * 1e-7, 1e-7):
            blockers.append(f"椭圆Edge目标{axis_label}与当前值几乎相同，不需要修改。")

        scale = target_radius / max(current_radius or 1.0, 1e-9)
        delta = None if current_radius is None else target_radius - current_radius
        delta_ratio = None if current_radius is None or current_radius <= 0 else abs(delta or 0.0) / current_radius
        if delta_ratio is not None:
            if delta_ratio > 0.5:
                risk = _max_risk(risk, "high")
                warnings.append(f"目标{axis_label}变化超过当前值的 50%，周边几何变形或修复失败的概率较高。")
            elif delta_ratio > 0.25:
                risk = _max_risk(risk, "medium")
                warnings.append(f"目标{axis_label}变化超过当前值的 25%，请确认建模意图。")

        part_id = int(info.get("part_id", -1))
        solid_id = int(info.get("solid_id", -1))
        part = self.part_by_id(part_id) if part_id >= 0 else None
        if part is None:
            blockers.append("找不到椭圆Edge所属零件。")
            part_solid_count = 0
            target_kind = "part"
        else:
            part_solid_count = len(_explore(part.shape, TopAbs_SOLID))
            target_kind = "solid" if solid_id >= 0 and part_solid_count > 1 else "part"

        if blockers:
            status = "blocked"
            risk = "blocked"
            message = " ".join(blockers)
        else:
            status = "caution" if risk != "low" else "ready"
            message = " ".join(warnings)

        target_major = target_radius if axis_kind == "major" else info.get("major_radius")
        target_minor = target_radius if axis_kind == "minor" else info.get("minor_radius")
        plan = {
            "edge_id": edge_id,
            "part_id": part_id,
            "solid_id": solid_id,
            "curve": info.get("curve"),
            "status": status,
            "risk": risk,
            "message": message,
            "warnings": "；".join(warnings),
            "blockers": "；".join(blockers),
            "resize_strategy": f"ellipse-edge-{axis_kind}-axis-affine",
            "edit_strategy_label": f"椭圆Edge{axis_label}单轴缩放",
            "edit_semantics": (
                f"沿椭圆{axis_direction_label}方向缩放所属 {target_kind}，让{axis_label}接近目标值；"
                "另一个半径方向尽量不动，但同一对象上的其它几何会受这个单轴缩放影响。"
            ),
            "ellipse_axis_kind": axis_kind,
            "ellipse_axis_label": axis_label,
            "ellipse_axis_direction_label": axis_direction_label,
            "ellipse_current_radius": current_radius,
            "ellipse_target_radius": target_radius,
            "ellipse_radius_delta": delta,
            "ellipse_radius_delta_ratio": delta_ratio,
            "ellipse_current_major_radius": info.get("major_radius"),
            "ellipse_target_major_radius": target_major,
            "ellipse_current_minor_radius": info.get("minor_radius"),
            "ellipse_target_minor_radius": target_minor,
            "affine_scale": scale,
            "affine_transform_kind": "axis-affine",
            "affine_transform_label": f"沿椭圆{axis_direction_label}单轴缩放",
            "affine_transform_note": "这会改变所属对象在该方向上的尺寸，可能把部分解析几何转换为 B-spline。",
            "affine_axis_point": center,
            "affine_axis_direction": direction,
            "ellipse_other_axis_direction": other_direction,
            "affine_axis_source": f"ellipse {axis_direction_label}",
            "affine_anchor_source": "ellipse center",
            "affine_target_kind": target_kind,
            "part_solid_count": part_solid_count,
        }
        plan.update(self._edge_first_level_plan_fields(edge_id))
        return plan

    def resize_ellipse_edge_axis_radius(
        self,
        edge_id: int,
        target_radius: float,
        axis_kind: str = "major",
    ) -> str:
        plan = self.ellipse_edge_axis_radius_plan(edge_id, target_radius, axis_kind=axis_kind)
        if plan["status"] == "blocked":
            raise ValueError(str(plan["message"]))
        self._apply_edge_length_affine_transform(plan)
        result_check = self._ellipse_edge_axis_radius_result_summary(plan)
        return (
            f"Ellipse Edge {plan['ellipse_axis_kind']} radius resize completed: "
            f"edge {edge_id}, "
            f"current_radius={float(plan['ellipse_current_radius']):g}, "
            f"target_radius={float(plan['ellipse_target_radius']):g}, "
            f"scale={float(plan['affine_scale']):g}, "
            f"target={plan.get('affine_target_kind')}, "
            f"risk={plan['risk']}. {result_check}"
        )

    def _ellipse_edge_axis_radius_result_summary(self, plan: dict[str, object]) -> str:
        axis_kind = str(plan.get("ellipse_axis_kind") or "major")
        radius_key = "minor_radius" if axis_kind == "minor" else "major_radius"
        target_radius = _float_or_none(plan.get("ellipse_target_radius"))
        if target_radius is None:
            return "Result check: target radius was unavailable."
        part_id = int(plan.get("part_id", -1))
        solid_id = int(plan.get("solid_id", -1))
        best: tuple[float, int, float, dict[str, object]] | None = None
        for candidate_edge_id in range(len(self.edges)):
            if part_id >= 0 and self.edge_part_ids[candidate_edge_id] != part_id:
                continue
            if solid_id >= 0 and self.edge_solid_ids[candidate_edge_id] != solid_id:
                continue
            info = self.edge_info(candidate_edge_id)
            if info.get("curve") != "ellipse":
                continue
            value = _float_or_none(info.get(radius_key))
            if value is None:
                continue
            error = abs(value - target_radius)
            if best is None or error < best[0]:
                best = (error, candidate_edge_id, value, info)
        if best is None:
            sampled = self._ellipse_edge_axis_radius_sampled_result(plan)
            if sampled is not None:
                candidate_edge_id, value, other_value, error = sampled
                return (
                    f"Result check: nearest_edge={candidate_edge_id}, sampled_{axis_kind}_radius={value:.6g}, "
                    f"target_error={error:.6g}, sampled_other_radius={other_value:.6g}; "
                    "the refreshed edge is no longer an analytic ellipse."
                )
            return "Result check: no ellipse-like Edge was recognized after the edit; inspect the refreshed B-Rep."
        error, candidate_edge_id, value, info = best
        other_key = "major_radius" if axis_kind == "minor" else "minor_radius"
        other_value = _float_or_none(info.get(other_key))
        return (
            f"Result check: nearest_edge={candidate_edge_id}, "
            f"nearest_{axis_kind}_radius={value:.6g}, "
            f"target_error={error:.6g}, "
            f"other_radius={other_value:.6g}."
            if other_value is not None
            else (
                f"Result check: nearest_edge={candidate_edge_id}, "
                f"nearest_{axis_kind}_radius={value:.6g}, target_error={error:.6g}."
            )
        )

    def _ellipse_edge_axis_radius_sampled_result(
        self,
        plan: dict[str, object],
    ) -> tuple[int, float, float, float] | None:
        center = _tuple_or_none(plan.get("affine_axis_point"))
        axis_direction = _tuple_normalized(_tuple_or_none(plan.get("affine_axis_direction")))
        other_direction = _tuple_normalized(_tuple_or_none(plan.get("ellipse_other_axis_direction")))
        target_radius = _float_or_none(plan.get("ellipse_target_radius"))
        if center is None or axis_direction is None or other_direction is None or target_radius is None:
            return None
        part_id = int(plan.get("part_id", -1))
        solid_id = int(plan.get("solid_id", -1))
        best: tuple[int, float, float, float] | None = None
        for edge_id in range(len(self.edges)):
            if part_id >= 0 and self.edge_part_ids[edge_id] != part_id:
                continue
            if solid_id >= 0 and self.edge_solid_ids[edge_id] != solid_id:
                continue
            extents = self._sample_edge_axis_extents(edge_id, center, axis_direction, other_direction)
            if extents is None:
                continue
            axis_radius, other_radius = extents
            error = abs(axis_radius - target_radius)
            if best is None or error < best[3]:
                best = (edge_id, axis_radius, other_radius, error)
        return best

    def _sample_edge_axis_extents(
        self,
        edge_id: int,
        center: tuple[float, float, float],
        axis_direction: tuple[float, float, float],
        other_direction: tuple[float, float, float],
    ) -> tuple[float, float] | None:
        if edge_id < 0 or edge_id >= len(self.edges):
            return None
        curve = BRepAdaptor_Curve(self.edges[edge_id])
        first = float(curve.FirstParameter())
        last = float(curve.LastParameter())
        if not math.isfinite(first) or not math.isfinite(last) or abs(last - first) <= 1e-12:
            return None
        sample_count = 1025
        axis_extent = 0.0
        other_extent = 0.0
        for index in range(sample_count):
            parameter = first + (last - first) * index / (sample_count - 1)
            point = _point_tuple(curve.Value(parameter))
            relative = _tuple_sub(point, center)
            axis_extent = max(axis_extent, abs(_tuple_dot(relative, axis_direction)))
            other_extent = max(other_extent, abs(_tuple_dot(relative, other_direction)))
        if axis_extent <= 1e-9 and other_extent <= 1e-9:
            return None
        return axis_extent, other_extent

    def straight_edge_length_plan(self, edge_id: int, target_length: float) -> dict[str, object]:
        return self.general_edge_length_plan(edge_id, target_length, anchor_mode="auto")

    def _straight_edge_length_end_face_candidate(
        self,
        edge_info: dict[str, object],
        delta_length: float,
        anchor_mode: str = "auto",
    ) -> dict[str, object] | None:
        start = _tuple_or_none(edge_info.get("start_point"))
        end = _tuple_or_none(edge_info.get("end_point"))
        if start is None or end is None:
            return None
        axis = _tuple_normalized(_tuple_sub(end, start))
        if axis is None:
            return None
        solid_id = int(edge_info.get("solid_id", -1))
        if solid_id < 0 or solid_id >= len(self.solids):
            return None
        solid = self.solids[solid_id][1]
        tolerance = max(_shape_diagonal(solid) * 1e-5, abs(delta_length) * 1e-5, 1e-4)
        candidates: list[tuple[float, dict[str, object]]] = []
        anchor_mode = self._edge_length_anchor_mode(anchor_mode)
        if anchor_mode == "keep-start":
            endpoint_specs = [("end", "终点端", end, _tuple_scale(axis, delta_length))]
        elif anchor_mode == "keep-end":
            endpoint_specs = [("start", "起点端", start, _tuple_scale(axis, -delta_length))]
        elif anchor_mode == "center":
            endpoint_specs = []
        else:
            endpoint_specs = [
                ("start", "起点端", start, _tuple_scale(axis, -delta_length)),
                ("end", "终点端", end, _tuple_scale(axis, delta_length)),
            ]

        for endpoint_role, endpoint_label, endpoint, desired_vector in endpoint_specs:
            desired_unit = _tuple_normalized(desired_vector)
            if desired_unit is None:
                continue
            for face_id, face in enumerate(self.faces):
                if self.face_solid_ids[face_id] != solid_id:
                    continue
                surf = BRepAdaptor_Surface(face)
                if surf.GetType() != GeomAbs_Plane:
                    continue
                plane = surf.Plane()
                plane_origin = _point_tuple(plane.Location())
                plane_normal = _tuple_normalized(_dir_tuple(plane.Axis().Direction()))
                if plane_normal is None:
                    continue
                plane_distance = abs(_tuple_dot(_tuple_sub(endpoint, plane_origin), plane_normal))
                if plane_distance > tolerance:
                    continue
                axis_alignment = abs(_tuple_dot(plane_normal, axis))
                if axis_alignment < 0.82:
                    continue
                face_info = self.face_info(face_id)
                outward = _tuple_normalized(_tuple_or_none(face_info.get("push_pull_outward_direction")))
                if outward is None:
                    continue
                movement_alignment = abs(_tuple_dot(outward, desired_unit))
                if movement_alignment < 0.82:
                    continue
                push_pull_distance = _tuple_dot(desired_vector, outward)
                if abs(push_pull_distance) <= 1e-9:
                    continue
                confidence_bonus = 0.0 if face_info.get("push_pull_confidence") == "high" else 0.2
                score = plane_distance / max(tolerance, 1e-9) + (1.0 - movement_alignment) + confidence_bonus
                candidates.append(
                    (
                        score,
                        {
                            "end_face_id": face_id,
                            "end_face_endpoint_role": endpoint_role,
                            "end_face_label": endpoint_label,
                            "end_face_plane_distance": plane_distance,
                            "end_face_axis_alignment": axis_alignment,
                            "end_face_movement_alignment": movement_alignment,
                            "end_face_outward_direction": outward,
                            "end_face_push_pull_confidence": face_info.get("push_pull_confidence", ""),
                            "push_pull_distance": push_pull_distance,
                            "desired_movement_vector": desired_vector,
                        },
                    )
                )
        if not candidates:
            return None
        candidates.sort(key=lambda item: item[0])
        return candidates[0][1]

    def existing_fillet_resize_plan(self, face_id: int, target_radius: float) -> dict[str, object]:
        if face_id < 0 or face_id >= len(self.faces):
            raise ValueError(f"Unknown face id {face_id}")
        info = self.face_info(face_id)
        if info.get("surface") != "cylinder" or "radius" not in info:
            return {
                "status": "blocked",
                "risk": "blocked",
                "message": "当前选中的 Face 不是圆柱圆角面，不能修改已有圆角半径。",
                "blockers": "当前选中的 Face 不是圆柱圆角面。",
                "warnings": "",
                "face_id": face_id,
            }

        feature = self.feature_info(face_id)
        feature_guess = str(info.get("feature_guess", ""))
        current_radius = float(feature.get("existing_fillet_radius_estimate", info["radius"]))
        support_face_ids = tuple(feature.get("feature_existing_fillet_support_face_ids", ()))
        warnings: list[str] = []
        blockers: list[str] = []
        risk = "medium"
        status = "caution"

        if feature_guess != "round/fillet candidate":
            blockers.append("当前圆柱面没有被识别为已有圆角/倒圆候选。")
        if target_radius <= 0:
            blockers.append("目标圆角半径必须大于 0。")
        if current_radius <= 0:
            blockers.append("当前圆角半径估算无效。")
        if current_radius > 0 and abs(target_radius - current_radius) <= max(current_radius * 1e-5, 1e-6):
            blockers.append("目标圆角半径与当前估算半径几乎相同，不需要修改。")
        if len(support_face_ids) < 2:
            blockers.append("当前版本只对识别到至少两个支撑Face的已有圆角候选开放。")

        part_id = int(info.get("part_id", -1))
        part_stats = None
        try:
            part_stats = self.part_topology_stats(part_id)
        except Exception:
            part_stats = None
        if part_stats is not None and part_stats.solids != 1:
            blockers.append(
                f"当前零件包含 {part_stats.solids} 个Solid；已有圆角半径修改当前版本只对单Solid零件开放。"
            )

        height_estimate = float(info.get("height_estimate", 0.0))
        angular_span = float(info.get("angular_span", 0.0))
        radius_delta = target_radius - current_radius
        radius_delta_ratio = abs(radius_delta) / max(current_radius, 1e-9)
        if not blockers:
            if radius_delta_ratio > 1.0:
                risk = "high"
                warnings.append("目标半径变化超过当前半径的 100%，defeature/refillet 很可能失败。")
            elif radius_delta_ratio > 0.35:
                risk = _max_risk(risk, "high")
                warnings.append("目标半径变化超过当前半径的 35%，请谨慎检查结果。")
            if height_estimate > 0 and target_radius > height_estimate * 0.5:
                risk = _max_risk(risk, "high")
                warnings.append("目标半径超过圆角长度估算的一半，几何比例异常。")
            if angular_span > math.pi * 1.25:
                risk = _max_risk(risk, "high")
                warnings.append("当前圆角圆弧跨度较大，可能不是普通边圆角。")
            if str(info.get("confidence", "low")) != "high":
                warnings.append("已有圆角识别置信度不是 high，执行结果需要重点检查。")

        if blockers:
            status = "blocked"
            risk = "blocked"
            message = " ".join(blockers + warnings)
        else:
            message = "将尝试先移除已有圆角面，再在恢复出的锐边上按目标半径重新倒圆。"
            if warnings:
                message += " " + " ".join(warnings)

        return {
            "status": status,
            "risk": risk,
            "message": message,
            "warnings": "；".join(warnings),
            "blockers": "；".join(blockers),
            "face_id": face_id,
            "part_id": info.get("part_id"),
            "solid_id": info.get("solid_id"),
            "feature_type": feature.get("feature_type"),
            "feature_guess": feature_guess,
            "confidence": info.get("confidence"),
            "current_radius": current_radius,
            "target_radius": target_radius,
            "delta_radius": radius_delta,
            "radius_delta_ratio": radius_delta_ratio,
            "height_estimate": info.get("height_estimate"),
            "angular_span": info.get("angular_span"),
            "axis_point": info.get("axis_point"),
            "axis": info.get("axis"),
            "feature_existing_fillet_support_face_ids": support_face_ids,
            "feature_boundary_edge_ids": feature.get("feature_boundary_edge_ids"),
            "resize_strategy": "defeature-existing-fillet-face-then-refillet-axis-edge",
            "edit_strategy_label": "移除旧圆角并重新倒圆",
            "edit_semantics": "先移除当前已有圆角面，再在恢复出的锐边上按目标半径重新倒圆；复杂 blend 可能失败并回滚。",
            "resize_note": (
                "当前版本的已有圆角半径修改只支持由圆柱面表示的直线边圆角。"
                "执行后 Face/Edge ID 会重建，请重新选择对象确认结果。"
            ),
        }

    def _push_pull_inward_material_depth(
        self,
        face_id: int,
        outward: tuple[float, float, float] | None,
    ) -> float | None:
        if face_id < 0 or face_id >= len(self.faces):
            return None
        direction = _tuple_normalized(outward)
        if direction is None:
            return None
        solid_id = self.face_solid_ids[face_id]
        if solid_id < 0 or solid_id >= len(self.solids):
            return None
        try:
            props = GProp_GProps()
            brepgprop.SurfaceProperties(self.faces[face_id], props)
            interval = _shape_axis_interval(self.solids[solid_id][1], props.CentreOfMass(), gp_Dir(*direction))
        except Exception:
            return None
        if interval is None:
            return None
        inward_depth = max(-float(interval[0]), 0.0)
        return inward_depth if inward_depth > 1e-9 else None

    def _push_pull_plan_face_info(
        self,
        face_id: int,
        surf: BRepAdaptor_Surface,
    ) -> dict[str, object]:
        quick_info = self.quick_face_info(face_id)
        cap_direction = self._cylindrical_cap_push_pull_direction(face_id, surf)
        if cap_direction is not None:
            info = dict(quick_info)
            info.update(cap_direction)
            return info
        return self.face_info(face_id)

    def push_pull_plan(self, face_id: int, distance: float) -> dict[str, object]:
        if face_id < 0 or face_id >= len(self.faces):
            raise ValueError(f"Unknown face id {face_id}")
        face = self.faces[face_id]
        surf = BRepAdaptor_Surface(face)
        if surf.GetType() != GeomAbs_Plane:
            return {
                "status": "blocked",
                "risk": "blocked",
                "message": "当前选中的 Face 不是平面，不能执行拉伸/切除平面。",
                "blockers": "当前选中的 Face 不是平面。",
                "warnings": "",
                "face_id": face_id,
                "part_id": self.face_part_ids[face_id],
                "solid_id": self.face_solid_ids[face_id],
                "distance": distance,
            }

        info = self._push_pull_plan_face_info(face_id, surf)
        first_level_fields = self._face_first_level_plan_fields(face_id)
        scope_face_ids = self._connected_coplanar_planar_face_ids(face_id)
        scope_area = 0.0
        for scope_face_id in scope_face_ids:
            try:
                scope_area += float(self.quick_face_info(scope_face_id).get("area") or 0.0)
            except Exception:
                try:
                    scope_area += float(self.face_info(scope_face_id).get("area") or 0.0)
                except Exception:
                    pass
        if len(scope_face_ids) > 1:
            scope_note = f"将一起拉伸/切除 {len(scope_face_ids)} 个共面且相接/重叠的Face，减少 STEP 碎面导致的贴块缝。"
        else:
            scope_note = "只拉伸/切除当前 Face。"
        direction_confidence = str(info.get("push_pull_confidence", "low"))
        bbox_diagonal = float(info.get("bbox_diagonal", 0.0))
        distance_abs = abs(distance)
        face_distance_ratio = distance_abs / bbox_diagonal if bbox_diagonal > 1e-9 else None
        plane_origin = _tuple_or_none(info.get("plane_origin"))
        outward_direction = _tuple_normalized(_tuple_or_none(info.get("push_pull_outward_direction")))
        owning_axis_span: float | None = None
        distance_to_owning_axis_span_ratio: float | None = None
        if distance > 0 and plane_origin is not None and outward_direction is not None:
            source_shape = None
            solid_id_for_extent = _int_or_none(info.get("solid_id"))
            if solid_id_for_extent is not None and 0 <= solid_id_for_extent < len(self.solids):
                source_shape = self.solids[solid_id_for_extent][1]
            else:
                part_id_for_extent = _int_or_none(info.get("part_id"))
                part_for_extent = self.part_by_id(part_id_for_extent) if part_id_for_extent is not None else None
                source_shape = part_for_extent.shape if part_for_extent is not None else None
            if source_shape is not None:
                try:
                    axis_interval = _shape_axis_interval(
                        source_shape,
                        gp_Pnt(*plane_origin),
                        gp_Dir(*outward_direction),
                    )
                except Exception:
                    axis_interval = None
                if axis_interval is not None:
                    owning_axis_span = max(float(axis_interval[1]) - float(axis_interval[0]), 0.0)
                    if owning_axis_span > 1e-9:
                        distance_to_owning_axis_span_ratio = distance_abs / owning_axis_span
        warnings: list[str] = []
        blockers: list[str] = []
        risk = "low"
        status = "ready"
        inward_material_depth = (
            self._push_pull_inward_material_depth(
                face_id,
                outward_direction,
            )
            if distance < 0
            else None
        )
        inward_cut_ratio = (
            distance_abs / inward_material_depth
            if distance < 0 and inward_material_depth is not None and inward_material_depth > 1e-9
            else None
        )

        if distance_abs <= 1e-9:
            status = "blocked"
            risk = "blocked"
            blockers.append("拉伸/切除距离为 0，不需要修改。")
        if direction_confidence != "high":
            risk = _max_risk(risk, "medium")
            warnings.append("拉伸/切除方向判断置信度较低，可能不是期望的内外方向。")
        if bbox_diagonal > 0 and distance_abs > bbox_diagonal * 5.0:
            risk = "blocked"
            status = "blocked"
            blockers.append("拉伸/切除距离超过当前 Face 尺寸的 5 倍，容易生成过大布尔体或影响无关几何。")
        elif bbox_diagonal > 0 and distance_abs > bbox_diagonal * 0.2:
            risk = _max_risk(risk, "high")
            warnings.append("拉伸/切除距离超过当前 Face 包围盒对角线的 20%，容易导致布尔失败或大范围变形。")
        elif bbox_diagonal > 0 and distance_abs > bbox_diagonal * 0.08:
            risk = _max_risk(risk, "medium")
            warnings.append("拉伸/切除距离相对当前 Face 尺寸偏大，请确认预览范围。")

        if inward_cut_ratio is not None and inward_material_depth is not None:
            depth_tolerance = max(
                inward_material_depth * 1e-5,
                bbox_diagonal * 1e-7 if bbox_diagonal > 0 else 0.0,
                1e-6,
            )
            if distance_abs >= inward_material_depth - depth_tolerance:
                status = "blocked"
                risk = "blocked"
                blockers.append(
                    "向内切削距离达到或超过当前面背后的材料厚度；继续执行很可能把实体切空或生成无效几何。"
                )
            elif inward_cut_ratio >= 0.85:
                risk = _max_risk(risk, "high")
                warnings.append("向内切削距离已经接近当前面背后的材料厚度，剩余壁厚很薄，请谨慎确认。")
            elif inward_cut_ratio >= 0.6:
                risk = _max_risk(risk, "medium")
                warnings.append("向内切削距离超过当前面背后材料厚度的 60%，请确认不会切穿。")

        cap_extension_info: dict[str, object] | None = None
        if abs(distance) > 1e-9:
            outward_for_cap = outward_direction
            if outward_for_cap is not None:
                try:
                    cap_extension_info = self._cylindrical_cap_extension_plan(face_id, distance, outward_for_cap)
                except Exception:
                    cap_extension_info = None
        if cap_extension_info is not None:
            old_height = _float_or_none(cap_extension_info.get("old_height"))
            new_height = _float_or_none(cap_extension_info.get("new_height"))
            radius = _float_or_none(cap_extension_info.get("radius"))
            extra_adjacent_count = int(cap_extension_info.get("cap_extra_adjacent_face_count") or 0)
            if extra_adjacent_count > 0:
                cap_method = str(cap_extension_info.get("cap_extension_method") or "")
                if cap_method == "cap-profile-prism" and distance > 0:
                    risk = _max_risk(risk, "high")
                    warnings.append(
                        "已识别为圆柱/筒体端盖，端面边界还连接了槽、缺口或台阶等额外一级相邻 Face；"
                        "本次向外拉伸会改用当前端盖真实轮廓拉伸，让这些开口边界跟随延长，避免通用大布尔长时间计算。"
                    )
                elif cap_method == "cap-profile-prism":
                    risk = _max_risk(risk, "high")
                    warnings.append(
                        "已识别为圆柱/筒体端盖，端面边界还连接了槽、缺口或台阶等额外一级相邻 Face；"
                        "本次向内切除没有越过这些开口的内侧终点，会改用当前端盖真实轮廓切削，让开口边界跟随缩短。"
                    )
                else:
                    status = "blocked"
                    risk = "blocked"
                    target_parameter = _float_or_none(cap_extension_info.get("cap_profile_prism_target_parameter"))
                    limit_parameter = _float_or_none(cap_extension_info.get("cap_profile_prism_retract_limit_parameter"))
                    limit_text = ""
                    if target_parameter is not None and limit_parameter is not None:
                        limit_text = (
                            f"目标端面轴向位置约 {_format_result_number(target_parameter)}，"
                            f"额外开口内侧终点约 {_format_result_number(limit_parameter)}；"
                        )
                    blockers.append(
                        "已识别为圆柱/筒体端盖，但端面边界还连接了槽、缺口或台阶等额外一级相邻 Face；"
                        f"{limit_text}"
                        "本次向内切除会越过这些开口/台阶的内侧终点，当前版本还不能判断槽底或台阶是否应一起移动。"
                        "已快速阻止，避免留下残余台阶、长时间布尔或丢失这些特征。"
                    )
            simple_cap_rebuild = self._simple_cylindrical_cap_extension_rebuild_available(
                face_id,
                cap_extension_info,
            )
            growth_ratio = (
                new_height / old_height
                if old_height is not None and old_height > 1e-9 and new_height is not None
                else None
            )
            distance_to_height_ratio = (
                distance_abs / old_height if old_height is not None and old_height > 1e-9 else None
            )
            if status != "blocked":
                if distance < 0 and growth_ratio is not None and growth_ratio < 0.2:
                    risk = _max_risk(risk, "high")
                    warnings.append(
                        "当前圆柱/筒体端面向内切除后剩余高度低于原高度的 20%；"
                        "已识别端盖一级关系，执行时会优先切除旧端盖到新端盖之间的局部段。"
                    )
                elif distance < 0:
                    if str(cap_extension_info.get("cap_extension_method") or "") == "cap-profile-prism":
                        warnings.append(
                            "已识别圆柱/筒体端盖一级关系，向内切除会优先走端盖真实轮廓切削，"
                            "避免通用大范围 prism 切削过慢。"
                        )
                    else:
                        warnings.append(
                            "已识别圆柱/筒体端盖一级关系，向内切除会优先切除旧端盖到新端盖之间的局部段，"
                            "避免通用平面 prism 切削过慢。"
                        )
                elif growth_ratio is not None and growth_ratio > 3.0 and simple_cap_rebuild:
                    risk = _max_risk(risk, "high")
                    warnings.append(
                        "当前圆柱端面会一次性加长很多；已识别为简单圆柱/筒体端盖，执行时会优先走解析重建，"
                        "避免通用布尔长时间计算。"
                    )
                elif growth_ratio is not None and growth_ratio > 3.0:
                    risk = _max_risk(risk, "high")
                    warnings.append(
                        "当前操作会把圆柱高度一次性放大到原来的 "
                        f"{_format_result_number(growth_ratio)} 倍；已识别为圆柱/筒体端盖一级关系，执行时会只生成旧端盖到新端盖之间的局部延长段，"
                        "避免拿整根新圆柱做布尔。复杂 STEP 上仍建议检查结果。"
                    )
                elif distance_to_height_ratio is not None and distance_to_height_ratio > 1.0:
                    risk = _max_risk(risk, "high")
                    warnings.append(
                        "当前圆柱端面拉伸/切除距离已经超过圆柱原高度，布尔延长可能较慢；建议优先小幅修改。"
                    )
                elif radius is not None and radius > 0 and distance_abs > radius * 4.0:
                    risk = _max_risk(risk, "high")
                    warnings.append(
                        "当前圆柱端面拉伸/切除距离明显大于圆柱半径，可能生成很长的补料体；建议优先小幅修改。"
                    )

        boundary_shell_extension_info: dict[str, object] | None = None
        if status != "blocked" and cap_extension_info is None and outward_direction is not None:
            boundary_shell_extension_info = self._planar_cap_boundary_shell_extension_plan(
                face_id,
                float(distance),
                outward_direction,
                scope_face_ids,
            )
            if boundary_shell_extension_info is not None:
                risk = _max_risk(risk, "medium")
                if distance > 0.0:
                    warnings.append(
                        "已识别为带内孔/多边界的平面端盖；本次向外拉伸会移动当前端面，"
                        "并沿所有一级边界 Edge 生成延长侧壁后局部缝合，避免复杂 STEP 的通用布尔长时间计算。"
                    )
                else:
                    warnings.append(
                        "已识别为带内孔/多边界的平面端盖；本次向内收缩会移动当前端面，"
                        "并沿所有一级边界 Edge 重建侧壁后局部缝合，避免复杂 STEP 的通用布尔长时间计算。"
                    )

        if (
            status != "blocked"
            and cap_extension_info is None
            and boundary_shell_extension_info is None
            and len(self.faces) > 600
            and int(info.get("inner_boundary_wires", 0) or 0) > 0
            and distance < 0.0
        ):
            status = "blocked"
            risk = "blocked"
            first_level_adjacent = int(first_level_fields.get("first_level_adjacent_face_count", 0) or 0)
            first_level_edges = int(first_level_fields.get("first_level_boundary_edge_count", 0) or 0)
            inner_wires = int(info.get("inner_boundary_wires", 0) or 0)
            blockers.append(
                f"当前 Face {face_id} 是复杂大 STEP 中带内孔/多边界的平面端盖："
                f"内边界 {inner_wires} 个，一级边界 Edge {first_level_edges} 条，"
                f"共享边一级相邻 Face {first_level_adjacent} 个。"
                "但没有识别到可安全向内切削的端盖一级关系。"
                "向内切除这类面通常需要判断孔壁、槽底、台阶内侧终点或其它相邻特征是否一起移动，"
                "这已经涉及一级相邻面背后的二级关系；当前阶段只自动处理一级关系。"
                "已快速阻止，避免进入通用 OCCT 布尔后长时间卡住、超时或生成无效 B-Rep。"
            )

        if status != "blocked" and cap_extension_info is None:
            if distance > 0 and (
                (
                    distance_to_owning_axis_span_ratio is not None
                    and distance_to_owning_axis_span_ratio > 1.0
                )
                or (face_distance_ratio is not None and face_distance_ratio > 0.6)
            ):
                risk = _max_risk(risk, "high")
                warnings.append(
                    "本次向外拉伸距离相对当前 Face 或所属实体跨度较大，可能需要较长 OCCT 布尔计算；"
                    "程序会在隔离子进程中执行，并在失败时保持原模型不变。"
                )
            elif (
                distance > 0
                and distance_to_owning_axis_span_ratio is not None
                and distance_to_owning_axis_span_ratio > 0.6
            ):
                risk = _max_risk(risk, "high")
                warnings.append(
                    "本次向外拉伸距离已经超过所属实体当前法向跨度的 60%，布尔延长可能较慢；"
                    "建议优先小幅修改。"
                )

        if risk in {"medium", "high"} and status != "blocked":
            status = "caution"
        if blockers:
            message = " ".join(blockers + warnings)
        elif warnings:
            message = " ".join(warnings)
        else:
            message = "可以尝试拉伸/切除该平面。"

        plane_origin = _tuple_or_none(info.get("plane_origin"))
        outward_direction = _tuple_normalized(_tuple_or_none(info.get("push_pull_outward_direction")))
        current_plane_position = None
        target_plane_position = None
        if plane_origin is not None and outward_direction is not None:
            current_plane_position = _tuple_dot(plane_origin, outward_direction)
            target_plane_position = current_plane_position + float(distance)

        return {
            "status": status,
            "risk": risk,
            "message": message,
            "warnings": "；".join(warnings),
            "blockers": "；".join(blockers),
            "face_id": face_id,
            "part_id": info["part_id"],
            "solid_id": info["solid_id"],
            **first_level_fields,
            "distance": distance,
            "surface": info.get("surface"),
            "area": info.get("area"),
            "bbox_diagonal": info.get("bbox_diagonal"),
            "push_pull_distance_to_face_diagonal_ratio": face_distance_ratio,
            "push_pull_owning_axis_span": owning_axis_span,
            "push_pull_distance_to_owning_axis_span_ratio": distance_to_owning_axis_span_ratio,
            "plane_origin": plane_origin,
            "plane_direction": outward_direction,
            "current_plane_position": current_plane_position,
            "target_plane_position": target_plane_position,
            "push_pull_inward_material_depth": inward_material_depth,
            "push_pull_inward_cut_ratio": inward_cut_ratio,
            "cylindrical_cap_extension_old_height": (
                cap_extension_info.get("old_height") if cap_extension_info is not None else None
            ),
            "cylindrical_cap_extension_new_height": (
                cap_extension_info.get("new_height") if cap_extension_info is not None else None
            ),
            "cylindrical_cap_extension_radius": (
                cap_extension_info.get("radius") if cap_extension_info is not None else None
            ),
            "cylindrical_cap_extension_inner_radius": (
                cap_extension_info.get("inner_radius") if cap_extension_info is not None else None
            ),
            "cylindrical_cap_extension_kind": (
                cap_extension_info.get("cap_extension_kind") if cap_extension_info is not None else None
            ),
            "cylindrical_cap_operation": (
                cap_extension_info.get("cap_operation") if cap_extension_info is not None else None
            ),
            "cylindrical_cap_extension_height": (
                cap_extension_info.get("extension_height") if cap_extension_info is not None else None
            ),
            "cylindrical_cap_extension_uses_local_segment": bool(
                cap_extension_info is not None and cap_extension_info.get("extension_shape") is not None
            ),
            "cylindrical_cap_extension_method": (
                cap_extension_info.get("cap_extension_method") if cap_extension_info is not None else None
            ),
            "cap_extra_adjacent_face_ids": (
                cap_extension_info.get("cap_extra_adjacent_face_ids") if cap_extension_info is not None else ()
            ),
            "cap_extra_adjacent_face_count": (
                cap_extension_info.get("cap_extra_adjacent_face_count") if cap_extension_info is not None else 0
            ),
            "cap_scope_face_ids": (
                cap_extension_info.get("cap_scope_face_ids") if cap_extension_info is not None else ()
            ),
            "cap_profile_prism_target_parameter": (
                cap_extension_info.get("cap_profile_prism_target_parameter") if cap_extension_info is not None else None
            ),
            "cap_profile_prism_retract_limit_parameter": (
                cap_extension_info.get("cap_profile_prism_retract_limit_parameter") if cap_extension_info is not None else None
            ),
            "planar_cap_extension_kind": (
                (boundary_shell_extension_info or {}).get("cap_extension_kind")
            ),
            "planar_cap_extension_method": (
                (boundary_shell_extension_info or {}).get("cap_extension_method")
            ),
            "planar_cap_boundary_edge_count": int(
                (boundary_shell_extension_info or {}).get("cap_boundary_edge_count") or 0
            ),
            "planar_cap_bridge_face_count": int(
                (boundary_shell_extension_info or {}).get("bridge_face_count") or 0
            ),
            "planar_cap_inner_boundary_wires": int(
                (boundary_shell_extension_info or {}).get("inner_boundary_wires") or 0
            ),
            "planar_cap_adjacent_face_count": int(
                (boundary_shell_extension_info or {}).get("adjacent_face_count") or 0
            ),
            "outward_direction": outward_direction,
            "direction_confidence": direction_confidence,
            "direction_note": info.get("push_pull_note"),
            "push_pull_scope_face_ids": tuple(scope_face_ids),
            "push_pull_scope_face_count": len(scope_face_ids),
            "push_pull_scope_area": scope_area,
            "push_pull_scope_note": scope_note,
        }

    def face_plane_offset_frame(
        self,
        face_id: int,
    ) -> tuple[tuple[float, float, float], tuple[float, float, float], float] | None:
        if face_id < 0 or face_id >= len(self.faces):
            return None
        info = self.quick_face_info(face_id)
        if str(info.get("surface", "")) != "plane":
            return None
        origin = _tuple_or_none(info.get("plane_origin"))
        direction = (
            _tuple_normalized(_tuple_or_none(info.get("push_pull_outward_direction")))
            or _tuple_normalized(_tuple_or_none(info.get("oriented_normal")))
            or _tuple_normalized(_tuple_or_none(info.get("normal")))
        )
        if origin is None or direction is None:
            return None
        current_position = _tuple_dot(origin, direction)
        return origin, direction, current_position

    def face_plane_offset_local_plan(self, face_id: int, distance: float) -> dict[str, object]:
        try:
            distance = float(distance)
        except (TypeError, ValueError):
            distance = 0.0
            frame = None
            blockers = ["目标偏移变换位置必须是数字。"]
        else:
            frame = self.face_plane_offset_frame(face_id)
            blockers = []

        if face_id < 0 or face_id >= len(self.faces):
            blockers.append(f"Unknown face id {face_id}")
        if frame is None:
            blockers.append("当前 Face 缺少稳定平面方向或基准点，不能执行偏移变换(局部重建)。")

        current_center = None
        target_center = None
        if 0 <= face_id < len(self.faces):
            info = self.face_info(face_id)
            current_center = _tuple_or_none(info.get("area_center")) or _tuple_or_none(info.get("bbox_center"))
        if current_center is None:
            blockers.append("当前 Face 缺少稳定中心坐标。")

        plane_origin = None
        plane_direction = None
        current_position = None
        target_position = None
        if frame is not None:
            plane_origin, plane_direction, current_position = frame
            target_position = current_position + distance
        if current_center is not None and plane_direction is not None:
            move_vector = _tuple_scale(plane_direction, distance)
            target_center = _tuple_add(current_center, move_vector)
        else:
            move_vector = (0.0, 0.0, 0.0)

        if blockers:
            return {
                "status": "blocked",
                "risk": "blocked",
                "message": " ".join(blockers),
                "warnings": "",
                "blockers": "；".join(blockers),
                "face_id": face_id,
                "current_plane_position": current_position,
                "target_plane_position": target_position,
                "plane_origin": plane_origin,
                "plane_direction": plane_direction,
                "plane_offset_distance": distance,
                "current_face_center": current_center,
                "target_face_center": target_center,
                "face_center_move_vector": move_vector,
                "resize_strategy": "local-face-plane-offset-deform",
                "edit_strategy_label": "偏移变换(局部重建)",
                "edit_semantics": "把目标偏移变换位置换算成沿当前面垂直方向的移动量，移动当前 Face 并重建相邻平面。",
            }

        plan = self.face_center_local_move_plan(face_id, target_center)
        plan.update(
            {
                "current_plane_position": current_position,
                "target_plane_position": target_position,
                "plane_origin": plane_origin,
                "plane_direction": plane_direction,
                "plane_offset_distance": distance,
                "resize_strategy": "local-face-plane-offset-deform",
                "edit_strategy_label": "偏移变换(局部重建)",
                "edit_semantics": (
                    "把目标偏移变换位置换算成沿当前面垂直方向的移动量，移动当前 Face 的顶点并重建相邻平面；"
                    "不拉伸/切除加料/切削，也不平移所属对象。"
                ),
            }
        )
        return plan

    def face_plane_offset_owning_translation_plan(self, face_id: int, distance: float) -> dict[str, object]:
        try:
            distance = float(distance)
        except (TypeError, ValueError):
            distance = 0.0
            frame = None
            blockers = ["目标偏移变换位置必须是数字。"]
        else:
            frame = self.face_plane_offset_frame(face_id)
            blockers = []

        if face_id < 0 or face_id >= len(self.faces):
            blockers.append(f"Unknown face id {face_id}")
            info: dict[str, object] = {}
        else:
            info = self.face_info(face_id)
        if frame is None:
            blockers.append("当前 Face 缺少稳定平面方向或基准点，不能按偏移变换平移所属对象。")

        plane_origin = None
        plane_direction = None
        current_position = None
        target_position = None
        vector = (0.0, 0.0, 0.0)
        if frame is not None:
            plane_origin, plane_direction, current_position = frame
            target_position = current_position + distance
            vector = _tuple_scale(plane_direction, distance)

        part_id = int(info.get("part_id", -1)) if info else -1
        solid_id = int(info.get("solid_id", -1)) if info else -1
        part = self.part_by_id(part_id) if part_id >= 0 else None
        part_solid_count = len(_explore(part.shape, TopAbs_SOLID)) if part is not None else 0
        target_kind = "solid" if solid_id >= 0 and part_solid_count > 1 else "part"
        if part is None:
            blockers.append("找不到当前 Face 所属特征。")
        if target_kind == "solid" and not (0 <= solid_id < len(self.solids)):
            blockers.append("找不到当前 Face 所属 Solid。")

        if blockers:
            return {
                "status": "blocked",
                "risk": "blocked",
                "message": " ".join(blockers),
                "warnings": "",
                "blockers": "；".join(blockers),
                "face_id": face_id,
                "part_id": part_id,
                "solid_id": solid_id,
                **self._face_first_level_plan_fields(face_id),
                "surface": info.get("surface"),
                "target_kind": target_kind,
                "current_plane_position": current_position,
                "target_plane_position": target_position,
                "plane_origin": plane_origin,
                "plane_direction": plane_direction,
                "plane_offset_distance": distance,
                "translation_vector": vector,
                "resize_strategy": "translate-owning-shape-from-plane-offset",
                "translate_strategy": f"translate-{target_kind}",
                "edit_strategy_label": "按偏移变换平移所属对象",
                "edit_semantics": "把目标偏移变换位置换算成沿当前面垂直方向的平移量，并平移所属特征或 Solid。",
            }

        plan = self.translate_solid_plan(solid_id, vector) if target_kind == "solid" else self.translate_part_plan(part_id, vector)
        distance_ratio = 0.0
        diagonal = float(plan.get("bbox_diagonal") or 0.0)
        if diagonal > 1e-9:
            distance_ratio = abs(distance) / diagonal
        if distance_ratio > 5.0:
            blocker = "目标偏移变换位置需要移动的距离超过所属对象尺寸的 5 倍，容易把特征移动到远离模型的位置。"
            blockers = [part for part in str(plan.get("blockers") or "").split("；") if part]
            blockers.append(blocker)
            plan["status"] = "blocked"
            plan["risk"] = "blocked"
            plan["blockers"] = "；".join(blockers)
            plan["message"] = " ".join(blockers)
        plan.update(
            {
                "face_id": face_id,
                **self._face_first_level_plan_fields(face_id),
                "surface": info.get("surface"),
                "current_plane_position": current_position,
                "target_plane_position": target_position,
                "plane_origin": plane_origin,
                "plane_direction": plane_direction,
                "plane_offset_distance": distance,
                "face_offset_distance_ratio": distance_ratio,
                "resize_strategy": "translate-owning-shape-from-plane-offset",
                "translate_strategy": f"translate-{target_kind}",
                "edit_strategy_label": "按偏移变换平移所属对象",
                "edit_semantics": "把目标偏移变换位置换算成沿当前面垂直方向的平移量，并平移所属特征或 Solid；不拉伸/切除，不切削，也不补料。",
            }
        )
        return plan

    def face_center_owning_translation_plan(
        self,
        face_id: int,
        target_center: tuple[float, float, float],
    ) -> dict[str, object]:
        if face_id < 0 or face_id >= len(self.faces):
            raise ValueError(f"Unknown face id {face_id}")

        info = self.quick_face_info(face_id)
        target = _tuple_or_none(target_center)
        current_center = _tuple_or_none(info.get("area_center")) or _tuple_or_none(info.get("bbox_center"))
        part_id = int(info.get("part_id", -1))
        solid_id = int(info.get("solid_id", -1))
        part = self.part_by_id(part_id) if part_id >= 0 else None
        part_solid_count = len(_explore(part.shape, TopAbs_SOLID)) if part is not None else 0
        target_kind = "solid" if solid_id >= 0 and part_solid_count > 1 else "part"

        blockers: list[str] = []
        if current_center is None:
            blockers.append("当前 Face 缺少稳定中心坐标，不能按中心平移所属对象。")
        if target is None:
            blockers.append("目标 Face 中心必须是有效的 X/Y/Z 坐标。")
        if part is None:
            blockers.append("找不到当前 Face 所属特征。")
        if target_kind == "solid" and not (0 <= solid_id < len(self.solids)):
            blockers.append("找不到当前 Face 所属 Solid。")

        vector = (0.0, 0.0, 0.0)
        move_distance = 0.0
        move_ratio = 0.0
        diagonal = 0.0
        if current_center is not None and target is not None:
            vector = _tuple_sub(target, current_center)
            move_distance = _vector_length(vector)
            source_shape = (
                self.solids[solid_id][1]
                if target_kind == "solid" and 0 <= solid_id < len(self.solids)
                else (part.shape if part is not None else None)
            )
            diagonal = _shape_diagonal(source_shape) if source_shape is not None else 0.0
            if diagonal > 1e-9:
                move_ratio = move_distance / diagonal
            if move_distance <= max(diagonal * 1e-7, 1e-7):
                blockers.append("目标 Face 中心与当前中心几乎相同，不需要移动。")
            elif move_ratio > 5.0:
                blockers.append("目标 Face 中心移动距离超过所属对象尺寸的 5 倍，容易生成极端变形或把特征移到远离模型的位置。")

        if blockers:
            return {
                "status": "blocked",
                "risk": "blocked",
                "message": " ".join(blockers),
                "warnings": "",
                "blockers": "；".join(blockers),
                "face_id": face_id,
                "part_id": part_id,
                "solid_id": solid_id,
                **self._face_first_level_plan_fields(face_id),
                "surface": info.get("surface"),
                "target_kind": target_kind,
                "current_face_center": current_center,
                "target_face_center": target,
                "translation_vector": vector,
                "translation_distance": move_distance,
                "face_center_move_vector": vector,
                "face_center_move_distance": move_distance,
                "face_center_move_ratio": move_ratio,
                "bbox_diagonal": diagonal,
                "resize_strategy": "translate-owning-shape-from-face-center",
                "translate_strategy": f"translate-{target_kind}",
                "edit_strategy_label": "平移 Face 所属对象",
                "edit_semantics": "把目标 Face 的中心坐标换算成平移量，并平移所属特征或 Solid；不做单面局部扭曲。",
            }

        plan = self.translate_solid_plan(solid_id, vector) if target_kind == "solid" else self.translate_part_plan(part_id, vector)
        diagonal = float(plan.get("bbox_diagonal") or diagonal or 0.0)
        if diagonal > 1e-9:
            move_ratio = move_distance / diagonal
        plan.update(
            {
                "face_id": face_id,
                **self._face_first_level_plan_fields(face_id),
                "surface": info.get("surface"),
                "current_face_center": current_center,
                "target_face_center": target,
                "face_center_move_vector": vector,
                "face_center_move_distance": move_distance,
                "face_center_move_ratio": move_ratio,
                "resize_strategy": "translate-owning-shape-from-face-center",
                "translate_strategy": f"translate-{target_kind}",
                "edit_strategy_label": "平移 Face 所属对象",
                "edit_semantics": "把目标 Face 的中心坐标换算成平移量，并平移所属特征或 Solid；不做单面局部扭曲。",
            }
        )
        return plan

    def move_face_center_owning(
        self,
        face_id: int,
        target_center: tuple[float, float, float],
    ) -> str:
        plan = self.face_center_owning_translation_plan(face_id, target_center)
        if plan["status"] == "blocked":
            raise ValueError(str(plan["message"]))
        self._remember_face_target_logical_id(plan, face_id)
        vector = tuple(plan["translation_vector"])
        result, result_check = self._run_checked_face_edit(
            plan,
            lambda: (
                self.translate_solid(int(plan["solid_id"]), vector)
                if plan.get("target_kind") == "solid"
                else self.translate_part(int(plan["part_id"]), vector)
            ),
        )
        return (
            "Face center move completed by owning-shape translation: "
            f"face {face_id}, "
            f"current_center={plan.get('current_face_center')}, "
            f"target_center={plan.get('target_face_center')}, "
            f"move={plan.get('face_center_move_vector')}, "
            f"target={plan.get('target_kind')}, "
            f"risk={plan['risk']}. {result_check} {result}"
        )

    def move_face_plane_offset_local(self, face_id: int, distance: float) -> str:
        plan = self.face_plane_offset_local_plan(face_id, distance)
        if plan["status"] == "blocked":
            raise ValueError(str(plan["message"]))
        self._remember_face_target_logical_id(plan, face_id)
        _action_result, result_check = self._run_checked_face_edit(
            plan,
            lambda: self._apply_local_face_deform(plan),
        )
        return (
            "Face plane offset completed by local face-only deformation: "
            f"face {face_id}, "
            f"current_position={float(plan['current_plane_position']):g}, "
            f"target_position={float(plan['target_plane_position']):g}, "
            f"distance={float(plan['plane_offset_distance']):g}, "
            f"moved_points={plan.get('local_face_deform_moved_point_count')}, "
            f"rebuilt_faces={plan.get('local_face_deform_face_count')}, "
            f"target={plan.get('local_face_deform_target_kind')}, "
            f"risk={plan['risk']}. {result_check}"
        )

    def translate_face_plane_offset_owning(self, face_id: int, distance: float) -> str:
        plan = self.face_plane_offset_owning_translation_plan(face_id, distance)
        if plan["status"] == "blocked":
            raise ValueError(str(plan["message"]))
        self._remember_face_target_logical_id(plan, face_id)
        result, result_check = self._run_checked_face_edit(
            plan,
            lambda: (
                self.translate_solid(int(plan["solid_id"]), tuple(plan["translation_vector"]))
                if plan.get("target_kind") == "solid"
                else self.translate_part(int(plan["part_id"]), tuple(plan["translation_vector"]))
            ),
        )
        return (
            "Face plane offset completed by owning-shape translation: "
            f"face {face_id}, "
            f"current_position={float(plan['current_plane_position']):g}, "
            f"target_position={float(plan['target_plane_position']):g}, "
            f"distance={float(plan['plane_offset_distance']):g}, "
            f"target={plan.get('target_kind')}, "
            f"risk={plan['risk']}. "
            f"{result_check} "
            f"{result}"
        )

    def shell_thickness_plan(self, face_id: int, target_thickness: float) -> dict[str, object]:
        if face_id < 0 or face_id >= len(self.faces):
            raise ValueError(f"Unknown face id {face_id}")
        info = self.feature_info(face_id)
        blockers: list[str] = []
        warnings: list[str] = [
            "壳体厚度调整基于相对平面几何估算，会移动当前选中平面区域，保留相对平面不动。"
        ]
        risk = "low"
        status = "ready"
        first_level_fields = self._face_first_level_plan_fields(face_id)

        try:
            target_thickness = float(target_thickness)
        except (TypeError, ValueError):
            target_thickness = 0.0
            blockers.append("目标壳体厚度必须是数字。")
        current_thickness = float(info.get("shell_thickness_estimate") or 0.0)
        signed_thickness = float(info.get("shell_signed_thickness") or 0.0)
        delta_thickness = target_thickness - current_thickness
        confidence = str(info.get("shell_confidence", "low"))
        overlap_ratio = float(info.get("shell_overlap_ratio_estimate", 0.0))
        source_face_ids = tuple(_int_values(info.get("shell_source_face_ids")) or [face_id])
        opposite_face_id = int(info.get("shell_opposite_face_id", -1))

        if info.get("surface") != "plane":
            blockers.append("当前选中 Face 不是平面，不能调整壳体厚度。")
        if info.get("shell_region_status") != "candidate":
            blockers.append(str(info.get("shell_region_note", "当前平面没有识别到相对壳体平面。")))
        if current_thickness <= 1e-9 or abs(signed_thickness) <= 1e-9:
            blockers.append("当前壳体厚度估算无效。")
        if target_thickness <= 1e-9:
            blockers.append("目标壳体厚度必须大于 0。")
        if abs(delta_thickness) <= max(current_thickness * 1e-5, 1e-6):
            blockers.append("目标厚度与当前估算厚度几乎相同，不需要修改。")
        if current_thickness > 1e-9:
            thickness_scale = target_thickness / current_thickness
            if thickness_scale < 0.05:
                blockers.append("目标壳体厚度会把当前厚度缩到 5% 以下，容易生成退化壳体或无效几何。")
            elif thickness_scale > 5.0:
                blockers.append("目标壳体厚度会把当前厚度放大到 5 倍以上，容易导致拉伸/切除布尔失败或大范围变形。")

        normal = _tuple_normalized(_tuple_or_none(info.get("normal")))
        outward = _tuple_normalized(_tuple_or_none(info.get("push_pull_outward_direction")))
        desired_movement = None
        push_pull_distance = 0.0
        movement_alignment = 0.0
        if not blockers:
            if normal is None or outward is None:
                blockers.append("当前平面缺少稳定法向或拉伸/切除方向，不能换算厚度修改。")
            else:
                sign = 1.0 if signed_thickness >= 0.0 else -1.0
                toward_opposite = _tuple_scale(normal, sign)
                desired_movement = _tuple_scale(toward_opposite, -delta_thickness)
                desired_unit = _tuple_normalized(desired_movement)
                if desired_unit is None:
                    blockers.append("目标厚度变化量无效。")
                else:
                    movement_alignment = abs(_tuple_dot(desired_unit, outward))
                    if movement_alignment < 0.82:
                        blockers.append("当前平面拉伸/切除方向与壳体厚度方向不匹配，暂不执行自动厚度修改。")
                    else:
                        push_pull_distance = _tuple_dot(desired_movement, outward)

        if not blockers:
            delta_ratio = abs(delta_thickness) / max(current_thickness, 1e-9)
            if confidence == "low":
                risk = _max_risk(risk, "high")
                warnings.append("壳体相对面识别置信度较低。")
            elif confidence == "medium":
                risk = _max_risk(risk, "medium")
                warnings.append("壳体相对面识别置信度为 medium，执行后请检查周边。")
            if overlap_ratio < 0.25:
                risk = _max_risk(risk, "high")
                warnings.append("相对平面投影重叠率较低，可能不是稳定壳体区域。")
            elif overlap_ratio < 0.55:
                risk = _max_risk(risk, "medium")
                warnings.append("相对平面投影重叠率一般，厚度估算可能偏局部。")
            if delta_ratio > 0.8:
                risk = _max_risk(risk, "high")
                warnings.append("目标厚度变化超过当前厚度的 80%，容易导致布尔失败或周边变形。")
            elif delta_ratio > 0.35:
                risk = _max_risk(risk, "medium")
                warnings.append("目标厚度变化超过当前厚度的 35%，请确认预览。")

            push_plan = self.push_pull_plan(face_id, push_pull_distance)
            if push_plan["status"] == "blocked":
                blockers.append(str(push_plan["message"]))
            else:
                risk = _max_risk(risk, str(push_plan["risk"]))
                push_warnings = str(push_plan.get("warnings", ""))
                if push_warnings:
                    warnings.append(push_warnings)

        if blockers:
            status = "blocked"
            risk = "blocked"
            message = " ".join(blockers)
            push_plan = {}
        elif risk != "low":
            status = "caution"
            message = " ".join(warnings)
        else:
            message = "可以通过拉伸/切除当前平面区域调整壳体厚度。"

        return {
            "status": status,
            "risk": risk,
            "message": message,
            "warnings": "；".join(warnings),
            "blockers": "；".join(blockers),
            "face_id": face_id,
            "part_id": info.get("part_id"),
            "solid_id": info.get("solid_id"),
            **first_level_fields,
            "surface": info.get("surface"),
            "shell_region_kind": info.get("shell_region_kind"),
            "shell_confidence": confidence,
            "shell_source_face_ids": source_face_ids,
            "shell_opposite_face_id": opposite_face_id,
            "shell_current_thickness": current_thickness,
            "shell_target_thickness": target_thickness,
            "shell_delta_thickness": delta_thickness,
            "shell_delta_ratio": abs(delta_thickness) / max(current_thickness, 1e-9),
            "shell_signed_thickness": signed_thickness,
            "shell_overlap_ratio_estimate": overlap_ratio,
            "shell_opposite_normal_dot": info.get("shell_opposite_normal_dot"),
            "shell_desired_movement_vector": desired_movement,
            "shell_movement_alignment": movement_alignment,
            "push_pull_distance": push_pull_distance,
            "outward_direction": info.get("push_pull_outward_direction"),
            "push_pull_status": push_plan.get("status"),
            "push_pull_risk": push_plan.get("risk"),
            "push_pull_message": push_plan.get("message"),
            "push_pull_scope_face_ids": push_plan.get("push_pull_scope_face_ids", source_face_ids),
            "push_pull_scope_face_count": push_plan.get("push_pull_scope_face_count", len(source_face_ids)),
            "push_pull_scope_note": push_plan.get("push_pull_scope_note", ""),
            "resize_strategy": "push-pull-shell-source-plane-to-target-thickness",
        }

    def _local_face_plane_size_info(
        self,
        face_id: int,
        *,
        face: TopoDS_Shape | None = None,
        surf: BRepAdaptor_Surface | None = None,
        center: tuple[float, float, float] | None = None,
        tolerance: float | None = None,
    ) -> dict[str, object]:
        if face_id < 0 or face_id >= len(self.faces):
            return {}
        face_shape = face or self.faces[face_id]
        surface = surf or BRepAdaptor_Surface(face_shape)
        if surface.GetType() != GeomAbs_Plane:
            return {}
        if center is None:
            try:
                center = _point_tuple(_surface_center(face_shape))
            except Exception:
                center = None
        if center is None:
            return {}

        if tolerance is None:
            solid_id = self.face_solid_ids[face_id] if face_id < len(self.face_solid_ids) else -1
            source_shape = self.solids[solid_id][1] if 0 <= solid_id < len(self.solids) else face_shape
            tolerance = max(_shape_diagonal(source_shape) * 1e-7, 1e-6)
        points = self._local_deform_face_vertex_points(face_shape, tolerance)
        if len(points) < 3:
            return {}

        normal = _tuple_normalized(_dir_tuple(surface.Plane().Axis().Direction()))
        if normal is None:
            return {}
        if face_shape.Orientation() == TopAbs_REVERSED:
            normal = _tuple_scale(normal, -1.0)

        u_dir, v_dir = _plane_basis_dirs(gp_Dir(*normal))
        width_dir = _tuple_normalized(_dir_tuple(u_dir))
        height_dir = _tuple_normalized(_dir_tuple(v_dir))
        if width_dir is None:
            return {}
        if height_dir is None:
            return {}

        def span_for(axis: tuple[float, float, float]) -> float:
            values = [_tuple_dot(_tuple_sub(point, center), axis) for point in points]
            return max(values) - min(values)

        width = span_for(width_dir)
        height = span_for(height_dir)
        if width <= max(tolerance, 1e-9) or height <= max(tolerance, 1e-9):
            return {}
        return {
            "local_face_width": width,
            "local_face_height": height,
            "local_face_width_direction": width_dir,
            "local_face_height_direction": height_dir,
            "local_face_size_center": center,
            "local_face_size_source_point_count": len(points),
        }

    def face_center_local_move_plan(
        self,
        face_id: int,
        target_center: tuple[float, float, float],
    ) -> dict[str, object]:
        if face_id < 0 or face_id >= len(self.faces):
            raise ValueError(f"Unknown face id {face_id}")

        info = self.face_info(face_id)
        target = _tuple_or_none(target_center)
        current_center = _tuple_or_none(info.get("area_center")) or _tuple_or_none(info.get("bbox_center"))
        part_id = int(info.get("part_id", -1))
        solid_id = int(info.get("solid_id", -1))
        part = self.part_by_id(part_id) if part_id >= 0 else None
        solid = self.solids[solid_id][1] if 0 <= solid_id < len(self.solids) else None
        source_shape = solid or (part.shape if part is not None else None)
        diagonal = _shape_diagonal(source_shape) if source_shape is not None else 0.0
        tolerance = max(diagonal * 1e-7, 1e-6)
        blockers: list[str] = []
        warnings: list[str] = [
            "`中心(局部重建)` 会移动这个 Face 的顶点并重建周边平面；相邻面可能变斜或被拆成三角面。"
        ]
        risk = "low"
        status = "ready"
        first_level_fields = self._face_first_level_plan_fields(face_id)

        if info.get("surface") != "plane":
            blockers.append("当前 Face 不是平面，不能执行“中心(局部重建)”。")
        if current_center is None:
            blockers.append("当前 Face 缺少稳定中心坐标。")
        if target is None:
            blockers.append("目标 Face 中心必须是有效的 X/Y/Z 坐标。")
        if part is None:
            blockers.append("找不到当前 Face 所属特征。")
        if solid is None:
            blockers.append("找不到当前 Face 所属 Solid。")

        move_vector = (0.0, 0.0, 0.0)
        move_distance = 0.0
        move_ratio = 0.0
        if current_center is not None and target is not None:
            move_vector = _tuple_sub(target, current_center)
            move_distance = _vector_length(move_vector)
            move_ratio = move_distance / max(diagonal, 1e-9)
            if move_distance <= max(diagonal * 1e-7, 1e-7):
                blockers.append("目标 Face 中心与当前中心几乎相同，不需要修改。")
            elif move_ratio > 5.0:
                blockers.append("目标 Face 中心移动距离超过所属对象尺寸的 5 倍，容易生成极端变形或无效几何。")
            elif move_ratio > 0.5:
                risk = _max_risk(risk, "high")
                warnings.append("Face 中心移动距离超过所属对象尺寸的 50%，局部形变风险很高。")
            elif move_ratio > 0.2:
                risk = _max_risk(risk, "medium")
                warnings.append("Face 中心移动距离超过所属对象尺寸的 20%，请确认相邻面变化是否符合预期。")

        source_points: tuple[tuple[float, float, float], ...] = ()
        face_count = 0
        part_solid_count = 0
        if part is not None:
            part_solid_count = len(_explore(part.shape, TopAbs_SOLID))
        target_kind = "solid" if solid_id >= 0 and part_solid_count > 1 else "part"
        if not blockers and solid is not None:
            solid_faces = _explore(solid, TopAbs_FACE)
            face_count = len(solid_faces)
            if not solid_faces:
                blockers.append("局部 Face 移动不可用：所属 Solid 没有可重建 Face。")
            if face_count > 128:
                blockers.append("局部 Face 移动暂只对较简单的平面实体开放，复杂模型请使用拉伸/切除或整体平移。")
            for face in solid_faces:
                surf = BRepAdaptor_Surface(face)
                if surf.GetType() != GeomAbs_Plane:
                    blockers.append("局部 Face 移动暂只支持全平面实体；含曲面的模型请使用其它建模意图。")
                    break
                if len(_explore(face, TopAbs_WIRE)) != 1:
                    blockers.append("局部 Face 移动暂不处理带内孔的 Face；请使用孔/槽专门入口。")
                    break
                if len(self._local_deform_face_vertex_points(face, tolerance)) < 3:
                    blockers.append("局部 Face 移动不可用：部分 Face 顶点环无法稳定读取。")
                    break

            if not blockers:
                blockers.extend(
                    self._face_first_level_plan_blockers(
                        first_level_fields,
                        operation_label="中心(局部重建)",
                    )
                )
            if not blockers:
                points = self._local_deform_face_vertex_points(self.faces[face_id], tolerance)
                if len(points) < 3:
                    blockers.append("局部 Face 移动不可用：当前 Face 顶点环无法稳定读取。")
                else:
                    source_points = tuple(points)

        if blockers:
            status = "blocked"
            risk = "blocked"
            message = " ".join(blockers)
        elif risk != "low":
            status = "caution"
            message = " ".join(warnings)
        else:
            message = "可以执行中心(局部重建)，并让相邻平面按新的顶点位置重建。"

        return {
            "status": status,
            "risk": risk,
            "message": message,
            "warnings": "；".join(warnings),
            "blockers": "；".join(blockers),
            "face_id": face_id,
            "part_id": part_id,
            "solid_id": solid_id,
            **first_level_fields,
            "surface": info.get("surface"),
            "current_face_center": current_center,
            "target_face_center": target,
            "face_center_move_vector": move_vector,
            "face_center_move_distance": move_distance,
            "face_center_move_ratio": move_ratio,
            "bbox_diagonal": diagonal,
            "local_face_deform_target_kind": target_kind,
            "local_face_deform_face_count": face_count,
            "local_face_deform_source_points": source_points,
            "local_face_deform_moved_point_count": len(source_points),
            "part_solid_count": part_solid_count,
            "resize_strategy": "local-face-only-deform",
            "edit_strategy_label": "中心(局部重建)",
            "edit_semantics": (
                "移动当前 Face 的顶点，周边相邻面按新顶点重建；这不是平移所属对象，也不是面积缩放。"
            ),
        }

    def face_area_local_resize_plan(self, face_id: int, target_area: float) -> dict[str, object]:
        if face_id < 0 or face_id >= len(self.faces):
            raise ValueError(f"Unknown face id {face_id}")

        info = self.face_info(face_id)
        current_area = _float_or_none(info.get("area"))
        center = _tuple_or_none(info.get("area_center")) or _tuple_or_none(info.get("bbox_center"))
        part_id = int(info.get("part_id", -1))
        solid_id = int(info.get("solid_id", -1))
        part = self.part_by_id(part_id) if part_id >= 0 else None
        solid = self.solids[solid_id][1] if 0 <= solid_id < len(self.solids) else None
        source_shape = solid or (part.shape if part is not None else None)
        diagonal = _shape_diagonal(source_shape) if source_shape is not None else 0.0
        tolerance = max(diagonal * 1e-7, 1e-6)
        blockers: list[str] = []
        warnings: list[str] = [
            "`面积(局部重建)` 会在该平面内移动当前 Face 的顶点，并重建相邻平面。"
        ]
        risk = "low"
        status = "ready"
        first_level_fields = self._face_first_level_plan_fields(face_id)

        try:
            target_area = float(target_area)
        except (TypeError, ValueError):
            target_area = 0.0
            blockers.append("目标面面积必须是数字。")
        if info.get("surface") != "plane":
            blockers.append("当前 Face 不是平面，不能执行“面积(局部重建)”。")
        if current_area is None or current_area <= 1e-9:
            blockers.append("当前 Face 缺少稳定面积。")
        if center is None:
            blockers.append("当前 Face 缺少稳定中心坐标。")
        if target_area <= 1e-9:
            blockers.append("目标面面积必须大于 0。")
        if part is None:
            blockers.append("找不到当前 Face 所属特征。")
        if solid is None:
            blockers.append("找不到当前 Face 所属 Solid。")

        scale = (
            math.sqrt(target_area / max(float(current_area), 1e-9))
            if target_area > 1e-9 and current_area is not None and current_area > 1e-9
            else 1.0
        )
        area_delta = target_area - float(current_area or 0.0)
        area_delta_ratio = abs(area_delta) / max(float(current_area or 0.0), 1e-9)
        if scale < 0.05:
            blockers.append("目标面面积会把当前 Face 缩放到当前尺寸的 5% 以下，容易生成退化面或无效几何。")
        elif scale > 5.0:
            blockers.append("目标面面积会把当前 Face 放大到当前尺寸的 5 倍以上，容易穿过相邻几何或导致重建失败。")
        if current_area is not None and abs(area_delta) <= max(current_area * 1e-6, 1e-6):
            blockers.append("目标面面积与当前面积几乎相同，不需要修改。")
        if area_delta_ratio > 1.0:
            risk = _max_risk(risk, "high")
            warnings.append("目标面面积变化超过当前面积的 100%，相邻面形变风险很高。")
        elif area_delta_ratio > 0.35:
            risk = _max_risk(risk, "medium")
            warnings.append("目标面面积变化超过当前面积的 35%，请确认相邻面变化是否符合预期。")
        if scale < 0.2:
            risk = _max_risk(risk, "high")
            warnings.append("当前 Face 会被缩得很小，可能生成薄小面或退化边。")
        elif scale > 2.5:
            risk = _max_risk(risk, "high")
            warnings.append("当前 Face 会被放大很多，可能穿过相邻几何。")

        point_targets: tuple[tuple[tuple[float, float, float], tuple[float, float, float]], ...] = ()
        face_count = 0
        part_solid_count = 0
        if part is not None:
            part_solid_count = len(_explore(part.shape, TopAbs_SOLID))
        target_kind = "solid" if solid_id >= 0 and part_solid_count > 1 else "part"
        if not blockers and solid is not None and center is not None:
            solid_faces = _explore(solid, TopAbs_FACE)
            face_count = len(solid_faces)
            if not solid_faces:
                blockers.append("局部 Face 面积缩放不可用：所属 Solid 没有可重建 Face。")
            if face_count > 128:
                blockers.append("局部 Face 面积缩放暂只对较简单的平面实体开放。")
            for face in solid_faces:
                surf = BRepAdaptor_Surface(face)
                if surf.GetType() != GeomAbs_Plane:
                    blockers.append("局部 Face 面积缩放暂只支持全平面实体；含曲面的模型请使用所属对象缩放。")
                    break
                if len(_explore(face, TopAbs_WIRE)) != 1:
                    blockers.append("局部 Face 面积缩放暂不处理带内孔的 Face。")
                    break
                if len(self._local_deform_face_vertex_points(face, tolerance)) < 3:
                    blockers.append("局部 Face 面积缩放不可用：部分 Face 顶点环无法稳定读取。")
                    break

            if not blockers:
                blockers.extend(
                    self._face_first_level_plan_blockers(
                        first_level_fields,
                        operation_label="面积(局部重建)",
                    )
                )
            if not blockers:
                points = self._local_deform_face_vertex_points(self.faces[face_id], tolerance)
                if len(points) < 3:
                    blockers.append("局部 Face 面积缩放不可用：当前 Face 顶点环无法稳定读取。")
                else:
                    target_items: list[tuple[tuple[float, float, float], tuple[float, float, float]]] = []
                    for point in points:
                        relative = _tuple_sub(point, center)
                        target_point = (
                            center[0] + relative[0] * scale,
                            center[1] + relative[1] * scale,
                            center[2] + relative[2] * scale,
                        )
                        target_items.append((point, target_point))
                    point_targets = tuple(target_items)

        if blockers:
            status = "blocked"
            risk = "blocked"
            message = " ".join(blockers)
        elif risk != "low":
            status = "caution"
            message = " ".join(warnings)
        else:
            message = "可以执行面积(局部重建)，并让相邻平面按新的顶点位置重建。"

        return {
            "status": status,
            "risk": risk,
            "message": message,
            "warnings": "；".join(warnings),
            "blockers": "；".join(blockers),
            "face_id": face_id,
            "part_id": part_id,
            "solid_id": solid_id,
            **first_level_fields,
            "surface": info.get("surface"),
            "current_area": current_area,
            "target_area": target_area,
            "area_delta": area_delta,
            "area_delta_ratio": area_delta_ratio,
            "area_center": center,
            "local_face_area_scale": scale,
            "bbox_diagonal": diagonal,
            "local_face_deform_target_kind": target_kind,
            "local_face_deform_face_count": face_count,
            "local_face_deform_source_point_targets": point_targets,
            "local_face_deform_moved_point_count": len(point_targets),
            "part_solid_count": part_solid_count,
            "resize_strategy": "local-face-area-only-deform",
            "edit_strategy_label": "面积(局部重建)",
            "edit_semantics": (
                "围绕当前 Face 中心在该平面内缩放这个 Face 的顶点，周边相邻面按新顶点重建；"
                "这不是缩放所属对象。"
            ),
        }

    def face_size_local_resize_plan(self, face_id: int, target_size: float, axis: str = "width") -> dict[str, object]:
        if face_id < 0 or face_id >= len(self.faces):
            raise ValueError(f"Unknown face id {face_id}")

        axis_key = "height" if str(axis).strip().lower() in {"height", "h", "v", "y"} else "width"
        axis_label = "V向尺寸" if axis_key == "height" else "U向尺寸"
        info = self.face_info(face_id)
        center = _tuple_or_none(info.get("area_center")) or _tuple_or_none(info.get("bbox_center"))
        part_id = int(info.get("part_id", -1))
        solid_id = int(info.get("solid_id", -1))
        part = self.part_by_id(part_id) if part_id >= 0 else None
        solid = self.solids[solid_id][1] if 0 <= solid_id < len(self.solids) else None
        source_shape = solid or (part.shape if part is not None else None)
        diagonal = _shape_diagonal(source_shape) if source_shape is not None else 0.0
        tolerance = max(diagonal * 1e-7, 1e-6)
        blockers: list[str] = []
        warnings: list[str] = [
            f"{axis_label}(局部重建)会只沿选中 Face 自身平面内的一个方向缩放当前 Face 顶点，并重建相邻平面。"
        ]
        risk = "low"
        status = "ready"
        first_level_fields = self._face_first_level_plan_fields(face_id)

        try:
            target_size = float(target_size)
        except (TypeError, ValueError):
            target_size = 0.0
            blockers.append(f"目标{axis_label}必须是数字。")
        if info.get("surface") != "plane":
            blockers.append(f"当前 Face 不是平面，不能执行“{axis_label}(局部重建)”。")
        if center is None:
            blockers.append("当前 Face 缺少稳定中心坐标。")
        if target_size <= 1e-9:
            blockers.append(f"目标{axis_label}必须大于 0。")
        if part is None:
            blockers.append("找不到当前 Face 所属特征。")
        if solid is None:
            blockers.append("找不到当前 Face 所属 Solid。")

        size_info = self._local_face_plane_size_info(
            face_id,
            center=center,
            tolerance=tolerance,
        )
        current_width = _float_or_none(size_info.get("local_face_width"))
        current_height = _float_or_none(size_info.get("local_face_height"))
        width_dir = _tuple_or_none(size_info.get("local_face_width_direction"))
        height_dir = _tuple_or_none(size_info.get("local_face_height_direction"))
        current_size = current_height if axis_key == "height" else current_width
        axis_dir = height_dir if axis_key == "height" else width_dir
        if current_size is None or current_size <= 1e-9 or axis_dir is None:
            blockers.append(f"当前 Face 缺少稳定{axis_label}方向或尺寸。")

        scale = target_size / max(float(current_size or 1.0), 1e-9)
        delta_size = target_size - float(current_size or 0.0)
        delta_ratio = abs(delta_size) / max(float(current_size or 0.0), 1e-9)
        if scale < 0.05:
            blockers.append(f"目标{axis_label}会把当前 Face 沿该方向缩放到当前值的 5% 以下，容易生成退化边或无效几何。")
        elif scale > 5.0:
            blockers.append(f"目标{axis_label}会把当前 Face 沿该方向放大到当前值的 5 倍以上，容易穿过相邻几何或导致重建失败。")
        if current_size is not None and abs(delta_size) <= max(current_size * 1e-6, 1e-6):
            blockers.append(f"目标{axis_label}与当前值几乎相同，不需要修改。")
        if delta_ratio > 1.0:
            risk = _max_risk(risk, "high")
            warnings.append(f"目标{axis_label}变化超过当前值的 100%，相邻面形变风险很高。")
        elif delta_ratio > 0.35:
            risk = _max_risk(risk, "medium")
            warnings.append(f"目标{axis_label}变化超过当前值的 35%，请确认相邻面变化是否符合预期。")
        if scale < 0.2:
            risk = _max_risk(risk, "high")
            warnings.append("当前 Face 会沿一个方向被缩得很窄，可能生成薄小面或退化边。")
        elif scale > 2.5:
            risk = _max_risk(risk, "high")
            warnings.append("当前 Face 会沿一个方向被拉得很长，可能穿过相邻几何。")

        point_targets: tuple[tuple[tuple[float, float, float], tuple[float, float, float]], ...] = ()
        face_count = 0
        part_solid_count = 0
        if part is not None:
            part_solid_count = len(_explore(part.shape, TopAbs_SOLID))
        target_kind = "solid" if solid_id >= 0 and part_solid_count > 1 else "part"
        if not blockers and solid is not None and center is not None and axis_dir is not None:
            solid_faces = _explore(solid, TopAbs_FACE)
            face_count = len(solid_faces)
            if not solid_faces:
                blockers.append(f"局部 Face {axis_label}修改不可用：所属 Solid 没有可重建 Face。")
            if face_count > 128:
                blockers.append(f"局部 Face {axis_label}修改暂只对较简单的平面实体开放。")
            for face in solid_faces:
                surf = BRepAdaptor_Surface(face)
                if surf.GetType() != GeomAbs_Plane:
                    blockers.append(f"局部 Face {axis_label}修改暂只支持全平面实体；含曲面的模型请使用所属对象缩放。")
                    break
                if len(_explore(face, TopAbs_WIRE)) != 1:
                    blockers.append(f"局部 Face {axis_label}修改暂不处理带内孔的 Face。")
                    break
                if len(self._local_deform_face_vertex_points(face, tolerance)) < 3:
                    blockers.append(f"局部 Face {axis_label}修改不可用：部分 Face 顶点环无法稳定读取。")
                    break

            if not blockers:
                blockers.extend(
                    self._face_first_level_plan_blockers(
                        first_level_fields,
                        operation_label=f"{axis_label}(局部重建)",
                    )
                )
            if not blockers:
                points = self._local_deform_face_vertex_points(self.faces[face_id], tolerance)
                if len(points) < 3:
                    blockers.append(f"局部 Face {axis_label}修改不可用：当前 Face 顶点环无法稳定读取。")
                else:
                    target_items: list[tuple[tuple[float, float, float], tuple[float, float, float]]] = []
                    for point in points:
                        relative = _tuple_sub(point, center)
                        along = _tuple_dot(relative, axis_dir)
                        axial = _tuple_scale(axis_dir, along)
                        rest = _tuple_sub(relative, axial)
                        scaled = _tuple_add(rest, _tuple_scale(axis_dir, along * scale))
                        target_point = _tuple_add(center, scaled)
                        target_items.append((point, target_point))
                    point_targets = tuple(target_items)

        if blockers:
            status = "blocked"
            risk = "blocked"
            message = " ".join(blockers)
        elif risk != "low":
            status = "caution"
            message = " ".join(warnings)
        else:
            message = f"可以只修改当前平面 Face 的{axis_label}，并让相邻平面按新的顶点位置重建。"

        return {
            "status": status,
            "risk": risk,
            "message": message,
            "warnings": "；".join(warnings),
            "blockers": "；".join(blockers),
            "face_id": face_id,
            "part_id": part_id,
            "solid_id": solid_id,
            **first_level_fields,
            "surface": info.get("surface"),
            "face_size_axis": axis_key,
            "face_size_label": axis_label,
            "current_face_width": current_width,
            "target_face_width": target_size if axis_key == "width" else current_width,
            "current_face_height": current_height,
            "target_face_height": target_size if axis_key == "height" else current_height,
            "current_face_size": current_size,
            "target_face_size": target_size,
            "face_size_delta": delta_size,
            "face_size_delta_ratio": delta_ratio,
            "face_size_scale": scale,
            "face_size_center": center,
            "face_size_axis_direction": axis_dir,
            "face_width_direction": width_dir,
            "face_height_direction": height_dir,
            "bbox_diagonal": diagonal,
            "local_face_deform_target_kind": target_kind,
            "local_face_deform_face_count": face_count,
            "local_face_deform_source_point_targets": point_targets,
            "local_face_deform_moved_point_count": len(point_targets),
            "local_face_deform_distance_hint": abs(delta_size),
            "part_solid_count": part_solid_count,
            "resize_strategy": f"local-face-{axis_key}-only-deform",
            "edit_strategy_label": f"{axis_label}(局部重建)",
            "edit_semantics": (
                f"围绕当前 Face 中心，只沿 Face 平面内的{axis_label}方向缩放该 Face 顶点；"
                "另一方向尺寸保持不主动缩放，周边相邻面按新顶点重建；这不是缩放所属对象。"
            ),
        }

    def face_size_owning_scale_plan(self, face_id: int, target_size: float, axis: str = "width") -> dict[str, object]:
        if face_id < 0 or face_id >= len(self.faces):
            raise ValueError(f"Unknown face id {face_id}")

        axis_key = "height" if str(axis).strip().lower() in {"height", "h", "v", "y"} else "width"
        axis_label = "V向尺寸" if axis_key == "height" else "U向尺寸"
        info = self.face_info(face_id)
        center = _tuple_or_none(info.get("area_center")) or _tuple_or_none(info.get("bbox_center"))
        part_id = int(info.get("part_id", -1))
        solid_id = int(info.get("solid_id", -1))
        part = self.part_by_id(part_id) if part_id >= 0 else None
        solid = self.solids[solid_id][1] if 0 <= solid_id < len(self.solids) else None
        source_shape = solid or (part.shape if part is not None else None)
        diagonal = _shape_diagonal(source_shape) if source_shape is not None else 0.0
        tolerance = max(diagonal * 1e-7, 1e-6)
        blockers: list[str] = []
        warnings: list[str] = [
            f"{axis_label}(缩放特征)会沿选中 Face 自身平面内的一个方向缩放所属特征或 Solid；同一对象上的其它几何会跟着改变。"
        ]
        risk = "medium"
        first_level_fields = self._face_first_level_plan_fields(face_id)

        try:
            target_size = float(target_size)
        except (TypeError, ValueError):
            target_size = 0.0
            blockers.append(f"目标{axis_label}必须是数字。")
        if info.get("surface") != "plane":
            blockers.append(f"当前 Face 不是平面，不能执行“{axis_label}(缩放特征)”。")
        if center is None:
            blockers.append("当前 Face 缺少稳定中心坐标，不能确定缩放基准。")
        if target_size <= 1e-9:
            blockers.append(f"目标{axis_label}必须大于 0。")
        if part is None:
            blockers.append("找不到当前 Face 所属特征。")
        if source_shape is None:
            blockers.append("找不到当前 Face 可缩放的所属对象。")

        size_info = self._local_face_plane_size_info(
            face_id,
            center=center,
            tolerance=tolerance,
        )
        current_width = _float_or_none(size_info.get("local_face_width"))
        current_height = _float_or_none(size_info.get("local_face_height"))
        width_dir = _tuple_or_none(size_info.get("local_face_width_direction"))
        height_dir = _tuple_or_none(size_info.get("local_face_height_direction"))
        current_size = current_height if axis_key == "height" else current_width
        axis_dir = height_dir if axis_key == "height" else width_dir
        if current_size is None or current_size <= 1e-9 or axis_dir is None:
            blockers.append(f"当前 Face 缺少稳定{axis_label}方向或尺寸。")

        scale = target_size / max(float(current_size or 1.0), 1e-9)
        delta_size = target_size - float(current_size or 0.0)
        delta_ratio = abs(delta_size) / max(float(current_size or 0.0), 1e-9)
        if scale < 0.05:
            blockers.append(f"目标{axis_label}会把所属对象沿该方向缩放到当前值的 5% 以下，容易生成退化几何。")
        elif scale > 5.0:
            blockers.append(f"目标{axis_label}会把所属对象沿该方向放大到当前值的 5 倍以上，风险过高。")
        if current_size is not None and abs(delta_size) <= max(current_size * 1e-6, 1e-6):
            blockers.append(f"目标{axis_label}与当前值几乎相同，不需要修改。")
        if delta_ratio > 1.0:
            risk = _max_risk(risk, "high")
            warnings.append(f"目标{axis_label}变化超过当前值的 100%，所属对象会发生很大的单向缩放。")
        elif delta_ratio > 0.35:
            risk = _max_risk(risk, "high")
            warnings.append(f"目标{axis_label}变化超过当前值的 35%，请重点检查同一对象上的孔、槽、凸台和厚度。")
        elif delta_ratio > 0.15:
            risk = _max_risk(risk, "medium")
            warnings.append(f"目标{axis_label}变化超过当前值的 15%，其它特征会跟随缩放。")
        if scale < 0.2:
            risk = _max_risk(risk, "high")
            warnings.append("所属对象会沿一个方向被缩得很窄，可能生成退化边或薄小面。")
        elif scale > 2.5:
            risk = _max_risk(risk, "high")
            warnings.append("所属对象会沿一个方向被拉得很长，可能明显扭曲其它特征间距。")

        part_solid_count = len(_explore(part.shape, TopAbs_SOLID)) if part is not None else 0
        target_kind = "solid" if solid_id >= 0 and part_solid_count > 1 else "part"
        target_label = "Solid" if target_kind == "solid" else "特征"
        if not blockers:
            warnings.append(f"当前会缩放所属{target_label}，不是局部重建当前 Face 顶点。")

        owning_rebuild_mode = "affine-transform"
        point_targets: tuple[tuple[tuple[float, float, float], tuple[float, float, float]], ...] = ()
        face_count = 0
        if not blockers and solid is not None and center is not None and axis_dir is not None:
            solid_faces = _explore(solid, TopAbs_FACE)
            face_count = len(solid_faces)
            can_rebuild_planar = bool(solid_faces) and face_count <= 128
            if not solid_faces:
                warnings.append("所属对象没有可重建 Face，将使用通用仿射缩放。")
            elif face_count > 128:
                warnings.append("所属对象 Face 数较多，将使用通用仿射缩放。")
            if can_rebuild_planar:
                for face in solid_faces:
                    surf = BRepAdaptor_Surface(face)
                    if surf.GetType() != GeomAbs_Plane:
                        can_rebuild_planar = False
                        warnings.append("所属对象含曲面，将使用通用仿射缩放；部分解析几何可能变为 B-spline。")
                        break
                    if len(_explore(face, TopAbs_WIRE)) != 1:
                        can_rebuild_planar = False
                        warnings.append("所属对象包含带内孔的 Face，将使用通用仿射缩放。")
                        break
                    if len(self._local_deform_face_vertex_points(face, tolerance)) < 3:
                        can_rebuild_planar = False
                        warnings.append("所属对象部分 Face 顶点环无法稳定读取，将使用通用仿射缩放。")
                        break
            if can_rebuild_planar:
                target_by_key: dict[tuple[int, int, int], tuple[tuple[float, float, float], tuple[float, float, float]]] = {}
                for face in solid_faces:
                    for point in self._local_deform_face_vertex_points(face, tolerance):
                        key = self._local_point_key(point, tolerance)
                        if key in target_by_key:
                            continue
                        relative = _tuple_sub(point, center)
                        along = _tuple_dot(relative, axis_dir)
                        axial = _tuple_scale(axis_dir, along)
                        rest = _tuple_sub(relative, axial)
                        scaled = _tuple_add(rest, _tuple_scale(axis_dir, along * scale))
                        target_by_key[key] = (point, _tuple_add(center, scaled))
                point_targets = tuple(target_by_key.values())
                if point_targets:
                    owning_rebuild_mode = "planar-rebuild"
                    warnings.append("当前所属对象是简单全平面实体，会优先重建平面 Face，减少仿射后变成样条面的风险。")

        status = "blocked" if blockers else ("caution" if risk != "low" else "ready")
        if blockers:
            risk = "blocked"
            message = " ".join(blockers)
        elif warnings:
            message = " ".join(warnings)
        else:
            message = f"可以沿当前 Face 的{axis_label}方向缩放所属{target_label}。"

        return {
            "status": status,
            "risk": risk,
            "message": message,
            "warnings": "；".join(warnings),
            "blockers": "；".join(blockers),
            "face_id": face_id,
            "part_id": part_id,
            "solid_id": solid_id,
            **first_level_fields,
            "surface": info.get("surface"),
            "face_size_axis": axis_key,
            "face_size_label": axis_label,
            "current_face_width": current_width,
            "target_face_width": target_size if axis_key == "width" else current_width,
            "current_face_height": current_height,
            "target_face_height": target_size if axis_key == "height" else current_height,
            "current_face_size": current_size,
            "target_face_size": target_size,
            "face_size_delta": delta_size,
            "face_size_delta_ratio": delta_ratio,
            "face_size_scale": scale,
            "face_size_center": center,
            "face_size_axis_direction": axis_dir,
            "face_width_direction": width_dir,
            "face_height_direction": height_dir,
            "bbox_diagonal": diagonal,
            "resize_strategy": f"axis-scale-owning-shape-from-face-{axis_key}",
            "edit_strategy_label": f"{axis_label}(缩放特征)",
            "edit_semantics": (
                f"围绕当前 Face 中心，沿 Face 平面内的{axis_label}方向对所属{target_label}做单向仿射缩放；"
                "同一对象上的其它几何会跟随变化，这不是只改当前 Face。"
            ),
            "affine_scale": scale,
            "affine_transform_kind": "axis-affine",
            "affine_transform_label": f"按当前 Face{axis_label}方向缩放所属{target_label}",
            "affine_transform_note": "单向仿射缩放可能把部分解析几何转换成 B-spline，并会改变同一对象上的其它特征间距。",
            "affine_axis_point": center,
            "affine_axis_direction": axis_dir,
            "affine_axis_source": f"selected face {axis_key} direction",
            "affine_anchor_source": "selected face center",
            "affine_target_kind": target_kind,
            "part_solid_count": part_solid_count,
            "owning_face_size_rebuild_mode": owning_rebuild_mode,
            "local_face_deform_target_kind": target_kind,
            "local_face_deform_face_count": face_count,
            "local_face_deform_source_point_targets": point_targets,
            "local_face_deform_moved_point_count": len(point_targets),
            "local_face_deform_distance_hint": abs(delta_size),
        }

    def cylindrical_boss_height_plan(
        self,
        face_id: int,
        target_height: float,
        *,
        require_boss: bool = True,
    ) -> dict[str, object]:
        if face_id < 0 or face_id >= len(self.faces):
            raise ValueError(f"Unknown face id {face_id}")
        info = self.face_info(face_id)
        feature = self.feature_info(face_id)
        topology_fields = (
            self._cylindrical_feature_first_level_plan_fields(face_id)
            if info.get("surface") == "cylinder"
            else {}
        )
        blockers: list[str] = []
        edit_label = "凸台高度" if require_boss else "圆柱高度"
        warnings: list[str] = [
            f"{edit_label}调整会拉伸/切除识别到的圆柱端盖 Face；这是 B-Rep 几何编辑，不是 CAD 历史特征参数。"
        ]
        risk = "low"

        if info.get("surface") != "cylinder":
            blockers.append(f"当前选中 Face 不是圆柱面，不能调整{edit_label}。")
        if require_boss and str(info.get("feature_guess", "")) != "boss/outer-round candidate":
            blockers.append("凸台高度调整当前版本只支持明确的圆柱凸台候选。")
        cylinder_identity = {**info, **feature}
        angular_span = _effective_cylinder_angular_span(cylinder_identity) or 0.0
        if not _is_effectively_full_cylinder(cylinder_identity):
            blockers.append(f"{edit_label}调整当前版本只支持接近完整圆柱的圆柱面。")
        if target_height <= 1e-9:
            blockers.append(f"目标{edit_label}必须大于 0。")

        axis_range: dict[str, object] = {
            "span": 0.0,
            "same_domain_face_ids": (),
            "same_domain_face_count": 0,
        }
        if info.get("surface") == "cylinder":
            axis_range = self._cylindrical_axis_range(
                face_id,
                BRepAdaptor_Surface(self.faces[face_id]),
                _int_values(feature.get("feature_side_face_ids")),
            )
        current_height = float(axis_range.get("span", 0.0))
        delta_height = float(target_height) - current_height
        if current_height <= 1e-9:
            blockers.append(f"当前{edit_label}估算无效。")
        elif abs(delta_height) <= max(current_height * 1e-5, 1e-6):
            blockers.append(f"目标{edit_label}与当前估算高度几乎相同，不需要修改。")

        if str(info.get("confidence", "low")) != "high":
            risk = _max_risk(risk, "medium")
            warnings.append(f"{edit_label}识别置信度不是 high，修改后请重点检查结果。")
        if current_height > 1e-9:
            delta_ratio = abs(delta_height) / current_height
            if delta_ratio > 0.8:
                risk = _max_risk(risk, "high")
                warnings.append("目标高度变化超过当前高度的 80%，可能导致周边几何异常。")
            elif delta_ratio > 0.3:
                risk = _max_risk(risk, "medium")
                warnings.append("目标高度变化超过当前高度的 30%，请确认预览方向和范围。")

        cap_candidates: list[tuple[tuple[int, int, float, int], dict[str, object]]] = []
        if not blockers:
            endpoint_groups = [
                ("start", "起点端盖", _int_values(feature.get("feature_start_end_face_ids")), -1.0, bool(info.get("start_end_open"))),
                ("end", "终点端盖", _int_values(feature.get("feature_end_end_face_ids")), 1.0, bool(info.get("end_end_open"))),
            ]
            axis_direction = _tuple_normalized(_tuple_or_none(info.get("axis")))
            if axis_direction is None:
                blockers.append(f"当前{edit_label}缺少稳定轴线方向，不能换算高度修改。")
            else:
                for endpoint_role, endpoint_label, cap_face_ids, axis_sign, is_open_end in endpoint_groups:
                    desired_movement = _tuple_scale(axis_direction, axis_sign * delta_height)
                    desired_unit = _tuple_normalized(desired_movement)
                    if desired_unit is None:
                        continue
                    for cap_face_id in cap_face_ids:
                        if cap_face_id < 0 or cap_face_id >= len(self.faces):
                            continue
                        try:
                            cap_info = self.face_info(cap_face_id)
                        except Exception:
                            continue
                        if cap_info.get("surface") != "plane":
                            continue
                        outward = _tuple_normalized(_tuple_or_none(cap_info.get("push_pull_outward_direction")))
                        if outward is None:
                            continue
                        movement_alignment = abs(_tuple_dot(desired_unit, outward))
                        if movement_alignment < 0.82:
                            continue
                        push_pull_distance = _tuple_dot(desired_movement, outward)
                        if abs(push_pull_distance) <= 1e-9:
                            continue
                        push_plan = self.push_pull_plan(cap_face_id, push_pull_distance)
                        if push_plan["status"] == "blocked":
                            warnings.append(f"{endpoint_label} Face {cap_face_id} 不能拉伸/切除：{push_plan.get('message', '')}")
                            continue
                        candidate_risk = str(push_plan.get("risk", "medium"))
                        score = (
                            0 if is_open_end else 1,
                            {"low": 0, "medium": 1, "high": 2}.get(candidate_risk, 3),
                            -movement_alignment,
                            cap_face_id,
                        )
                        cap_candidates.append(
                            (
                                score,
                                {
                                    "boss_height_cap_face_id": cap_face_id,
                                    "boss_height_endpoint_role": endpoint_role,
                                    "boss_height_endpoint_label": endpoint_label,
                                    "boss_height_open_end": is_open_end,
                                    "boss_height_movement_alignment": movement_alignment,
                                    "boss_height_desired_movement_vector": desired_movement,
                                    "push_pull_distance": push_pull_distance,
                                    "push_pull_status": push_plan.get("status"),
                                    "push_pull_risk": push_plan.get("risk"),
                                    "push_pull_message": push_plan.get("message"),
                                    "push_pull_scope_face_ids": push_plan.get("push_pull_scope_face_ids", (cap_face_id,)),
                                    "push_pull_scope_face_count": push_plan.get("push_pull_scope_face_count", 1),
                                    "push_pull_scope_note": push_plan.get("push_pull_scope_note", ""),
                                },
                            )
                        )

        selected_cap: dict[str, object] = {}
        if not blockers:
            if not cap_candidates:
                blockers.append("没有找到可拉伸/切除的圆柱端盖 Face，暂不能直接调整凸台高度。")
            else:
                cap_candidates.sort(key=lambda item: item[0])
                selected_cap = cap_candidates[0][1]
                risk = _max_risk(risk, str(selected_cap.get("push_pull_risk", "medium")))
                if not selected_cap.get("boss_height_open_end"):
                    risk = _max_risk(risk, "medium")
                    warnings.append("未能确认所选端盖是凸台外端，执行后请重点检查是否移动了正确端面。")

        if blockers:
            status = "blocked"
            risk = "blocked"
            message = " ".join(blockers)
        elif risk != "low":
            status = "caution"
            message = " ".join(warnings)
        else:
            status = "ready"
            message = f"可以通过拉伸/切除圆柱端盖调整{edit_label}。"

        return {
            "status": status,
            "risk": risk,
            "message": message,
            "warnings": "；".join(warnings),
            "blockers": "；".join(blockers),
            "face_id": face_id,
            "part_id": info.get("part_id"),
            "solid_id": info.get("solid_id"),
            "feature_type": feature.get("feature_type"),
            "feature_guess": info.get("feature_guess"),
            "confidence": info.get("confidence"),
            "current_height": current_height,
            "target_height": float(target_height),
            "delta_height": delta_height,
            "height_delta_ratio": abs(delta_height) / max(current_height, 1e-9),
            "diameter": info.get("diameter"),
            "radius": info.get("radius"),
            "axis": info.get("axis"),
            "axis_point": info.get("axis_point"),
            "same_domain_face_ids": axis_range.get("same_domain_face_ids"),
            "same_domain_face_count": axis_range.get("same_domain_face_count"),
            "feature_start_end_face_ids": feature.get("feature_start_end_face_ids"),
            "feature_end_end_face_ids": feature.get("feature_end_end_face_ids"),
            **topology_fields,
            "resize_strategy": (
                "push-pull-cylindrical-boss-end-cap-to-target-height"
                if require_boss
                else "push-pull-cylindrical-end-cap-to-target-height"
            ),
            "edit_strategy_label": "端盖拉伸/切除调整高度" if require_boss else "圆柱端盖拉伸/切除调整高度",
            "edit_semantics": (
                f"通过拉伸/切除识别到的{edit_label}端盖 Face 改变高度；这是局部端面移动，不是整体缩放。"
            ),
            **selected_cap,
        }

    def cylindrical_height_plan(self, face_id: int, target_height: float) -> dict[str, object]:
        return self.cylindrical_boss_height_plan(face_id, target_height, require_boss=False)

    def cylindrical_boss_height_preview_polydata(
        self,
        face_id: int,
        target_height: float,
        deflection: float = 0.8,
    ):
        plan = self.cylindrical_boss_height_plan(face_id, target_height)
        if plan["status"] == "blocked":
            raise ValueError(str(plan["message"]))
        return self.push_pull_preview_polydata(
            int(plan["boss_height_cap_face_id"]),
            float(plan["push_pull_distance"]),
            deflection,
        )

    def resize_cylindrical_boss_height(self, face_id: int, target_height: float) -> str:
        plan = self.cylindrical_boss_height_plan(face_id, target_height)
        if plan["status"] == "blocked":
            raise ValueError(str(plan["message"]))
        self._remember_face_target_logical_id(plan, face_id)
        part_id = int(plan.get("part_id", self.face_part_ids[face_id]))
        part = self.part_by_id(part_id)
        if part is None:
            raise ValueError(f"Unknown part id {part_id}")
        old_part_shape = part.shape
        verification: dict[str, object] = {}
        try:
            push_result = self.push_pull_face(
                int(plan["boss_height_cap_face_id"]),
                float(plan["push_pull_distance"]),
            )
            verification = self._verify_cylindrical_height_result(plan, part_id)
            if not verification.get("matched"):
                detail = str(verification.get("detail", "cylindrical height result verification failed"))
                raise RuntimeError(
                    "圆柱凸台高度修改返回了结果，但没有检测到达到目标高度且保留一级关系的圆柱面，"
                    "已回滚到修改前状态。"
                    f"{detail}"
                )
        except Exception:
            part.shape = old_part_shape
            self.refresh_topology()
            raise
        return (
            "Cylindrical boss height resize completed by end-cap push/pull: "
            f"face {face_id}, cap_face={plan.get('boss_height_cap_face_id')}, "
            f"current_height={float(plan['current_height']):g}, "
            f"target_height={float(plan['target_height']):g}, "
            f"delta={float(plan['delta_height']):g}, "
            f"push_pull_distance={float(plan['push_pull_distance']):g}, "
            f"risk={plan['risk']}, verified_face={verification.get('face_id', '')}. {push_result}"
        )

    def shell_thickness_preview_polydata(
        self,
        face_id: int,
        target_thickness: float,
        deflection: float = 0.8,
    ):
        plan = self.shell_thickness_plan(face_id, target_thickness)
        if plan["status"] == "blocked":
            raise ValueError(str(plan["message"]))
        return self.push_pull_preview_polydata(face_id, float(plan["push_pull_distance"]), deflection)

    def resize_shell_thickness(self, face_id: int, target_thickness: float) -> str:
        plan = self.shell_thickness_plan(face_id, target_thickness)
        if plan["status"] == "blocked":
            raise ValueError(str(plan["message"]))
        self._remember_face_target_logical_id(plan, face_id)
        push_result, result_check = self._run_checked_face_edit(
            plan,
            lambda: self.push_pull_face(face_id, float(plan["push_pull_distance"])),
        )
        return (
            "Shell thickness resize completed by planar push/pull: "
            f"face {face_id}, current_thickness={float(plan['shell_current_thickness']):g}, "
            f"target_thickness={float(plan['shell_target_thickness']):g}, "
            f"delta={float(plan['shell_delta_thickness']):g}, "
            f"opposite_face={plan.get('shell_opposite_face_id')}, "
            f"push_pull_distance={float(plan['push_pull_distance']):g}, "
            f"risk={plan['risk']}. {result_check} {push_result}"
        )

    def shell_thickness_owning_scale_plan(self, face_id: int, target_thickness: float) -> dict[str, object]:
        if face_id < 0 or face_id >= len(self.faces):
            raise ValueError(f"Unknown face id {face_id}")
        info = self.feature_info(face_id)
        blockers: list[str] = []
        warnings: list[str] = [
            "该方式会沿壳体厚度方向缩放所属特征或 Solid；它不是拉伸/切除当前平面，也不是局部壳命令参数。"
        ]
        risk = "medium"
        first_level_fields = self._face_first_level_plan_fields(face_id)

        try:
            target_thickness = float(target_thickness)
        except (TypeError, ValueError):
            target_thickness = 0.0
            blockers.append("目标壳体厚度必须是数字。")

        current_thickness = _float_or_none(info.get("shell_thickness_estimate"))
        signed_thickness = _float_or_none(info.get("shell_signed_thickness"))
        normal = _tuple_normalized(_tuple_or_none(info.get("normal")))
        plane_origin = _tuple_or_none(info.get("plane_origin"))
        if info.get("surface") != "plane":
            blockers.append("当前选中 Face 不是平面，不能按壳体厚度整体缩放。")
        if info.get("shell_region_status") != "candidate":
            blockers.append(str(info.get("shell_region_note", "当前平面没有识别到相对壳体平面。")))
        if current_thickness is None or current_thickness <= 1e-9:
            blockers.append("当前壳体厚度估算无效。")
        if signed_thickness is None or abs(signed_thickness) <= 1e-9:
            blockers.append("当前壳体厚度方向无效。")
        if normal is None:
            blockers.append("当前平面缺少稳定法向，不能按厚度方向整体缩放。")
        if target_thickness <= 1e-9:
            blockers.append("目标壳体厚度必须大于 0。")

        current_value = float(current_thickness or 0.0)
        scale = target_thickness / max(current_value, 1e-9)
        delta_thickness = target_thickness - current_value
        delta_ratio = abs(delta_thickness) / max(current_value, 1e-9)
        if current_thickness is not None and abs(delta_thickness) <= max(current_thickness * 1e-6, 1e-6):
            blockers.append("目标壳体厚度与当前值几乎相同，不需要修改。")
        if scale < 0.05:
            blockers.append("目标壳体厚度会把所属对象沿厚度方向缩放到当前值的 5% 以下，容易生成退化几何。")
        elif scale > 5.0:
            blockers.append("目标壳体厚度会把所属对象沿厚度方向放大到当前值的 5 倍以上，风险过高。")
        if delta_ratio > 0.75:
            risk = _max_risk(risk, "high")
            warnings.append("壳体厚度变化超过 75%，会明显影响所属对象上的其它厚度方向尺寸。")
        elif delta_ratio > 0.3:
            warnings.append("壳体厚度变化超过 30%，修改后请重点检查壁厚和相邻特征。")

        confidence = str(info.get("shell_confidence", "low"))
        overlap_ratio = _float_or_none(info.get("shell_overlap_ratio_estimate"))
        if confidence == "low":
            risk = _max_risk(risk, "high")
            warnings.append("壳体相对面识别置信度较低。")
        elif confidence == "medium":
            risk = _max_risk(risk, "medium")
            warnings.append("壳体相对面识别置信度为 medium，执行后请检查周边。")
        if overlap_ratio is not None:
            if overlap_ratio < 0.25:
                risk = _max_risk(risk, "high")
                warnings.append("相对平面投影重叠率较低，可能不是稳定壳体区域。")
            elif overlap_ratio < 0.55:
                risk = _max_risk(risk, "medium")
                warnings.append("相对平面投影重叠率一般，厚度估算可能偏局部。")

        scale_center = None
        if plane_origin is not None and normal is not None and signed_thickness is not None:
            scale_center = (
                plane_origin[0] + normal[0] * signed_thickness * 0.5,
                plane_origin[1] + normal[1] * signed_thickness * 0.5,
                plane_origin[2] + normal[2] * signed_thickness * 0.5,
            )
        scale_center = scale_center or _tuple_or_none(info.get("area_center")) or _tuple_or_none(info.get("bbox_center"))
        if scale_center is None:
            blockers.append("当前壳体区域缺少稳定缩放中心，不能整体缩放所属对象。")

        part_id = int(info.get("part_id", -1))
        solid_id = int(info.get("solid_id", -1))
        part = self.part_by_id(part_id) if part_id >= 0 else None
        if part is None:
            blockers.append("找不到当前壳体区域所属特征。")
            part_solid_count = 0
        else:
            part_solid_count = len(_explore(part.shape, TopAbs_SOLID))
        target_kind = "solid" if solid_id >= 0 and part_solid_count > 1 else "part"
        target_label = "Solid" if target_kind == "solid" else "特征"
        warnings.append(f"当前会沿壳体厚度方向缩放所属{target_label}；同一对象上的其它尺寸会跟随变化。")

        owning_rebuild_mode = "affine-transform"
        point_targets: tuple[tuple[tuple[float, float, float], tuple[float, float, float]], ...] = ()
        face_count = 0
        solid = self.solids[solid_id][1] if 0 <= solid_id < len(self.solids) else None
        if not blockers and solid is not None and scale_center is not None and normal is not None:
            solid_faces = _explore(solid, TopAbs_FACE)
            face_count = len(solid_faces)
            can_rebuild_planar = bool(solid_faces) and face_count <= 128
            if not solid_faces:
                warnings.append("所属对象没有可重建 Face，将使用通用仿射缩放。")
            elif face_count > 128:
                warnings.append("所属对象 Face 数较多，将使用通用仿射缩放。")
            if can_rebuild_planar:
                tolerance = max(_shape_diagonal(solid) * 1e-7, abs(delta_thickness) * 1e-7, 1e-6)
                for face in solid_faces:
                    surf = BRepAdaptor_Surface(face)
                    if surf.GetType() != GeomAbs_Plane:
                        can_rebuild_planar = False
                        warnings.append("所属对象含曲面，将使用通用仿射缩放；部分解析几何可能变为 B-spline。")
                        break
                    if len(_explore(face, TopAbs_WIRE)) != 1:
                        can_rebuild_planar = False
                        warnings.append("所属对象包含带内孔的 Face，将使用通用仿射缩放。")
                        break
                    if len(self._local_deform_face_vertex_points(face, tolerance)) < 3:
                        can_rebuild_planar = False
                        warnings.append("所属对象部分 Face 顶点环无法稳定读取，将使用通用仿射缩放。")
                        break
            if can_rebuild_planar:
                target_by_key: dict[tuple[int, int, int], tuple[tuple[float, float, float], tuple[float, float, float]]] = {}
                tolerance = max(_shape_diagonal(solid) * 1e-7, abs(delta_thickness) * 1e-7, 1e-6)
                for face in solid_faces:
                    for point in self._local_deform_face_vertex_points(face, tolerance):
                        key = self._local_point_key(point, tolerance)
                        if key in target_by_key:
                            continue
                        relative = _tuple_sub(point, scale_center)
                        along = _tuple_dot(relative, normal)
                        axial = _tuple_scale(normal, along)
                        rest = _tuple_sub(relative, axial)
                        moved = _tuple_add(scale_center, _tuple_add(rest, _tuple_scale(normal, along * scale)))
                        target_by_key[key] = (point, moved)
                point_targets = tuple(target_by_key.values())
                if point_targets:
                    owning_rebuild_mode = "planar-rebuild"
                    warnings.append("当前所属对象是简单全平面实体，会优先重建平面 Face，避免整体缩放后变成样条面。")

        status = "blocked" if blockers else "caution"
        if blockers:
            risk = "blocked"
        return {
            "status": status,
            "risk": risk,
            "message": " ".join(blockers + warnings),
            "warnings": "；".join(warnings),
            "blockers": "；".join(blockers),
            "face_id": face_id,
            "part_id": part_id,
            "solid_id": solid_id,
            **first_level_fields,
            "surface": info.get("surface"),
            "shell_region_kind": info.get("shell_region_kind"),
            "shell_confidence": confidence,
            "shell_source_face_ids": tuple(_int_values(info.get("shell_source_face_ids")) or [face_id]),
            "shell_opposite_face_id": info.get("shell_opposite_face_id"),
            "shell_current_thickness": current_thickness,
            "shell_target_thickness": target_thickness,
            "shell_delta_thickness": delta_thickness,
            "shell_delta_ratio": delta_ratio,
            "shell_signed_thickness": signed_thickness,
            "shell_overlap_ratio_estimate": overlap_ratio,
            "shell_opposite_normal_dot": info.get("shell_opposite_normal_dot"),
            "resize_strategy": "axis-scale-owning-shape-from-shell-thickness",
            "edit_strategy_label": "壳体厚度(缩放特征)",
            "edit_semantics": (
                "按目标壳体厚度和当前厚度的比例，沿厚度方向缩放所属特征或 Solid；"
                "这会改变同一对象上的其它尺寸，不是局部拉伸/切除当前平面。"
            ),
            "affine_scale": scale,
            "affine_transform_kind": "axis-affine",
            "affine_transform_label": f"按壳体厚度方向缩放所属{target_label}",
            "affine_transform_note": "单向仿射缩放可能把部分解析几何转换成 B-spline，并会改变同一对象上的其它尺寸。",
            "affine_axis_point": scale_center,
            "affine_axis_direction": normal or (0.0, 0.0, 1.0),
            "affine_axis_source": "shell thickness normal",
            "affine_anchor_source": "midpoint between source and opposite plane",
            "affine_target_kind": target_kind,
            "part_solid_count": part_solid_count,
            "owning_shell_thickness_rebuild_mode": owning_rebuild_mode,
            "local_face_deform_target_kind": target_kind,
            "local_face_deform_face_count": face_count,
            "local_face_deform_source_point_targets": point_targets,
            "local_face_deform_moved_point_count": len(point_targets),
            "local_face_deform_distance_hint": abs(delta_thickness),
        }

    def resize_shell_thickness_owning_scale(self, face_id: int, target_thickness: float) -> str:
        plan = self.shell_thickness_owning_scale_plan(face_id, target_thickness)
        if plan["status"] == "blocked":
            raise ValueError(str(plan["message"]))
        self._remember_face_target_logical_id(plan, face_id)
        _action_result, result_check = self._run_checked_face_edit(
            plan,
            lambda: (
                self._apply_local_face_deform(plan)
                if plan.get("owning_shell_thickness_rebuild_mode") == "planar-rebuild"
                else self._apply_edge_length_affine_transform(plan)
            ),
        )
        return (
            "Shell thickness resize completed by axis owning-shape scaling: "
            f"face {face_id}, "
            f"thickness={float(plan['shell_current_thickness']):g}->{float(plan['shell_target_thickness']):g}, "
            f"scale={float(plan['affine_scale']):g}, "
            f"rebuild_mode={plan.get('owning_shell_thickness_rebuild_mode')}, "
            f"target={plan.get('affine_target_kind')}, "
            f"risk={plan['risk']}. {result_check}"
        )

    def resize_cylindrical_height(self, face_id: int, target_height: float) -> str:
        plan = self.cylindrical_height_plan(face_id, target_height)
        if plan["status"] == "blocked":
            raise ValueError(str(plan["message"]))
        self._remember_face_target_logical_id(plan, face_id)
        part_id = int(plan.get("part_id", self.face_part_ids[face_id]))
        part = self.part_by_id(part_id)
        if part is None:
            raise ValueError(f"Unknown part id {part_id}")
        old_part_shape = part.shape
        verification: dict[str, object] = {}
        try:
            push_result = self.push_pull_face(
                int(plan["boss_height_cap_face_id"]),
                float(plan["push_pull_distance"]),
            )
            verification = self._verify_cylindrical_height_result(plan, part_id)
            if not verification.get("matched"):
                detail = str(verification.get("detail", "cylindrical height result verification failed"))
                raise RuntimeError(
                    "圆柱高度修改返回了结果，但没有检测到达到目标高度且保留一级关系的圆柱面，"
                    "已回滚到修改前状态。"
                    f"{detail}"
                )
        except Exception:
            part.shape = old_part_shape
            self.refresh_topology()
            raise
        return (
            "Cylindrical height resize completed by end-cap push/pull: "
            f"face {face_id}, cap_face={plan.get('boss_height_cap_face_id')}, "
            f"current_height={float(plan['current_height']):g}, "
            f"target_height={float(plan['target_height']):g}, "
            f"delta={float(plan['delta_height']):g}, "
            f"push_pull_distance={float(plan['push_pull_distance']):g}, "
            f"risk={plan['risk']}, verified_face={verification.get('face_id', '')}. {push_result}"
        )

    def cylindrical_height_owning_scale_plan(self, face_id: int, target_height: float) -> dict[str, object]:
        if face_id < 0 or face_id >= len(self.faces):
            raise ValueError(f"Unknown face id {face_id}")
        info = self.face_info(face_id)
        try:
            feature = self.feature_info(face_id)
        except Exception:
            feature = {}
        topology_fields = (
            self._cylindrical_feature_first_level_plan_fields(face_id)
            if info.get("surface") == "cylinder"
            else {}
        )
        blockers: list[str] = []
        warnings: list[str] = [
            "该方式会沿当前圆柱轴向缩放所属特征或 Solid；它不是拉伸/切除某个端盖，也不是只修改单个圆柱面。"
        ]
        risk = "medium"

        try:
            target_height = float(target_height)
        except (TypeError, ValueError):
            target_height = 0.0
            blockers.append("目标圆柱高度必须是数字。")

        axis_point = _tuple_or_none(info.get("axis_point"))
        axis_direction = _tuple_normalized(_tuple_or_none(info.get("axis")))
        current_height = _float_or_none(info.get("same_domain_height_estimate"))
        if current_height is None:
            current_height = _float_or_none(info.get("height_estimate"))
        axis_range_value = info.get("same_domain_v_range") or info.get("v_range")
        if (
            current_height is None
            and info.get("surface") == "cylinder"
            and 0 <= face_id < len(self.faces)
        ):
            try:
                axis_range = self._cylindrical_axis_range(
                    face_id,
                    BRepAdaptor_Surface(self.faces[face_id]),
                    _int_values(feature.get("feature_side_face_ids")),
                )
                current_height = _float_or_none(axis_range.get("span"))
                axis_range_value = (axis_range.get("v_min"), axis_range.get("v_max"))
            except Exception:
                pass

        if info.get("surface") != "cylinder":
            blockers.append("当前选中 Face 不是圆柱面。")
        cylinder_identity = {**info, **feature}
        angular_span = _effective_cylinder_angular_span(cylinder_identity)
        if angular_span is not None and not _is_effectively_full_cylinder(cylinder_identity):
            risk = _max_risk(risk, "high")
            warnings.append("当前圆柱面不是完整圆柱；轴向整体缩放会影响所属对象，但不等于稳定的局部槽/半孔高度编辑。")
        if current_height is None or current_height <= 1e-9:
            blockers.append("当前圆柱缺少稳定高度估算，不能按高度整体缩放。")
        if axis_point is None or axis_direction is None:
            blockers.append("当前圆柱缺少稳定轴线，不能沿轴向整体缩放。")
        if target_height <= 1e-9:
            blockers.append("目标圆柱高度必须大于 0。")

        scale_center = None
        if (
            axis_point is not None
            and axis_direction is not None
            and isinstance(axis_range_value, (list, tuple))
            and len(axis_range_value) >= 2
        ):
            v_min = _float_or_none(axis_range_value[0])
            v_max = _float_or_none(axis_range_value[1])
            if v_min is not None and v_max is not None:
                v_mid = (v_min + v_max) * 0.5
                scale_center = (
                    axis_point[0] + axis_direction[0] * v_mid,
                    axis_point[1] + axis_direction[1] * v_mid,
                    axis_point[2] + axis_direction[2] * v_mid,
                )
        scale_center = scale_center or _tuple_or_none(info.get("area_center")) or _tuple_or_none(info.get("bbox_center"))
        if scale_center is None:
            blockers.append("当前圆柱缺少稳定缩放中心，不能整体缩放所属对象。")

        current_height_value = float(current_height or 0.0)
        scale = target_height / max(current_height_value, 1e-9)
        delta_height = target_height - current_height_value
        delta_ratio = abs(delta_height) / max(current_height_value, 1e-9)
        if current_height is not None and abs(delta_height) <= max(current_height * 1e-6, 1e-6):
            blockers.append("目标圆柱高度与当前值几乎相同，不需要修改。")
        if delta_ratio > 0.6:
            risk = _max_risk(risk, "high")
            warnings.append("圆柱高度变化超过 60%，会明显影响同一对象上的其它几何位置。")
        elif delta_ratio > 0.25:
            warnings.append("圆柱高度变化超过 25%，修改后请重点检查相邻特征。")

        part_id = int(info.get("part_id", -1))
        solid_id = int(info.get("solid_id", -1))
        part = self.part_by_id(part_id) if part_id >= 0 else None
        if part is None:
            blockers.append("找不到当前圆柱面所属特征。")
            part_solid_count = 0
        else:
            part_solid_count = len(_explore(part.shape, TopAbs_SOLID))
        target_kind = "solid" if solid_id >= 0 and part_solid_count > 1 else "part"
        target_label = "Solid" if target_kind == "solid" else "特征"
        warnings.append(f"当前会沿圆柱轴向缩放所属{target_label}；同一对象上的孔距、台阶位置和其它轴向尺寸会跟随变化。")

        status = "blocked" if blockers else "caution"
        if blockers:
            risk = "blocked"
        return {
            "status": status,
            "risk": risk,
            "message": " ".join(blockers + warnings),
            "warnings": "；".join(warnings),
            "blockers": "；".join(blockers),
            "face_id": face_id,
            "part_id": part_id,
            "solid_id": solid_id,
            "surface": info.get("surface"),
            "feature_type": feature.get("feature_type"),
            "feature_guess": info.get("feature_guess"),
            "confidence": info.get("confidence"),
            "current_height": current_height,
            "target_height": target_height,
            "delta_height": delta_height,
            "height_delta_ratio": delta_ratio,
            "diameter": info.get("diameter"),
            "radius": info.get("radius"),
            "axis": axis_direction,
            "axis_point": axis_point,
            "scale_center": scale_center,
            "resize_strategy": "axis-scale-owning-shape-from-cylinder-height",
            "edit_strategy_label": "高度(缩放特征)",
            "edit_semantics": (
                "按目标圆柱高度和当前高度的比例，沿圆柱轴向缩放所属特征或 Solid；"
                "这会改变同一对象上的其它轴向尺寸，不是端盖拉伸/切除。"
            ),
            "affine_scale": scale,
            "affine_transform_kind": "axis-affine",
            "affine_transform_label": f"按圆柱高度轴向缩放所属{target_label}",
            "affine_transform_note": "单向仿射缩放可能把部分解析几何转换成 B-spline，并会改变同一对象上的其它轴向尺寸。",
            "affine_axis_point": scale_center,
            "affine_axis_direction": axis_direction or (0.0, 0.0, 1.0),
            "affine_axis_source": "cylinder axis",
            "affine_anchor_source": "cylinder axis center",
            "affine_target_kind": target_kind,
            "part_solid_count": part_solid_count,
            **topology_fields,
        }

    def resize_cylindrical_height_owning_scale(self, face_id: int, target_height: float) -> str:
        plan = self.cylindrical_height_owning_scale_plan(face_id, target_height)
        if plan["status"] == "blocked":
            raise ValueError(str(plan["message"]))
        self._remember_face_target_logical_id(plan, face_id)
        part_id = int(plan.get("part_id", self.face_part_ids[face_id]))
        part = self.part_by_id(part_id)
        if part is None:
            raise ValueError(f"Unknown part id {part_id}")
        old_part_shape = part.shape
        verification: dict[str, object] = {}
        try:
            self._apply_edge_length_affine_transform(plan)
            verification = self._verify_axis_height_span_result(plan, part_id)
            if not verification.get("matched"):
                detail = str(verification.get("detail", "axis height span verification failed"))
                raise RuntimeError(
                    "圆柱高度整体缩放返回了结果，但所属对象的轴向跨度没有达到目标高度，"
                    "已回滚到修改前状态。"
                    f"{detail}"
                )
        except Exception:
            part.shape = old_part_shape
            self.refresh_topology()
            raise
        return (
            "Cylindrical height resize completed by axis owning-shape scaling: "
            f"face {face_id}, "
            f"height={float(plan['current_height']):g}->{float(plan['target_height']):g}, "
            f"scale={float(plan['affine_scale']):g}, "
            f"target={plan.get('affine_target_kind')}, "
            f"risk={plan['risk']}, verified_axis_span={_format_result_number(verification.get('axis_span'))}."
        )

    def cylindrical_depth_owning_scale_plan(
        self,
        face_id: int,
        target_depth: float,
        bottom_face_id: int | None = None,
    ) -> dict[str, object]:
        if face_id < 0 or face_id >= len(self.faces):
            raise ValueError(f"Unknown face id {face_id}")
        info = self.face_info(face_id)
        try:
            feature = self.feature_info(face_id)
        except Exception:
            feature = {}
        blockers: list[str] = []
        warnings: list[str] = [
            "该方式会沿盲孔/盲槽轴向缩放所属特征或 Solid；它不是加深切削，也不是变浅补料。"
        ]
        risk = "medium"

        try:
            target_depth = float(target_depth)
        except (TypeError, ValueError):
            target_depth = 0.0
            blockers.append("目标盲孔/盲槽深度必须是数字。")

        if info.get("surface") != "cylinder":
            blockers.append("当前选中 Face 不是圆柱面。")
        if str(info.get("feature_guess", "")) != "hole/groove candidate":
            blockers.append("深度(缩放特征)当前只对孔/槽候选开放。")
        if target_depth <= 1e-9:
            blockers.append("目标盲孔/盲槽深度必须大于 0。")

        context: dict[str, object] = {}
        if info.get("surface") == "cylinder":
            try:
                context = self._blind_cylindrical_depth_context(
                    face_id,
                    info,
                    feature,
                    max(target_depth, 1e-6),
                    bottom_face_id=bottom_face_id,
                )
            except Exception as exc:
                context = {"context_status": "blocked", "context_message": str(exc)}
        if context.get("context_status") == "blocked":
            blockers.append(str(context.get("context_message") or "当前盲孔/盲槽深度方向不稳定。"))

        current_depth = _float_or_none(context.get("depth_current_depth"))
        if current_depth is None:
            current_depth = _float_or_none(info.get("hole_depth_estimate"))
        if current_depth is None:
            current_depth = _float_or_none(info.get("same_domain_height_estimate"))
        if current_depth is None or current_depth <= 1e-9:
            blockers.append("当前对象缺少稳定深度估算，不能按深度整体缩放。")

        axis_direction = _tuple_normalized(_tuple_or_none(context.get("depth_axis_direction")))
        if axis_direction is None:
            axis_direction = _tuple_normalized(_tuple_or_none(info.get("axis")))
        if axis_direction is None:
            blockers.append("当前对象缺少稳定轴线方向，不能按深度整体缩放。")

        scale_center = None
        open_point = _tuple_or_none(context.get("depth_open_point"))
        bottom_point = _tuple_or_none(context.get("depth_current_bottom_point"))
        if open_point is not None and bottom_point is not None:
            scale_center = (
                (open_point[0] + bottom_point[0]) * 0.5,
                (open_point[1] + bottom_point[1]) * 0.5,
                (open_point[2] + bottom_point[2]) * 0.5,
            )
        scale_center = scale_center or _tuple_or_none(info.get("area_center")) or _tuple_or_none(info.get("bbox_center"))
        if scale_center is None:
            blockers.append("当前对象缺少稳定缩放中心，不能整体缩放所属对象。")

        current_depth_value = float(current_depth or 0.0)
        scale = target_depth / max(current_depth_value, 1e-9)
        delta_depth = target_depth - current_depth_value
        delta_ratio = abs(delta_depth) / max(current_depth_value, 1e-9)
        if current_depth is not None and abs(delta_depth) <= max(current_depth * 1e-6, 1e-6):
            blockers.append("目标盲孔/盲槽深度与当前值几乎相同，不需要修改。")
        if delta_ratio > 0.75:
            risk = _max_risk(risk, "high")
            warnings.append("盲孔/盲槽深度变化超过 75%，会明显影响所属对象上的其它轴向尺寸。")
        elif delta_ratio > 0.3:
            warnings.append("盲孔/盲槽深度变化超过 30%，修改后请重点检查相邻特征和壁厚。")

        cylinder_identity = {**info, **feature}
        angular_span = _effective_cylinder_angular_span(cylinder_identity)
        if angular_span is not None and not _is_effectively_full_cylinder(cylinder_identity):
            risk = _max_risk(risk, "high")
            warnings.append("当前是局部圆柱槽/半孔；整体缩放会改变所属对象，不等于稳定的局部槽底调整。")

        part_id = int(info.get("part_id", -1))
        solid_id = int(info.get("solid_id", -1))
        part = self.part_by_id(part_id) if part_id >= 0 else None
        if part is None:
            blockers.append("找不到当前对象所属特征。")
            part_solid_count = 0
        else:
            part_solid_count = len(_explore(part.shape, TopAbs_SOLID))
        target_kind = "solid" if solid_id >= 0 and part_solid_count > 1 else "part"
        target_label = "Solid" if target_kind == "solid" else "特征"
        warnings.append(f"当前会沿盲孔/盲槽方向缩放所属{target_label}；孔距、壁厚和其它同向尺寸会跟随变化。")

        status = "blocked" if blockers else "caution"
        if blockers:
            risk = "blocked"
        return {
            "status": status,
            "risk": risk,
            "message": " ".join(blockers + warnings),
            "warnings": "；".join(warnings),
            "blockers": "；".join(blockers),
            "face_id": face_id,
            "part_id": part_id,
            "solid_id": solid_id,
            "surface": info.get("surface"),
            "feature_type": feature.get("feature_type"),
            "feature_guess": info.get("feature_guess"),
            "confidence": info.get("confidence"),
            "current_depth": current_depth,
            "target_depth": target_depth,
            "delta_depth": delta_depth,
            "depth_delta_ratio": delta_ratio,
            "diameter": info.get("diameter"),
            "radius": info.get("radius"),
            "angular_span": info.get("angular_span"),
            "cylinder_end_type": info.get("cylinder_end_type"),
            "feature_bottom_face_ids": context.get("feature_bottom_face_ids", feature.get("feature_bottom_face_ids")),
            "manual_bottom_face_id": context.get("manual_bottom_face_id", "" if bottom_face_id is None else bottom_face_id),
            "manual_bottom_face_used": bool(context.get("manual_bottom_face_used", bottom_face_id is not None)),
            "feature_opening_face_ids": feature.get("feature_opening_face_ids"),
            "depth_open_point": context.get("depth_open_point"),
            "depth_current_bottom_point": context.get("depth_current_bottom_point"),
            "depth_current_depth_source": context.get("depth_current_depth_source", ""),
            "resize_strategy": "axis-scale-owning-shape-from-blind-depth",
            "edit_strategy_label": "盲孔/盲槽深度(缩放特征)",
            "edit_semantics": (
                "按目标盲孔/盲槽深度和当前深度的比例，沿孔/槽轴向缩放所属特征或 Solid；"
                "这会改变同一对象上的其它轴向尺寸，不是局部切削或补料。"
            ),
            "affine_scale": scale,
            "affine_transform_kind": "axis-affine",
            "affine_transform_label": f"按盲孔/盲槽深度轴向缩放所属{target_label}",
            "affine_transform_note": "单向仿射缩放可能把部分解析几何转换成 B-spline，并会改变同一对象上的其它轴向尺寸。",
            "affine_axis_point": scale_center,
            "affine_axis_direction": axis_direction or (0.0, 0.0, 1.0),
            "affine_axis_source": "blind depth direction",
            "affine_anchor_source": "blind depth midpoint",
            "affine_target_kind": target_kind,
            "part_solid_count": part_solid_count,
        }

    def resize_cylindrical_depth_owning_scale(
        self,
        face_id: int,
        target_depth: float,
        bottom_face_id: int | None = None,
    ) -> str:
        plan = self.cylindrical_depth_owning_scale_plan(
            face_id,
            target_depth,
            bottom_face_id=bottom_face_id,
        )
        if plan["status"] == "blocked":
            raise ValueError(str(plan["message"]))
        self._remember_face_target_logical_id(plan, face_id)
        part_id = int(plan.get("part_id", self.face_part_ids[face_id]))
        part = self.part_by_id(part_id)
        if part is None:
            raise ValueError(f"Unknown part id {part_id}")
        old_part_shape = part.shape
        verification: dict[str, object] = {}
        try:
            self._apply_edge_length_affine_transform(plan)
            verification = self._verify_cylindrical_depth_result(plan, part_id)
            if not verification.get("matched"):
                detail = str(verification.get("detail", "blind cylindrical depth verification failed"))
                raise RuntimeError(
                    "Blind cylindrical depth owning-scale returned a shape, but no target-depth blind "
                    f"cylindrical feature was detected after the edit; rolled back to the previous model. {detail}"
                )
        except Exception:
            part.shape = old_part_shape
            self.refresh_topology()
            raise
        return (
            "Blind cylindrical depth resize completed by axis owning-shape scaling: "
            f"face {face_id}, "
            f"depth={float(plan['current_depth']):g}->{float(plan['target_depth']):g}, "
            f"scale={float(plan['affine_scale']):g}, "
            f"target={plan.get('affine_target_kind')}, "
            f"risk={plan['risk']}, verified_face={verification.get('face_id', '')}."
        )

    def cylindrical_owning_scale_plan(self, face_id: int, target_diameter: float) -> dict[str, object]:
        if face_id < 0 or face_id >= len(self.faces):
            raise ValueError(f"Unknown face id {face_id}")
        info = self.face_info(face_id)
        blockers: list[str] = []
        warnings: list[str] = [
            "该方式会按目标直径比例均匀缩放所属特征或 Solid；它不是重切孔壁，也不是只修改单个圆柱面。"
        ]
        risk = "medium"

        try:
            target_diameter = float(target_diameter)
        except (TypeError, ValueError):
            target_diameter = 0.0
            blockers.append("目标圆柱直径必须是数字。")

        current_diameter = _float_or_none(info.get("diameter"))
        current_radius = _float_or_none(info.get("radius"))
        axis_point = _tuple_or_none(info.get("axis_point"))
        axis_direction = _tuple_normalized(_tuple_or_none(info.get("axis")))
        topology_fields = (
            self._cylindrical_feature_first_level_plan_fields(face_id)
            if info.get("surface") == "cylinder"
            else {}
        )
        if info.get("surface") != "cylinder":
            blockers.append("当前选中 Face 不是圆柱面。")
        if current_diameter is None or current_diameter <= 1e-9:
            blockers.append("当前圆柱面缺少有效直径。")
        axis_range_value = info.get("same_domain_v_range") or info.get("v_range")
        scale_center = None
        if (
            axis_point is not None
            and axis_direction is not None
            and isinstance(axis_range_value, (list, tuple))
            and len(axis_range_value) >= 2
        ):
            v_min = _float_or_none(axis_range_value[0])
            v_max = _float_or_none(axis_range_value[1])
            if v_min is not None and v_max is not None:
                v_mid = (v_min + v_max) * 0.5
                scale_center = (
                    axis_point[0] + axis_direction[0] * v_mid,
                    axis_point[1] + axis_direction[1] * v_mid,
                    axis_point[2] + axis_direction[2] * v_mid,
                )
        scale_center = scale_center or _tuple_or_none(info.get("area_center")) or _tuple_or_none(info.get("bbox_center"))
        if scale_center is None:
            blockers.append("当前圆柱面缺少稳定缩放中心，不能缩放所属对象。")
        if target_diameter <= 1e-9:
            blockers.append("目标圆柱直径必须大于 0。")

        scale = target_diameter / max(current_diameter or 1.0, 1e-9)
        delta_diameter = target_diameter - float(current_diameter or 0.0)
        delta_ratio = abs(delta_diameter) / max(float(current_diameter or 0.0), 1e-9)
        if current_diameter is not None and abs(delta_diameter) <= max(current_diameter * 1e-6, 1e-6):
            blockers.append("目标圆柱直径与当前值几乎相同，不需要修改。")
        if delta_ratio > 0.5:
            risk = _max_risk(risk, "high")
            warnings.append("圆柱直径变化超过 50%，会明显影响同一对象上的高度、厚度和其它尺寸。")
        elif delta_ratio > 0.2:
            warnings.append("圆柱直径变化超过 20%，修改后请重点检查相邻特征。")

        part_id = int(info.get("part_id", -1))
        solid_id = int(info.get("solid_id", -1))
        part = self.part_by_id(part_id) if part_id >= 0 else None
        if part is None:
            blockers.append("找不到当前圆柱面所属特征。")
            part_solid_count = 0
        else:
            part_solid_count = len(_explore(part.shape, TopAbs_SOLID))
        target_kind = "solid" if solid_id >= 0 and part_solid_count > 1 else "part"
        target_label = "Solid" if target_kind == "solid" else "特征"
        warnings.append(f"当前会均匀缩放所属{target_label}，同一对象上的高度、厚度和其它尺寸会同比例变化。")

        status = "blocked" if blockers else "caution"
        if blockers:
            risk = "blocked"
        return {
            "status": status,
            "risk": risk,
            "message": " ".join(blockers + warnings),
            "warnings": "；".join(warnings),
            "blockers": "；".join(blockers),
            "face_id": face_id,
            "part_id": part_id,
            "solid_id": solid_id,
            "surface": info.get("surface"),
            "feature_type": info.get("feature_type"),
            "feature_guess": info.get("feature_guess"),
            "confidence": info.get("confidence"),
            "current_diameter": current_diameter,
            "target_diameter": target_diameter,
            "current_radius": current_radius,
            "target_radius": target_diameter * 0.5,
            "delta_diameter": delta_diameter,
            "diameter_delta_ratio": delta_ratio,
            "scale_center": scale_center,
            "axis_point": axis_point,
            "axis": axis_direction,
            "cutter_axis_point": axis_point,
            "cutter_axis_direction": axis_direction,
            "resize_strategy": "uniform-scale-owning-shape-from-cylinder-diameter",
            "edit_strategy_label": "按圆柱直径缩放所属对象",
            "edit_semantics": (
                "按目标圆柱直径和当前直径的比例，围绕当前圆柱面的轴向中心均匀缩放所属特征或 Solid；"
                "高度、厚度和同一对象上的其它尺寸会同比例变化。"
            ),
            "affine_scale": scale,
            "affine_transform_kind": "uniform",
            "affine_transform_label": "按圆柱直径均匀缩放所属对象",
            "affine_axis_point": scale_center,
            "affine_axis_direction": axis_direction or (0.0, 0.0, 1.0),
            "affine_axis_source": "cylinder axis center",
            "affine_anchor_source": "cylinder axis center",
            "affine_target_kind": target_kind,
            "part_solid_count": part_solid_count,
            **topology_fields,
        }

    def resize_cylindrical_owning_scale(self, face_id: int, target_diameter: float) -> str:
        plan = self.cylindrical_owning_scale_plan(face_id, target_diameter)
        if plan["status"] == "blocked":
            raise ValueError(str(plan["message"]))
        self._remember_face_target_logical_id(plan, face_id)
        part_id = int(plan.get("part_id", self.face_part_ids[face_id]))
        part = self.part_by_id(part_id)
        if part is None:
            raise ValueError(f"Unknown part id {part_id}")
        old_part_shape = part.shape
        verification: dict[str, object] = {}
        try:
            self._apply_edge_length_affine_transform(plan)
            verification = self._verify_cylindrical_resize_result(plan, part_id)
            if not verification.get("matched"):
                detail = str(verification.get("detail", "cylindrical diameter verification failed"))
                raise RuntimeError(
                    "Cylindrical owning-scale returned a shape, but no target-diameter cylindrical Face "
                    f"was detected after the edit; rolled back to the previous model. {detail}"
                )
        except Exception:
            part.shape = old_part_shape
            self.refresh_topology()
            raise
        return (
            "Cylindrical diameter resize completed by uniform owning-shape scaling: "
            f"face {face_id}, "
            f"diameter={float(plan['current_diameter']):g}->{float(plan['target_diameter']):g}, "
            f"scale={float(plan['affine_scale']):g}, "
            f"target={plan.get('affine_target_kind')}, "
            f"risk={plan['risk']}, verified_face={verification.get('face_id', '')}."
        )

    def conical_reference_radius_plan(self, face_id: int, target_radius: float) -> dict[str, object]:
        if face_id < 0 or face_id >= len(self.faces):
            raise ValueError(f"Unknown face id {face_id}")
        info = self.face_info(face_id)
        blockers: list[str] = []
        warnings: list[str] = [
            "圆锥面参考半径修改会围绕圆锥轴径向缩放所属零件/Solid；这是 B-Rep 几何缩放，不是 CAD 历史参数。"
        ]
        risk = "medium"

        try:
            target_radius = float(target_radius)
        except (TypeError, ValueError):
            target_radius = 0.0
            blockers.append("目标圆锥参考半径必须是数字。")

        current_radius = _float_or_none(info.get("reference_radius"))
        axis_point = _tuple_or_none(info.get("axis_point"))
        axis_direction = _tuple_normalized(_tuple_or_none(info.get("axis")))
        if info.get("surface") != "cone":
            blockers.append("当前选中 Face 不是圆锥面。")
        if current_radius is None or current_radius <= 1e-9:
            blockers.append("当前圆锥面缺少有效参考半径。")
        if axis_point is None or axis_direction is None:
            blockers.append("当前圆锥面缺少稳定轴线，不能做径向缩放。")
        if target_radius <= 1e-9:
            blockers.append("目标圆锥参考半径必须大于 0。")

        scale = target_radius / max(current_radius or 1.0, 1e-9)
        current_semi_angle = _float_or_none(info.get("semi_angle"))
        current_semi_angle_degrees = None
        target_semi_angle = None
        target_semi_angle_degrees = None
        if current_semi_angle is not None:
            current_semi_angle_degrees = abs(math.degrees(current_semi_angle))
            current_tangent = abs(math.tan(current_semi_angle))
            if current_tangent > 1e-9 and scale > 0:
                target_semi_angle = math.atan(current_tangent * scale)
                target_semi_angle_degrees = math.degrees(target_semi_angle)
        delta_radius = target_radius - float(current_radius or 0.0)
        delta_ratio = abs(delta_radius) / max(float(current_radius or 0.0), 1e-9)
        if current_radius is not None and abs(delta_radius) <= max(current_radius * 1e-6, 1e-6):
            blockers.append("目标圆锥参考半径与当前值几乎相同，不需要修改。")
        if delta_ratio > 0.6:
            risk = _max_risk(risk, "high")
            warnings.append("圆锥参考半径变化超过 60%，可能明显影响周边几何。")
        elif delta_ratio > 0.25:
            risk = _max_risk(risk, "high")
            warnings.append("圆锥参考半径变化超过 25%，修改后请重点检查相邻面。")

        part_id = int(info.get("part_id", -1))
        solid_id = int(info.get("solid_id", -1))
        part = self.part_by_id(part_id) if part_id >= 0 else None
        if part is None:
            blockers.append("找不到当前圆锥面所属零件。")
            part_solid_count = 0
        else:
            part_solid_count = len(_explore(part.shape, TopAbs_SOLID))
        target_kind = "solid" if solid_id >= 0 and part_solid_count > 1 else "part"
        if target_kind == "part":
            warnings.append("当前会缩放所属零件 shape，可能影响同一零件上的其它尺寸。")
        else:
            warnings.append("当前会缩放所属 Solid，可能影响同一 Solid 上的其它尺寸。")

        status = "blocked" if blockers else "caution"
        if blockers:
            risk = "blocked"
        plan = {
            "status": status,
            "risk": risk,
            "message": " ".join(blockers + warnings),
            "warnings": "；".join(warnings),
            "blockers": "；".join(blockers),
            "face_id": face_id,
            "part_id": part_id,
            "solid_id": solid_id,
            "surface": info.get("surface"),
            "current_reference_radius": current_radius,
            "target_reference_radius": target_radius,
            "current_reference_diameter": None if current_radius is None else current_radius * 2.0,
            "target_reference_diameter": target_radius * 2.0,
            "delta_reference_radius": delta_radius,
            "reference_radius_delta_ratio": delta_ratio,
            "semi_angle": current_semi_angle,
            "semi_angle_degrees": current_semi_angle_degrees,
            "target_semi_angle": target_semi_angle,
            "target_semi_angle_degrees": target_semi_angle_degrees,
            "axis_point": axis_point,
            "axis": axis_direction,
            "resize_strategy": "radial-affine-scale-cone-reference-radius",
            "edit_strategy_label": "围绕圆锥轴径向缩放",
            "edit_semantics": "按目标参考半径围绕圆锥轴径向缩放所属对象；会影响同一对象上的其它径向尺寸。",
            "affine_scale": scale,
            "affine_transform_kind": "radial-affine",
            "affine_transform_label": "围绕圆锥轴径向缩放",
            "affine_axis_point": axis_point,
            "affine_axis_direction": axis_direction,
            "affine_axis_source": "cone axis",
            "affine_anchor_source": "cone axis point",
            "affine_target_kind": target_kind,
            "part_solid_count": part_solid_count,
        }
        self._annotate_simple_conical_rebuild_plan(plan, "reference-radius")
        self._block_obvious_complex_conical_fallback_plan(plan, "reference-radius")
        self._annotate_embedded_conical_recut_plan(plan, "reference-radius")
        self._block_unstable_conical_reference_radius_plan(plan)
        return plan

    def conical_semi_angle_plan(self, face_id: int, target_angle_degrees: float) -> dict[str, object]:
        if face_id < 0 or face_id >= len(self.faces):
            raise ValueError(f"Unknown face id {face_id}")
        info = self.quick_face_info(face_id)
        blockers: list[str] = []
        warnings: list[str] = [
            "圆锥半角修改会换算为围绕圆锥轴的径向缩放；高度不变，两个端面半径会按同一比例变化。"
        ]
        try:
            target_angle_degrees = float(target_angle_degrees)
        except (TypeError, ValueError):
            target_angle_degrees = 0.0
            blockers.append("目标圆锥半角必须是数字。")

        current_radius = _float_or_none(info.get("reference_radius"))
        current_angle = _float_or_none(info.get("semi_angle"))
        if info.get("surface") != "cone":
            blockers.append("当前选中 Face 不是圆锥面。")
        if current_radius is None or current_radius <= 1e-9:
            blockers.append("当前圆锥面缺少有效参考半径。")
        if current_angle is None:
            blockers.append("当前圆锥面缺少稳定半角。")
        if target_angle_degrees <= 0 or target_angle_degrees >= 89.0:
            blockers.append("目标圆锥半角必须大于 0 且小于 89 度。")

        current_tangent = abs(math.tan(current_angle)) if current_angle is not None else 0.0
        target_tangent = math.tan(math.radians(target_angle_degrees)) if target_angle_degrees > 0 else 0.0
        if current_angle is not None and current_tangent <= 1e-9:
            blockers.append("当前圆锥半角过小，不能稳定换算参考半径。")
        if target_tangent <= 1e-9:
            blockers.append("目标圆锥半角过小，不能稳定换算参考半径。")

        target_radius = (
            float(current_radius) * target_tangent / current_tangent
            if current_radius is not None and current_radius > 0 and current_tangent > 1e-9 and target_tangent > 1e-9
            else 0.0
        )
        base_plan = self.conical_reference_radius_plan(face_id, target_radius)
        base_strategy = str(base_plan.get("resize_strategy") or "")
        ignore_reference_fallback_blocker = base_strategy.startswith("blocked-cone-reference-radius") or base_strategy.startswith(
            "blocked-complex-cone-reference-radius"
        )
        base_blockers = str(base_plan.get("blockers") or "")
        blocker_parts = [part for part in blockers if part]
        if base_blockers and not ignore_reference_fallback_blocker:
            blocker_parts.extend(part for part in base_blockers.split("；") if part and part not in blocker_parts)
        base_warnings = str(base_plan.get("warnings") or "")
        warning_parts = [part for part in warnings if part]
        if base_warnings:
            warning_parts.extend(part for part in base_warnings.split("；") if part and part not in warning_parts)

        base_status = "caution" if ignore_reference_fallback_blocker else str(base_plan.get("status") or "caution")
        base_risk = "medium" if ignore_reference_fallback_blocker else str(base_plan.get("risk") or "medium")
        status = "blocked" if blocker_parts else base_status
        risk = "blocked" if blocker_parts else base_risk
        base_plan.update(
            {
                "status": status,
                "risk": risk,
                "message": " ".join(blocker_parts + warning_parts),
                "warnings": "；".join(warning_parts),
                "blockers": "；".join(blocker_parts),
                "target_semi_angle": math.radians(target_angle_degrees) if target_angle_degrees > 0 else None,
                "target_semi_angle_degrees": target_angle_degrees if target_angle_degrees > 0 else None,
                "target_reference_radius": target_radius if target_radius > 0 else None,
                "target_reference_diameter": target_radius * 2.0 if target_radius > 0 else None,
                "resize_strategy": "radial-affine-scale-cone-semi-angle",
                "edit_strategy_label": "按圆锥半角径向缩放",
                "edit_semantics": "按目标半角换算径向缩放比例；圆锥高度不变，端面半径和相邻径向尺寸会跟随变化。",
            }
        )
        self._annotate_simple_conical_rebuild_plan(base_plan, "semi-angle")
        self._block_obvious_complex_conical_fallback_plan(base_plan, "semi-angle")
        self._annotate_embedded_conical_recut_plan(base_plan, "semi-angle")
        self._block_unstable_conical_semi_angle_plan(base_plan)
        return base_plan

    def _annotate_simple_conical_rebuild_plan(self, plan: dict[str, object], mode: str) -> None:
        if str(plan.get("status")) == "blocked":
            return
        try:
            spec = self._simple_conical_rebuild_spec(plan)
        except Exception:
            spec = None
        if spec is None:
            plan["analytic_rebuild_available"] = False
            return
        if mode == "reference-radius" and not bool(spec.get("reference_radius_matches_current", False)):
            plan["analytic_rebuild_available"] = False
            plan["analytic_rebuild_skip_reason"] = "cone-reference-radius-does-not-match-a-cap"
            return
        plan["analytic_rebuild_available"] = True
        plan["analytic_cone_rebuild_height"] = spec.get("height")
        plan["analytic_cone_rebuild_reference_radius"] = spec.get("reference_radius")
        plan["analytic_cone_rebuild_other_radius"] = spec.get("other_radius")
        plan["analytic_cone_reference_radius_matches_current"] = spec.get("reference_radius_matches_current")
        plan["fallback_resize_strategy"] = plan.get("resize_strategy")
        if mode == "semi-angle":
            plan["resize_strategy"] = "analytic-cone-rebuild-semi-angle"
        else:
            plan["resize_strategy"] = "analytic-cone-rebuild-reference-radius"

    def _block_obvious_complex_conical_fallback_plan(self, plan: dict[str, object], mode: str) -> None:
        if str(plan.get("status")) == "blocked":
            return
        if bool(plan.get("analytic_rebuild_available", False)):
            return
        if bool(plan.get("embedded_cone_recut_available", False)):
            return
        expected_strategy = {
            "reference-radius": "radial-affine-scale-cone-reference-radius",
            "semi-angle": "radial-affine-scale-cone-semi-angle",
        }.get(mode)
        if expected_strategy is None or str(plan.get("resize_strategy") or "") != expected_strategy:
            return

        current_angle = _float_or_none(plan.get("semi_angle_degrees"))
        current_radius = _float_or_none(plan.get("current_reference_radius"))
        face_id = int(plan.get("face_id", -1))
        if current_angle is None or current_angle > 3.0 or current_radius is None:
            return

        face_diagonal = 0.0
        if 0 <= face_id < len(self.faces):
            try:
                face_diagonal = _shape_diagonal(self.faces[face_id])
            except Exception:
                face_diagonal = 0.0
        owning_diagonal = 0.0
        part_id = int(plan.get("part_id", -1))
        part = self.part_by_id(part_id) if part_id >= 0 else None
        if part is not None:
            try:
                owning_diagonal = _shape_diagonal(part.shape)
            except Exception:
                owning_diagonal = 0.0
        if current_radius <= max(face_diagonal * 4.0, owning_diagonal * 2.0, 1.0):
            return

        current_angle_text = _format_result_number(current_angle)
        current_radius_text = _format_result_number(current_radius)
        if mode == "reference-radius":
            target_radius = _float_or_none(plan.get("target_reference_radius"))
            target_radius_text = _format_result_number(target_radius)
            reason = (
                "当前对象仍然是 Face，但底层是复杂浅锥/拔模面；"
                f"半角约 {current_angle_text}°，参考半径约 {current_radius_text}，已经远大于当前 Face/所属特征尺寸。"
                f"把参考半径改到 {target_radius_text} 这类操作不适合走整体径向缩放，也不应该在界面线程里继续做昂贵的锥孔识别。"
                "当前版本只对简单圆锥解析重建，或可识别的锥孔/沉孔局部重切开放参考半径/直径修改；"
                "复杂浅锥/拔模面会提前阻止，避免界面卡死或生成无效 B-Rep。"
            )
            blocked_strategy = "blocked-complex-cone-reference-radius-shallow-far-axis"
            label = "暂不开放复杂浅锥参考半径修改"
        else:
            target_angle = _float_or_none(plan.get("target_semi_angle_degrees"))
            target_radius = _float_or_none(plan.get("target_reference_radius"))
            target_angle_text = _format_result_number(target_angle)
            target_radius_text = _format_result_number(target_radius)
            reason = (
                "当前对象仍然是 Face，但底层是复杂浅锥/拔模面；"
                f"半角约 {current_angle_text}°，参考半径约 {current_radius_text}，已经远大于当前 Face/所属特征尺寸。"
                f"把半角改到 {target_angle_text}° 会换算出约 {target_radius_text} 的参考半径，"
                "不适合走整体径向缩放，也不应该在界面线程里继续做昂贵的锥孔识别。"
                "当前版本只对简单圆锥解析重建，或可识别的锥孔/沉孔局部重切开放半角修改；"
                "复杂浅锥/拔模面会提前阻止，避免界面卡死或生成无效 B-Rep。"
            )
            blocked_strategy = "blocked-complex-cone-semi-angle-shallow-far-axis"
            label = "暂不开放复杂浅锥半角修改"
        existing_blockers = [part for part in str(plan.get("blockers") or "").split("；") if part]
        if reason not in existing_blockers:
            existing_blockers.append(reason)
        plan.update(
            {
                "status": "blocked",
                "risk": "blocked",
                "blockers": "；".join(existing_blockers),
                "message": reason,
                "resize_strategy": blocked_strategy,
                "edit_strategy_label": label,
                "edit_semantics": reason,
                "cone_fast_block_face_diagonal": face_diagonal,
                "cone_fast_block_owning_diagonal": owning_diagonal,
            }
        )

    def _block_unstable_conical_reference_radius_plan(self, plan: dict[str, object]) -> None:
        if str(plan.get("status")) == "blocked":
            return
        if bool(plan.get("analytic_rebuild_available", False)):
            return
        if bool(plan.get("embedded_cone_recut_available", False)):
            return
        if str(plan.get("resize_strategy") or "") != "radial-affine-scale-cone-reference-radius":
            return

        if str(plan.get("analytic_rebuild_skip_reason") or "") == "cone-reference-radius-does-not-match-a-cap":
            reason = (
                "当前圆锥面的参考半径不在可识别的圆形端面上；当前版本不能稳定保留这个参考位置来直接修改参考半径，"
                "否则容易出现目标值无法回读、圆锥面退化或编辑结果被回滚。"
                "当前只对简单圆锥解析重建，或可识别的锥孔/沉孔局部重切开放参考半径/直径修改。"
            )
            strategy = "blocked-cone-reference-radius-non-cap"
            label = "暂不开放非端面参考半径"
        else:
            reason = (
                "当前对象仍然是 Face，但它的底层曲面类型是复杂圆锥面/拔模面；"
                "当前版本没有把这个 Face 识别为简单圆锥，也没有识别成双圆边界的锥孔/沉孔，"
                "因此不再使用整体径向缩放兜底修改参考半径/直径。整体缩放会影响所属特征的其它尺寸，"
                "并且在复杂 STEP 上容易生成无效 B-Rep。"
            )
            strategy = "blocked-complex-cone-reference-radius-unsupported-fallback"
            label = "暂不开放复杂圆锥参考半径兜底修改"
        existing_blockers = [part for part in str(plan.get("blockers") or "").split("；") if part]
        if reason not in existing_blockers:
            existing_blockers.append(reason)
        warnings = [part for part in str(plan.get("warnings") or "").split("；") if part]
        plan.update(
            {
                "status": "blocked",
                "risk": "blocked",
                "blockers": "；".join(existing_blockers),
                "message": reason,
                "resize_strategy": strategy,
                "edit_strategy_label": label,
                "edit_semantics": reason,
            }
        )

    def _block_unstable_conical_semi_angle_plan(self, plan: dict[str, object]) -> None:
        if str(plan.get("status")) == "blocked":
            return
        if bool(plan.get("analytic_rebuild_available", False)):
            return
        if bool(plan.get("embedded_cone_recut_available", False)):
            return
        if str(plan.get("resize_strategy") or "") != "radial-affine-scale-cone-semi-angle":
            return

        current_angle = _float_or_none(plan.get("semi_angle_degrees"))
        target_angle = _float_or_none(plan.get("target_semi_angle_degrees"))
        current_radius = _float_or_none(plan.get("current_reference_radius"))
        target_radius = _float_or_none(plan.get("target_reference_radius"))
        scale = _float_or_none(plan.get("affine_scale"))
        face_id = int(plan.get("face_id", -1))

        face_diagonal = 0.0
        if 0 <= face_id < len(self.faces):
            face_diagonal = _shape_diagonal(self.faces[face_id])
        owning_diagonal = 0.0
        try:
            _target_kind, source_shape, _part, _solid = self._edge_length_affine_target(plan)
            owning_diagonal = _shape_diagonal(source_shape)
        except Exception:
            try:
                owning_diagonal = _shape_diagonal(self.shape)
            except Exception:
                owning_diagonal = 0.0

        model_size = max(face_diagonal, owning_diagonal, 1.0)
        angle_delta = (
            abs(float(target_angle) - float(current_angle))
            if current_angle is not None and target_angle is not None
            else 0.0
        )
        shallow_far_axis = (
            current_angle is not None
            and current_angle <= 3.0
            and current_radius is not None
            and current_radius > max(face_diagonal * 4.0, owning_diagonal * 2.0, 1.0)
        )
        extreme_scale = scale is None or scale <= 0.0 or scale > 3.0 or scale < (1.0 / 3.0)
        extreme_reference = target_radius is not None and target_radius > model_size * 8.0
        large_angle_jump = angle_delta >= 3.0

        current_angle_text = _format_result_number(current_angle)
        target_angle_text = _format_result_number(target_angle)
        current_radius_text = _format_result_number(current_radius)
        target_radius_text = _format_result_number(target_radius)
        scale_text = _format_result_number(scale)
        is_extreme_shallow = shallow_far_axis and (extreme_scale or extreme_reference or large_angle_jump)
        if is_extreme_shallow:
            reason = (
                "当前对象仍然是 Face，但它的底层曲面类型是复杂浅锥/拔模面；"
                "1° 左右的浅锥面视觉上很像平面，不适合用整体径向缩放直接修改半角。"
                f"半角从 {current_angle_text}° 改到 {target_angle_text}° 会把参考半径从 "
                f"{current_radius_text} 放大到 {target_radius_text}，缩放比例约 {scale_text}；"
                "这类结果在复杂 STEP 上容易生成无效 B-Rep。当前版本只对简单圆锥解析重建，"
                "或可识别的锥孔/沉孔局部重切开放大幅半角修改。"
            )
            blocked_strategy = "blocked-complex-cone-semi-angle-extreme-scale"
            label = "暂不开放复杂浅锥半角大幅修改"
        else:
            reason = (
                "当前对象仍然是 Face，但它的底层曲面类型是圆锥面/拔模面；"
                "当前版本没有把这个 Face 识别为简单圆锥，也没有识别成双圆边界的锥孔/沉孔，"
                "因此不再使用整体径向缩放兜底修改半角。整体缩放会影响所属特征的其它尺寸，"
                "并且在复杂 STEP 上容易生成无效 B-Rep。"
            )
            blocked_strategy = "blocked-complex-cone-semi-angle-unsupported-fallback"
            label = "暂不开放复杂圆锥半角兜底修改"
        existing_blockers = [part for part in str(plan.get("blockers") or "").split("；") if part]
        if reason not in existing_blockers:
            existing_blockers.append(reason)
        warnings = [part for part in str(plan.get("warnings") or "").split("；") if part]
        plan.update(
            {
                "status": "blocked",
                "risk": "blocked",
                "blockers": "；".join(existing_blockers),
                "message": reason,
                "resize_strategy": blocked_strategy,
                "edit_strategy_label": label,
                "edit_semantics": reason,
                "cone_semi_angle_block_face_diagonal": face_diagonal,
                "cone_semi_angle_block_owning_diagonal": owning_diagonal,
            }
        )

    def _annotate_embedded_conical_recut_plan(self, plan: dict[str, object], mode: str) -> None:
        if str(plan.get("status")) == "blocked":
            return
        if bool(plan.get("analytic_rebuild_available", False)):
            return
        try:
            spec = self._embedded_conical_recut_spec(plan, mode)
        except Exception:
            spec = None
        if spec is None:
            plan["embedded_cone_recut_available"] = False
            return

        recut_mode = str(spec.get("embedded_cone_recut_mode") or "enlarge")
        if mode == "reference-radius":
            recut_action = "先补料封回旧锥孔，再按目标参考半径重切" if recut_mode == "shrink" else "按目标参考半径局部扩大重切"
            strategy = "bounded-cone-recut-preserve-angle-reference-radius"
            semantics = (
                "保持锥孔当前半角和轴向深度不变，按目标参考半径局部重切锥孔；"
                "不会整体缩放所属对象，也不会自动联动相连的圆柱孔直径。"
            )
        else:
            recut_action = "先补料封回旧锥孔，再按目标半角重切" if recut_mode == "shrink" else "按目标半角局部扩大重切"
            strategy = "bounded-cone-recut-fixed-small-radius-semi-angle"
            semantics = (
                "保持锥孔较小端半径和轴向深度不变；放大半角时直接用目标圆锥 cutter 扩大开口，"
                "缩小半角时先补料封回旧锥孔再按目标半角重切。"
            )
        warning = (
            "检测到嵌入式锥孔/沉孔类圆锥 Face；本次会优先局部重切圆锥开口，"
            f"不再围绕圆锥轴缩放整个所属对象。执行方式：{recut_action}。"
        )
        warnings = [
            part
            for part in str(plan.get("warnings") or "").split("；")
            if part
            and "径向缩放" not in part
            and "缩放所属" not in part
            and "同一零件上的其它尺寸" not in part
            and "同一 Solid 上的其它尺寸" not in part
        ]
        if warning not in warnings:
            warnings.append(warning)
        plan.update(
            {
                **spec,
                "embedded_cone_recut_available": True,
                "fallback_resize_strategy": plan.get("resize_strategy"),
                "resize_strategy": strategy,
                "edit_strategy_label": "锥孔局部重切",
                "edit_semantics": semantics,
                "risk": _max_risk(str(plan.get("risk") or "medium"), "high"),
                "status": "caution",
                "warnings": "；".join(warnings),
                "message": " ".join([part for part in str(plan.get("blockers") or "").split("；") if part] + warnings),
            }
        )

    def _embedded_conical_recut_spec(self, plan: dict[str, object], mode: str) -> dict[str, object] | None:
        if mode not in {"semi-angle", "reference-radius"}:
            return None
        face_id = int(plan.get("face_id", -1))
        if face_id < 0 or face_id >= len(self.faces):
            return None

        axis_point = _tuple_or_none(plan.get("axis_point"))
        axis_direction = _tuple_normalized(_tuple_or_none(plan.get("axis")))
        if axis_point is None or axis_direction is None:
            return None
        circles = self._conical_face_circle_boundaries(face_id, axis_point, axis_direction)
        if len(circles) != 2:
            return None

        circles = sorted(circles, key=lambda item: float(item["radius"]))
        small = circles[0]
        large = circles[1]
        small_radius = float(small["radius"])
        large_radius = float(large["radius"])
        small_center = tuple(small["center"])
        large_center = tuple(large["center"])
        height = _vector_length(_tuple_sub(large_center, small_center))
        if small_radius <= 1e-9 or large_radius <= small_radius or height <= 1e-9:
            return None

        current_tangent = (large_radius - small_radius) / height
        if current_tangent <= 1e-9:
            return None
        tolerance = max(_shape_diagonal(self.faces[face_id]) * 1e-6, large_radius * 1e-5, 1e-5)

        if mode == "semi-angle":
            target_angle_degrees = _float_or_none(plan.get("target_semi_angle_degrees"))
            if target_angle_degrees is None or target_angle_degrees <= 0.0 or target_angle_degrees >= 89.0:
                return None
            target_tangent = math.tan(math.radians(target_angle_degrees))
            if target_tangent <= 1e-9:
                return None
            target_small_radius = small_radius
            target_large_radius = small_radius + height * target_tangent
            if abs(target_large_radius - large_radius) <= tolerance:
                return None
            edit_mode = "enlarge" if target_large_radius > large_radius else "shrink"
        else:
            target_reference_radius = _float_or_none(plan.get("target_reference_radius"))
            current_reference_radius = _float_or_none(plan.get("current_reference_radius"))
            if (
                target_reference_radius is None
                or current_reference_radius is None
                or target_reference_radius <= 1e-9
                or current_reference_radius <= 1e-9
            ):
                return None
            reference_parameter = (current_reference_radius - small_radius) / current_tangent
            reference_matches_small = abs(reference_parameter) <= max(tolerance / current_tangent, tolerance)
            reference_matches_large = abs(reference_parameter - height) <= max(tolerance / current_tangent, tolerance)
            target_small_radius = target_reference_radius - reference_parameter * current_tangent
            target_large_radius = target_small_radius + height * current_tangent
            if target_small_radius <= tolerance or target_large_radius <= target_small_radius + tolerance:
                return None
            radial_delta = target_reference_radius - current_reference_radius
            if abs(radial_delta) <= tolerance:
                return None
            target_tangent = current_tangent
            target_angle_degrees = math.degrees(math.atan(current_tangent))
            edit_mode = "enlarge" if radial_delta > 0.0 else "shrink"

        target_kind, source_shape, _part, source_solid = self._edge_length_affine_target(plan)
        classifier_solid = source_solid or source_shape
        if not self._embedded_conical_face_is_hole_like(classifier_solid, small, large, tolerance):
            return None

        tool_direction = _tuple_normalized(_tuple_sub(large_center, small_center))
        if tool_direction is None:
            return None
        if target_large_radius <= target_small_radius + tolerance:
            return None
        end_margin = (
            min(max(height * 0.01, target_large_radius * 0.005, 0.02), max(height * 0.05, 0.05))
            if edit_mode == "enlarge"
            else 0.0
        )
        tool_height = height + end_margin
        tool_end_radius = target_large_radius + target_tangent * end_margin
        diagonal = max(_shape_diagonal(source_shape), target_large_radius, 1.0)
        if tool_end_radius > max(diagonal * 1.2, large_radius * 6.0):
            return None

        return {
            "embedded_cone_recut_mode": edit_mode,
            "embedded_cone_fixed_small_radius": small_radius if mode == "semi-angle" else None,
            "embedded_cone_current_small_radius": small_radius,
            "embedded_cone_target_small_radius": target_small_radius,
            "embedded_cone_current_large_radius": large_radius,
            "embedded_cone_target_large_radius": target_large_radius,
            "embedded_cone_current_angle_degrees": math.degrees(math.atan(current_tangent)),
            "embedded_cone_target_angle_degrees": target_angle_degrees,
            "embedded_cone_reference_parameter": reference_parameter if mode == "reference-radius" else None,
            "embedded_cone_reference_matches_small": reference_matches_small if mode == "reference-radius" else None,
            "embedded_cone_reference_matches_large": reference_matches_large if mode == "reference-radius" else None,
            "embedded_cone_height": height,
            "embedded_cone_tool_start_point": small_center,
            "embedded_cone_tool_direction": tool_direction,
            "embedded_cone_tool_start_radius": target_small_radius,
            "embedded_cone_tool_end_radius": tool_end_radius,
            "embedded_cone_tool_height": tool_height,
            "embedded_cone_tool_end_margin": end_margin,
            "embedded_cone_fill_start_radius": small_radius,
            "embedded_cone_fill_end_radius": large_radius,
            "embedded_cone_fill_height": height,
            "embedded_cone_target_kind": target_kind,
        }

    def _conical_face_circle_boundaries(
        self,
        face_id: int,
        axis_point: tuple[float, float, float],
        axis_direction: tuple[float, float, float],
    ) -> list[dict[str, object]]:
        face = self.faces[face_id]
        axis_origin = gp_Pnt(*axis_point)
        axis_dir = gp_Dir(*axis_direction)
        tolerance = max(_shape_diagonal(face) * 1e-6, 1e-6)
        circles: list[dict[str, object]] = []
        for edge in _explore(face, TopAbs_EDGE):
            try:
                curve = BRepAdaptor_Curve(edge)
                if curve.GetType() != GeomAbs_Circle:
                    continue
                circle = curve.Circle()
                center = circle.Location()
                radius = float(circle.Radius())
                if radius <= 1e-9:
                    continue
                if abs(_direction_dot(circle.Axis().Direction(), axis_dir)) < 0.95:
                    continue
                if _point_axis_distance(axis_origin, axis_dir, center) > max(radius * 1e-5, tolerance):
                    continue
                parameter = _axis_parameter(axis_origin, axis_dir, center)
                sample = curve.Value(curve.FirstParameter())
                item = {
                    "radius": radius,
                    "center": _point_tuple(center),
                    "axis_parameter": parameter,
                    "sample_point": _point_tuple(sample),
                }
                duplicate = False
                for existing in circles:
                    if (
                        abs(float(existing["radius"]) - radius) <= tolerance
                        and _vector_length(_tuple_sub(tuple(existing["center"]), item["center"])) <= tolerance
                    ):
                        duplicate = True
                        break
                if not duplicate:
                    circles.append(item)
            except Exception:
                continue
        return circles

    def _embedded_conical_face_is_hole_like(
        self,
        solid: TopoDS_Shape,
        small: dict[str, object],
        large: dict[str, object],
        tolerance: float,
    ) -> bool:
        small_center = tuple(small["center"])
        large_center = tuple(large["center"])
        large_sample = tuple(large["sample_point"])
        radial = _tuple_normalized(_tuple_sub(large_sample, large_center))
        if radial is None:
            return False
        small_radius = float(small["radius"])
        large_radius = float(large["radius"])
        mid_center = (
            (small_center[0] + large_center[0]) * 0.5,
            (small_center[1] + large_center[1]) * 0.5,
            (small_center[2] + large_center[2]) * 0.5,
        )
        mid_radius = (small_radius + large_radius) * 0.5
        sample_point = _tuple_add(mid_center, _tuple_scale(radial, mid_radius))
        offset = max((large_radius - small_radius) * 0.08, large_radius * 0.02, tolerance * 10.0, 0.02)
        toward_axis = gp_Pnt(*_tuple_sub(sample_point, _tuple_scale(radial, offset)))
        away_axis = gp_Pnt(*_tuple_add(sample_point, _tuple_scale(radial, offset)))
        return _solid_state(solid, toward_axis) == "outside" and _solid_state(solid, away_axis) == "inside"

    def _apply_conical_analytic_rebuild_if_simple(self, plan: dict[str, object]) -> bool:
        if not bool(plan.get("analytic_rebuild_available", False)):
            return False
        spec = self._simple_conical_rebuild_spec(plan)
        if spec is None:
            return False

        target_kind, _source_shape, part, source_solid = self._edge_length_affine_target(plan)
        maker = BRepPrimAPI_MakeCone(
            float(spec["reference_radius"]),
            float(spec["other_radius"]),
            float(spec["height"]),
        )
        rebuilt = maker.Shape()
        if rebuilt.IsNull():
            raise RuntimeError("Analytic cone rebuild produced an empty shape.")

        transform = self._axis_placement_transform(
            spec["reference_center"],
            spec["reference_to_other_direction"],
        )
        builder = BRepBuilderAPI_Transform(rebuilt, transform, True)
        builder.Build()
        if not builder.IsDone():
            raise RuntimeError("Analytic cone placement transform failed.")
        transformed = builder.Shape()
        if transformed.IsNull():
            raise RuntimeError("Analytic cone placement transform produced an empty shape.")
        transformed = _ensure_valid_or_repaired_shape(transformed, "analytic cone rebuild")

        if target_kind == "part":
            part.shape = transformed
        else:
            part_solids = _explore(part.shape, TopAbs_SOLID)
            replaced = False
            shapes: list[TopoDS_Shape] = []
            for item in part_solids:
                if not replaced and source_solid is not None and _same_shape(item, source_solid):
                    shapes.append(transformed)
                    replaced = True
                else:
                    shapes.append(item)
            if not replaced:
                raise RuntimeError(f"Could not locate solid {plan.get('solid_id')} inside part {plan.get('part_id')}.")
            part.shape = _compound_from_shapes(shapes)
            _ensure_valid_shape(part.shape)

        self.refresh_topology()
        return True

    def _apply_embedded_conical_recut_if_available(self, plan: dict[str, object]) -> bool:
        if not bool(plan.get("embedded_cone_recut_available", False)):
            return False
        target_kind, source_shape, part, source_solid = self._edge_length_affine_target(plan)
        start = _tuple_or_none(plan.get("embedded_cone_tool_start_point"))
        direction = _tuple_normalized(_tuple_or_none(plan.get("embedded_cone_tool_direction")))
        start_radius = _float_or_none(plan.get("embedded_cone_tool_start_radius"))
        end_radius = _float_or_none(plan.get("embedded_cone_tool_end_radius"))
        height = _float_or_none(plan.get("embedded_cone_tool_height"))
        recut_mode = str(plan.get("embedded_cone_recut_mode") or "enlarge")
        if (
            start is None
            or direction is None
            or start_radius is None
            or end_radius is None
            or height is None
            or start_radius <= 1e-9
            or end_radius <= start_radius
            or height <= 1e-9
        ):
            raise RuntimeError("Embedded conical recut plan is missing a valid cutter.")

        source_for_cut = source_shape
        if recut_mode == "shrink":
            fill_start_radius = _float_or_none(plan.get("embedded_cone_fill_start_radius"))
            fill_end_radius = _float_or_none(plan.get("embedded_cone_fill_end_radius"))
            fill_height = _float_or_none(plan.get("embedded_cone_fill_height"))
            if (
                fill_start_radius is None
                or fill_end_radius is None
                or fill_height is None
                or fill_start_radius <= 1e-9
                or fill_end_radius <= fill_start_radius
                or fill_height <= 1e-9
            ):
                raise RuntimeError("Embedded conical recut shrink plan is missing a valid filler.")
            filler = BRepPrimAPI_MakeCone(
                gp_Ax2(gp_Pnt(*start), gp_Dir(*direction)),
                float(fill_start_radius),
                float(fill_end_radius),
                float(fill_height),
            ).Shape()
            if filler.IsNull():
                raise RuntimeError("Embedded conical recut produced an empty filler.")
            fuse = BRepAlgoAPI_Fuse(source_shape, filler)
            source_for_cut = _finalize_boolean_result(fuse, "embedded conical recut fill old cone", use_glue=False)

        cutter = BRepPrimAPI_MakeCone(
            gp_Ax2(gp_Pnt(*start), gp_Dir(*direction)),
            float(start_radius),
            float(end_radius),
            float(height),
        ).Shape()
        if cutter.IsNull():
            raise RuntimeError("Embedded conical recut produced an empty cutter.")
        op = BRepAlgoAPI_Cut(source_for_cut, cutter)
        result = _finalize_boolean_result(op, "embedded conical recut")

        if target_kind == "part":
            part.shape = result
        else:
            part_solids = _explore(part.shape, TopAbs_SOLID)
            replaced = False
            shapes: list[TopoDS_Shape] = []
            for item in part_solids:
                if not replaced and source_solid is not None and _same_shape(item, source_solid):
                    shapes.append(result)
                    replaced = True
                else:
                    shapes.append(item)
            if not replaced:
                raise RuntimeError(f"Could not locate solid {plan.get('solid_id')} inside part {plan.get('part_id')}.")
            part.shape = _compound_from_shapes(shapes)
            _ensure_valid_shape(part.shape)

        self.refresh_topology()
        return True

    def _simple_conical_rebuild_spec(self, plan: dict[str, object]) -> dict[str, object] | None:
        target_kind, source_shape, _part, _source_solid = self._edge_length_affine_target(plan)
        if len(_explore(source_shape, TopAbs_SOLID)) != 1:
            return None

        current_reference_radius = _float_or_none(plan.get("current_reference_radius"))
        target_reference_radius = _float_or_none(plan.get("target_reference_radius"))
        scale = _float_or_none(plan.get("affine_scale"))
        if (
            current_reference_radius is None
            or target_reference_radius is None
            or scale is None
            or current_reference_radius <= 1e-9
            or target_reference_radius <= 1e-9
            or scale <= 1e-9
        ):
            return None

        faces = _explore(source_shape, TopAbs_FACE)
        cone_faces: list[TopoDS_Shape] = []
        cap_specs: list[dict[str, object]] = []
        for face in faces:
            try:
                surf = BRepAdaptor_Surface(face)
                surface_type = surf.GetType()
            except Exception:
                return None
            if surface_type == GeomAbs_Cone:
                cone_faces.append(face)
                continue
            if surface_type != GeomAbs_Plane:
                return None

            edge_count = len(_explore(face, TopAbs_EDGE))
            if edge_count != 1:
                return None
            props = GProp_GProps()
            try:
                brepgprop.SurfaceProperties(face, props)
            except Exception:
                return None
            area = float(props.Mass())
            if area <= 1e-9:
                return None
            radius = math.sqrt(area / math.pi)
            center = _point_tuple(props.CentreOfMass())
            cap_specs.append({"radius": radius, "center": center})

        if target_kind not in {"part", "solid"} or len(cone_faces) != 1 or len(cap_specs) not in {1, 2}:
            return None

        length_reference = max(
            _shape_diagonal(source_shape),
            current_reference_radius,
            target_reference_radius,
            1.0,
        )
        radius_tolerance = max(length_reference * 1e-5, 1e-5)
        if len(cap_specs) == 1:
            reference_cap = cap_specs[0]
            reference_center = tuple(reference_cap["center"])
            apex = self._simple_conical_apex_point(source_shape, reference_center, radius_tolerance, plan)
            if apex is None:
                return None
            direction = _tuple_normalized(_tuple_sub(apex, reference_center))
            height = _vector_length(_tuple_sub(apex, reference_center))
            if direction is None or height <= radius_tolerance:
                return None
            reference_radius = float(reference_cap["radius"]) * scale
            if reference_radius <= 1e-9:
                return None
            return {
                "reference_center": reference_center,
                "reference_to_other_direction": direction,
                "reference_radius": reference_radius,
                "other_radius": 0.0,
                "height": height,
                "reference_radius_matches_current": abs(float(reference_cap["radius"]) - current_reference_radius)
                <= radius_tolerance,
            }

        matching_caps = [
            cap for cap in cap_specs if abs(float(cap["radius"]) - current_reference_radius) <= radius_tolerance
        ]
        reference_radius_matches_current = len(matching_caps) == 1
        if reference_radius_matches_current:
            reference_cap = matching_caps[0]
            other_cap = cap_specs[0] if reference_cap is cap_specs[1] else cap_specs[1]
        else:
            reference_cap = cap_specs[0]
            other_cap = cap_specs[1]

        reference_center = tuple(reference_cap["center"])
        other_center = tuple(other_cap["center"])
        direction = _tuple_normalized(_tuple_sub(other_center, reference_center))
        height = _vector_length(_tuple_sub(other_center, reference_center))
        if direction is None or height <= radius_tolerance:
            return None

        reference_radius = float(reference_cap["radius"]) * scale
        other_radius = float(other_cap["radius"]) * scale
        if reference_radius <= 1e-9 or other_radius <= 1e-9:
            return None

        return {
            "reference_center": reference_center,
            "reference_to_other_direction": direction,
            "reference_radius": reference_radius,
            "other_radius": other_radius,
            "height": height,
            "reference_radius_matches_current": reference_radius_matches_current,
        }

    def _simple_conical_apex_point(
        self,
        shape: TopoDS_Shape,
        cap_center: tuple[float, float, float],
        tolerance: float,
        plan: dict[str, object],
    ) -> tuple[float, float, float] | None:
        axis_direction = _tuple_normalized(_tuple_or_none(plan.get("axis")))
        unique_points: list[tuple[float, float, float]] = []
        for vertex in _explore(shape, TopAbs_VERTEX):
            try:
                point = _point_tuple(BRep_Tool.Pnt(topods.Vertex(vertex)))
            except Exception:
                continue
            if any(_vector_length(_tuple_sub(point, existing)) <= tolerance for existing in unique_points):
                continue
            unique_points.append(point)
        if not unique_points:
            return None

        best_point: tuple[float, float, float] | None = None
        best_score = -math.inf
        for point in unique_points:
            vector = _tuple_sub(point, cap_center)
            if axis_direction is not None:
                score = abs(_tuple_dot(vector, axis_direction))
            else:
                score = _vector_length(vector)
            if score > best_score:
                best_score = score
                best_point = point
        if best_point is None or best_score <= tolerance:
            return None
        return best_point

    def _axis_placement_transform(
        self,
        origin: tuple[float, float, float],
        z_direction: tuple[float, float, float],
    ) -> gp_Trsf:
        w = _tuple_normalized(z_direction)
        if w is None:
            raise ValueError("Missing analytic cone placement direction.")
        helper = (1.0, 0.0, 0.0) if abs(w[0]) < 0.85 else (0.0, 1.0, 0.0)
        u = _tuple_normalized(_tuple_cross(helper, w))
        if u is None:
            helper = (0.0, 0.0, 1.0)
            u = _tuple_normalized(_tuple_cross(helper, w))
        if u is None:
            raise ValueError("Could not build analytic cone placement basis.")
        v = _tuple_cross(w, u)
        transform = gp_Trsf()
        transform.SetValues(
            u[0],
            v[0],
            w[0],
            origin[0],
            u[1],
            v[1],
            w[1],
            origin[1],
            u[2],
            v[2],
            w[2],
            origin[2],
        )
        return transform

    def resize_conical_reference_radius(self, face_id: int, target_radius: float) -> str:
        plan = self.conical_reference_radius_plan(face_id, target_radius)
        if plan["status"] == "blocked":
            raise ValueError(str(plan["message"]))
        self._remember_face_target_logical_id(plan, face_id)
        if bool(plan.get("analytic_rebuild_available", False)):
            applied, result_check = self._run_checked_face_edit(
                plan,
                lambda: self._apply_conical_analytic_rebuild_if_simple(plan),
            )
            if not applied:
                raise RuntimeError("Analytic cone rebuild was planned but not applied.")
            return (
                "Conical face reference radius resize completed by analytic cone rebuild: "
                f"face {face_id}, "
                f"reference_radius={float(plan['current_reference_radius']):g}->{float(plan['target_reference_radius']):g}, "
                f"scale={float(plan['affine_scale']):g}, "
                f"target={plan.get('affine_target_kind')}, "
                f"risk={plan['risk']}. {result_check}"
            )
        if bool(plan.get("embedded_cone_recut_available", False)):
            applied, result_check = self._run_checked_face_edit(
                plan,
                lambda: self._apply_embedded_conical_recut_if_available(plan),
            )
            if not applied:
                raise RuntimeError("Embedded conical recut was planned but not applied.")
            return (
                "Conical face reference radius resize completed by embedded local cone recut: "
                f"face {face_id}, "
                f"reference_radius={float(plan['current_reference_radius']):g}->{float(plan['target_reference_radius']):g}, "
                f"mode={plan.get('embedded_cone_recut_mode')}, "
                f"small_radius={float(plan['embedded_cone_current_small_radius']):g}->{float(plan['embedded_cone_target_small_radius']):g}, "
                f"large_radius={float(plan['embedded_cone_current_large_radius']):g}->{float(plan['embedded_cone_target_large_radius']):g}, "
                f"height={float(plan['embedded_cone_height']):g}, "
                f"target={plan.get('embedded_cone_target_kind')}, "
                f"risk={plan['risk']}. {result_check}"
            )
        _action_result, result_check = self._run_checked_face_edit(
            plan,
            lambda: self._apply_edge_length_affine_transform(plan),
        )
        return (
            "Conical face reference radius resize completed by radial affine scaling: "
            f"face {face_id}, "
            f"reference_radius={float(plan['current_reference_radius']):g}->{float(plan['target_reference_radius']):g}, "
            f"scale={float(plan['affine_scale']):g}, "
            f"target={plan.get('affine_target_kind')}, "
            f"risk={plan['risk']}. {result_check}"
        )

    def resize_conical_semi_angle(self, face_id: int, target_angle_degrees: float) -> str:
        plan = self.conical_semi_angle_plan(face_id, target_angle_degrees)
        if plan["status"] == "blocked":
            raise ValueError(str(plan["message"]))
        self._remember_face_target_logical_id(plan, face_id)
        if bool(plan.get("analytic_rebuild_available", False)):
            applied, result_check = self._run_checked_face_edit(
                plan,
                lambda: self._apply_conical_analytic_rebuild_if_simple(plan),
            )
            if not applied:
                raise RuntimeError("Analytic cone rebuild was planned but not applied.")
            return (
                "Conical face semi-angle resize completed by analytic cone rebuild: "
                f"face {face_id}, "
                f"semi_angle={float(plan['semi_angle_degrees']):g}deg->{float(plan['target_semi_angle_degrees']):g}deg, "
                f"reference_radius={float(plan['current_reference_radius']):g}->{float(plan['target_reference_radius']):g}, "
                f"scale={float(plan['affine_scale']):g}, "
                f"target={plan.get('affine_target_kind')}, "
                f"risk={plan['risk']}. {result_check}"
            )
        if bool(plan.get("embedded_cone_recut_available", False)):
            applied, result_check = self._run_checked_face_edit(
                plan,
                lambda: self._apply_embedded_conical_recut_if_available(plan),
            )
            if not applied:
                raise RuntimeError("Embedded conical recut was planned but not applied.")
            return (
                "Conical face semi-angle resize completed by embedded local cone recut: "
                f"face {face_id}, "
                f"semi_angle={float(plan['semi_angle_degrees']):g}deg->{float(plan['target_semi_angle_degrees']):g}deg, "
                f"mode={plan.get('embedded_cone_recut_mode')}, "
                f"fixed_small_radius={float(plan['embedded_cone_fixed_small_radius']):g}, "
                f"large_radius={float(plan['embedded_cone_current_large_radius']):g}->{float(plan['embedded_cone_target_large_radius']):g}, "
                f"height={float(plan['embedded_cone_height']):g}, "
                f"target={plan.get('embedded_cone_target_kind')}, "
                f"risk={plan['risk']}. {result_check}"
            )
        _action_result, result_check = self._run_checked_face_edit(
            plan,
            lambda: self._apply_edge_length_affine_transform(plan),
        )
        return (
            "Conical face semi-angle resize completed by radial affine scaling: "
            f"face {face_id}, "
            f"semi_angle={float(plan['semi_angle_degrees']):g}deg->{float(plan['target_semi_angle_degrees']):g}deg, "
            f"reference_radius={float(plan['current_reference_radius']):g}->{float(plan['target_reference_radius']):g}, "
            f"scale={float(plan['affine_scale']):g}, "
            f"target={plan.get('affine_target_kind')}, "
            f"risk={plan['risk']}. {result_check}"
        )

    def spherical_radius_plan(self, face_id: int, target_radius: float) -> dict[str, object]:
        if face_id < 0 or face_id >= len(self.faces):
            raise ValueError(f"Unknown face id {face_id}")
        info = self.face_info(face_id)
        blockers: list[str] = []
        warnings: list[str] = [
            "球面半径修改会围绕球心缩放所属零件/Solid；这是 B-Rep 几何缩放，不是 CAD 历史参数。"
        ]
        risk = "medium"

        try:
            target_radius = float(target_radius)
        except (TypeError, ValueError):
            target_radius = 0.0
            blockers.append("目标球面半径必须是数字。")

        current_radius = _float_or_none(info.get("radius"))
        center = _tuple_or_none(info.get("center"))
        if info.get("surface") != "sphere":
            blockers.append("当前选中 Face 不是球面。")
        if current_radius is None or current_radius <= 1e-9:
            blockers.append("当前球面缺少有效半径。")
        if center is None:
            blockers.append("当前球面缺少稳定球心，不能缩放。")
        if target_radius <= 1e-9:
            blockers.append("目标球面半径必须大于 0。")

        scale = target_radius / max(current_radius or 1.0, 1e-9)
        delta_radius = target_radius - float(current_radius or 0.0)
        delta_ratio = abs(delta_radius) / max(float(current_radius or 0.0), 1e-9)
        if current_radius is not None and abs(delta_radius) <= max(current_radius * 1e-6, 1e-6):
            blockers.append("目标球面半径与当前值几乎相同，不需要修改。")
        if delta_ratio > 0.6:
            risk = _max_risk(risk, "high")
            warnings.append("球面半径变化超过 60%，可能明显影响周边几何。")
        elif delta_ratio > 0.25:
            risk = _max_risk(risk, "high")
            warnings.append("球面半径变化超过 25%，修改后请重点检查相邻面。")

        part_id = int(info.get("part_id", -1))
        solid_id = int(info.get("solid_id", -1))
        part = self.part_by_id(part_id) if part_id >= 0 else None
        if part is None:
            blockers.append("找不到当前球面所属零件。")
            part_solid_count = 0
        else:
            part_solid_count = len(_explore(part.shape, TopAbs_SOLID))
        target_kind = "solid" if solid_id >= 0 and part_solid_count > 1 else "part"
        warnings.append(f"当前会缩放所属 {target_kind}，可能影响同一对象上的其它尺寸。")

        status = "blocked" if blockers else "caution"
        if blockers:
            risk = "blocked"
        return {
            "status": status,
            "risk": risk,
            "message": " ".join(blockers + warnings),
            "warnings": "；".join(warnings),
            "blockers": "；".join(blockers),
            "face_id": face_id,
            "part_id": part_id,
            "solid_id": solid_id,
            "surface": info.get("surface"),
            "current_radius": current_radius,
            "target_radius": target_radius,
            "current_diameter": None if current_radius is None else current_radius * 2.0,
            "target_diameter": target_radius * 2.0,
            "delta_radius": delta_radius,
            "radius_delta_ratio": delta_ratio,
            "center": center,
            "resize_strategy": "uniform-scale-sphere-radius",
            "edit_strategy_label": "围绕球心均匀缩放",
            "edit_semantics": "按目标球面半径围绕球心均匀缩放所属对象；不是只替换单个球面历史参数。",
            "affine_scale": scale,
            "affine_transform_kind": "uniform",
            "affine_transform_label": "围绕球心均匀缩放",
            "affine_axis_point": center,
            "affine_axis_direction": (0.0, 0.0, 1.0),
            "affine_axis_source": "sphere center",
            "affine_anchor_source": "sphere center",
            "affine_target_kind": target_kind,
            "part_solid_count": part_solid_count,
        }

    def resize_spherical_radius(self, face_id: int, target_radius: float) -> str:
        plan = self.spherical_radius_plan(face_id, target_radius)
        if plan["status"] == "blocked":
            raise ValueError(str(plan["message"]))
        self._remember_face_target_logical_id(plan, face_id)
        _action_result, result_check = self._run_checked_face_edit(
            plan,
            lambda: self._apply_edge_length_affine_transform(plan),
        )
        return (
            "Spherical face radius resize completed by uniform scaling: "
            f"face {face_id}, "
            f"radius={float(plan['current_radius']):g}->{float(plan['target_radius']):g}, "
            f"scale={float(plan['affine_scale']):g}, "
            f"target={plan.get('affine_target_kind')}, "
            f"risk={plan['risk']}. {result_check}"
        )

    def toroidal_radius_plan(self, face_id: int, target_radius: float, mode: str = "minor") -> dict[str, object]:
        if face_id < 0 or face_id >= len(self.faces):
            raise ValueError(f"Unknown face id {face_id}")
        mode_key = "major" if str(mode).lower() in {"major", "main", "major_radius"} else "minor"
        info = self.face_info(face_id)
        blockers: list[str] = []
        warnings: list[str] = [
            "环面半径修改会围绕环面中心均匀缩放所属零件/Solid；主半径和小半径会等比例变化。"
        ]
        risk = "medium"

        try:
            target_radius = float(target_radius)
        except (TypeError, ValueError):
            target_radius = 0.0
            blockers.append("目标环面半径必须是数字。")

        current_major = _float_or_none(info.get("major_radius"))
        current_minor = _float_or_none(info.get("minor_radius"))
        current_radius = current_major if mode_key == "major" else current_minor
        center = _tuple_or_none(info.get("center"))
        axis = _tuple_normalized(_tuple_or_none(info.get("axis"))) or (0.0, 0.0, 1.0)
        if info.get("surface") != "torus":
            blockers.append("当前选中 Face 不是环面。")
        if current_major is None or current_major <= 1e-9 or current_minor is None or current_minor <= 1e-9:
            blockers.append("当前环面缺少有效主半径或小半径。")
        if center is None:
            blockers.append("当前环面缺少稳定中心，不能缩放。")
        if target_radius <= 1e-9:
            blockers.append("目标环面半径必须大于 0。")

        scale = target_radius / max(current_radius or 1.0, 1e-9)
        target_major = None if current_major is None else current_major * scale
        target_minor = None if current_minor is None else current_minor * scale
        delta_radius = target_radius - float(current_radius or 0.0)
        delta_ratio = abs(delta_radius) / max(float(current_radius or 0.0), 1e-9)
        if current_radius is not None and abs(delta_radius) <= max(current_radius * 1e-6, 1e-6):
            blockers.append("目标环面半径与当前值几乎相同，不需要修改。")
        if delta_ratio > 0.6:
            risk = _max_risk(risk, "high")
            warnings.append("环面半径变化超过 60%，可能明显影响周边几何。")
        elif delta_ratio > 0.25:
            risk = _max_risk(risk, "high")
            warnings.append("环面半径变化超过 25%，修改后请重点检查相邻面。")

        part_id = int(info.get("part_id", -1))
        solid_id = int(info.get("solid_id", -1))
        part = self.part_by_id(part_id) if part_id >= 0 else None
        if part is None:
            blockers.append("找不到当前环面所属零件。")
            part_solid_count = 0
        else:
            part_solid_count = len(_explore(part.shape, TopAbs_SOLID))
        target_kind = "solid" if solid_id >= 0 and part_solid_count > 1 else "part"
        warnings.append(f"当前会缩放所属 {target_kind}，可能影响同一对象上的其它尺寸。")

        status = "blocked" if blockers else "caution"
        if blockers:
            risk = "blocked"
        return {
            "status": status,
            "risk": risk,
            "message": " ".join(blockers + warnings),
            "warnings": "；".join(warnings),
            "blockers": "；".join(blockers),
            "face_id": face_id,
            "part_id": part_id,
            "solid_id": solid_id,
            "surface": info.get("surface"),
            "torus_radius_mode": mode_key,
            "current_major_radius": current_major,
            "target_major_radius": target_major,
            "current_minor_radius": current_minor,
            "target_minor_radius": target_minor,
            "target_radius": target_radius,
            "delta_radius": delta_radius,
            "radius_delta_ratio": delta_ratio,
            "center": center,
            "axis": axis,
            "resize_strategy": "uniform-scale-torus-radius",
            "edit_strategy_label": "围绕环面中心均匀缩放",
            "edit_semantics": "按目标环面半径围绕环面中心均匀缩放所属对象，主半径和小半径会等比例变化。",
            "affine_scale": scale,
            "affine_transform_kind": "uniform",
            "affine_transform_label": "围绕环面中心均匀缩放",
            "affine_axis_point": center,
            "affine_axis_direction": axis,
            "affine_axis_source": "torus center",
            "affine_anchor_source": "torus center",
            "affine_target_kind": target_kind,
            "part_solid_count": part_solid_count,
        }

    def resize_toroidal_radius(self, face_id: int, target_radius: float, mode: str = "minor") -> str:
        plan = self.toroidal_radius_plan(face_id, target_radius, mode)
        if plan["status"] == "blocked":
            raise ValueError(str(plan["message"]))
        self._remember_face_target_logical_id(plan, face_id)
        _action_result, result_check = self._run_checked_face_edit(
            plan,
            lambda: self._apply_edge_length_affine_transform(plan),
        )
        mode_label = "major" if plan.get("torus_radius_mode") == "major" else "minor"
        current = plan.get("current_major_radius") if mode_label == "major" else plan.get("current_minor_radius")
        target = plan.get("target_major_radius") if mode_label == "major" else plan.get("target_minor_radius")
        return (
            "Toroidal face radius resize completed by uniform scaling: "
            f"face {face_id}, {mode_label}_radius={float(current):g}->{float(target):g}, "
            f"scale={float(plan['affine_scale']):g}, "
            f"target={plan.get('affine_target_kind')}, "
            f"risk={plan['risk']}. {result_check}"
        )

    def face_area_scale_plan(self, face_id: int, target_area: float) -> dict[str, object]:
        if face_id < 0 or face_id >= len(self.faces):
            raise ValueError(f"Unknown face id {face_id}")
        info = self.face_info(face_id)
        blockers: list[str] = []
        warnings: list[str] = [
            "目标面面积不是 STEP 原始 CAD 历史参数；当前采用围绕当前面的面积中心均匀缩放所属特征或 Solid 的语义。"
        ]
        risk = "high"
        first_level_fields = self._face_first_level_plan_fields(face_id)

        try:
            target_area = float(target_area)
        except (TypeError, ValueError):
            target_area = 0.0
            blockers.append("目标面面积必须是数字。")

        current_area = _float_or_none(info.get("area"))
        center = _tuple_or_none(info.get("area_center")) or _tuple_or_none(info.get("bbox_center"))
        if current_area is None or current_area <= 1e-9:
            blockers.append("当前面缺少有效面积。")
        if center is None:
            blockers.append("当前面缺少稳定面积中心，不能缩放。")
        if target_area <= 1e-9:
            blockers.append("目标面面积必须大于 0。")
        if current_area is not None and abs(target_area - current_area) <= max(current_area * 1e-6, 1e-6):
            blockers.append("目标面面积与当前值几乎相同，不需要修改。")

        scale = (
            math.sqrt(target_area / max(float(current_area), 1e-9))
            if target_area > 1e-9 and current_area is not None and current_area > 1e-9
            else 1.0
        )
        area_delta = target_area - float(current_area or 0.0)
        area_delta_ratio = abs(area_delta) / max(float(current_area or 0.0), 1e-9)
        if scale < 0.05:
            blockers.append("目标面面积会把所属对象整体缩放到当前尺寸的 5% 以下，容易生成退化几何。")
        elif scale > 5.0:
            blockers.append("目标面面积会把所属对象整体放大到当前尺寸的 5 倍以上，风险过高。")
        if area_delta_ratio <= 0.15:
            risk = "medium"
        elif area_delta_ratio > 0.8:
            warnings.append("目标面积变化超过 80%，很可能明显影响周边几何。")
        else:
            warnings.append("目标面积变化较大，修改后请重点检查周边尺寸。")

        part_id = int(info.get("part_id", -1))
        solid_id = int(info.get("solid_id", -1))
        part = self.part_by_id(part_id) if part_id >= 0 else None
        if part is None:
            blockers.append("找不到当前面所属零件。")
            part_solid_count = 0
        else:
            part_solid_count = len(_explore(part.shape, TopAbs_SOLID))
        target_kind = "solid" if solid_id >= 0 and part_solid_count > 1 else "part"
        target_label = "Solid" if target_kind == "solid" else "特征"
        warnings.append(f"当前会缩放所属{target_label}，该对象上的其它尺寸会一起变化。")

        status = "blocked" if blockers else "caution"
        if blockers:
            risk = "blocked"
        return {
            "status": status,
            "risk": risk,
            "message": " ".join(blockers + warnings),
            "warnings": "；".join(warnings),
            "blockers": "；".join(blockers),
            "face_id": face_id,
            "part_id": part_id,
            "solid_id": solid_id,
            **first_level_fields,
            "surface": info.get("surface"),
            "current_area": current_area,
            "target_area": target_area,
            "area_delta": area_delta,
            "area_delta_ratio": area_delta_ratio,
            "area_center": center,
            "resize_strategy": "uniform-scale-face-area-fallback",
            "edit_strategy_label": "按目标面面积缩放所属对象",
            "edit_semantics": "围绕当前面的面积中心均匀缩放所属特征或 Solid；目标 Face 和同一对象上的其它尺寸会一起变化。",
            "affine_scale": scale,
            "affine_transform_kind": "uniform",
            "affine_transform_label": "按目标面面积缩放所属对象",
            "affine_transform_note": "围绕当前面面积中心做均匀缩放；目标 Face 和同一所属对象上的其它尺寸会一起变化。",
            "affine_axis_point": center,
            "affine_axis_direction": (0.0, 0.0, 1.0),
            "affine_axis_source": "face area center",
            "affine_anchor_source": "face area center",
            "affine_target_kind": target_kind,
            "part_solid_count": part_solid_count,
        }

    def resize_face_area(self, face_id: int, target_area: float) -> str:
        plan = self.face_area_scale_plan(face_id, target_area)
        if plan["status"] == "blocked":
            raise ValueError(str(plan["message"]))
        self._remember_face_target_logical_id(plan, face_id)
        _action_result, result_check = self._run_checked_face_edit(
            plan,
            lambda: self._apply_edge_length_affine_transform(plan),
        )
        return (
            "Face area resize completed by uniform scaling fallback: "
            f"face {face_id}, "
            f"area={float(plan['current_area']):g}->{float(plan['target_area']):g}, "
            f"scale={float(plan['affine_scale']):g}, "
            f"target={plan.get('affine_target_kind')}, "
            f"risk={plan['risk']}. {result_check}"
        )

    def cylindrical_resize_preview_polydata(
        self,
        face_id: int,
        new_diameter: float,
        deflection: float = 0.8,
    ) -> list[dict[str, object]]:
        plan = self.cylindrical_resize_plan(face_id, new_diameter)
        if plan["status"] == "blocked":
            raise ValueError(str(plan["message"]))

        face = self.faces[face_id]
        surf = BRepAdaptor_Surface(face)
        if surf.GetType() != GeomAbs_Cylinder:
            raise ValueError("Cylinder resize preview currently supports cylindrical faces only.")

        direction = surf.Cylinder().Axis().Direction()
        previews: list[dict[str, object]] = []

        if plan["resize_mode"] == "shrink" and "fill_start_point" in plan:
            fill_start = gp_Pnt(*plan["fill_start_point"])
            fill_axis = gp_Ax2(fill_start, gp_Dir(direction.X(), direction.Y(), direction.Z()))
            filler = BRepPrimAPI_MakeCylinder(
                fill_axis,
                float(plan["fill_radius"]),
                float(plan["fill_height"]),
            ).Shape()
            BRepMesh_IncrementalMesh(filler, deflection)
            previews.append(
                {
                    "role": "fill",
                    "label": "补料预览",
                    "polydata": _shape_faces_polydata(filler),
                }
            )

        cutter_start = gp_Pnt(*plan["cutter_start_point"])
        cutter_axis = gp_Ax2(cutter_start, gp_Dir(direction.X(), direction.Y(), direction.Z()))
        cutter = BRepPrimAPI_MakeCylinder(
            cutter_axis,
            float(plan["cutter_radius"]),
            float(plan["cutter_height"]),
        ).Shape()
        BRepMesh_IncrementalMesh(cutter, deflection)
        previews.append(
            {
                "role": "cutter",
                "label": "切削预览",
                "polydata": _shape_faces_polydata(cutter),
            }
        )
        return previews

    def cylindrical_boss_resize_preview_polydata(
        self,
        face_id: int,
        new_diameter: float,
        deflection: float = 0.8,
    ) -> list[dict[str, object]]:
        plan = self.cylindrical_boss_resize_plan(face_id, new_diameter)
        if plan["status"] == "blocked":
            raise ValueError(str(plan["message"]))

        start = gp_Pnt(*plan["boss_tool_start_point"])
        direction = gp_Dir(*plan["boss_tool_axis_direction"])
        axis = gp_Ax2(start, direction)
        height = float(plan["boss_tool_height"])
        if plan["resize_mode"] == "enlarge":
            tool = BRepPrimAPI_MakeCylinder(axis, float(plan["boss_tool_radius"]), height).Shape()
            BRepMesh_IncrementalMesh(tool, deflection)
            return [
                {
                    "role": "fill",
                    "label": "凸台扩大补料预览",
                    "polydata": _shape_faces_polydata(tool),
                }
            ]

        removal = BRepPrimAPI_MakeCylinder(axis, float(plan["boss_tool_outer_radius"]), height).Shape()
        replacement = BRepPrimAPI_MakeCylinder(axis, float(plan["boss_tool_inner_radius"]), height).Shape()
        BRepMesh_IncrementalMesh(removal, deflection)
        BRepMesh_IncrementalMesh(replacement, deflection)
        return [
            {
                "role": "cutter",
                "label": "凸台缩小移除范围预览",
                "polydata": _shape_faces_polydata(removal),
            },
            {
                "role": "fill",
                "label": "凸台缩小重建目标预览",
                "polydata": _shape_faces_polydata(replacement),
            },
        ]

    def cylindrical_suppress_preview_polydata(
        self,
        face_id: int,
        deflection: float = 0.8,
    ) -> list[dict[str, object]]:
        plan = self.cylindrical_suppress_plan(face_id)
        if plan["status"] == "blocked":
            raise ValueError(str(plan["message"]))

        face = self.faces[face_id]
        surf = BRepAdaptor_Surface(face)
        if surf.GetType() != GeomAbs_Cylinder:
            raise ValueError("Cylinder suppress preview currently supports cylindrical faces only.")

        direction = surf.Cylinder().Axis().Direction()
        fill_start = gp_Pnt(*plan["fill_start_point"])
        fill_axis = gp_Ax2(fill_start, gp_Dir(direction.X(), direction.Y(), direction.Z()))
        filler = BRepPrimAPI_MakeCylinder(
            fill_axis,
            float(plan["fill_radius"]),
            float(plan["fill_height"]),
        ).Shape()
        BRepMesh_IncrementalMesh(filler, deflection)
        return [
            {
                "role": "fill",
                "label": "封堵补料预览",
                "polydata": _shape_faces_polydata(filler),
            }
        ]

    def cylindrical_depth_preview_polydata(
        self,
        face_id: int,
        target_depth: float,
        bottom_face_id: int | None = None,
        deflection: float = 0.8,
    ) -> list[dict[str, object]]:
        plan = self.cylindrical_depth_plan(
            face_id,
            target_depth,
            bottom_face_id=bottom_face_id,
        )
        if plan["status"] == "blocked":
            raise ValueError(str(plan["message"]))

        start = gp_Pnt(*plan["depth_tool_start_point"])
        direction = gp_Dir(*plan["depth_axis_direction"])
        axis = gp_Ax2(start, direction)
        tool = BRepPrimAPI_MakeCylinder(
            axis,
            float(plan["depth_tool_radius"]),
            float(plan["depth_tool_height"]),
        ).Shape()
        BRepMesh_IncrementalMesh(tool, deflection)
        role = str(plan["depth_tool_role"])
        return [
            {
                "role": role,
                "label": "切削预览" if role == "cutter" else "补料预览",
                "polydata": _shape_faces_polydata(tool),
            }
        ]

    def existing_fillet_resize_preview_polydata(
        self,
        face_id: int,
        target_radius: float,
        deflection: float = 0.8,
    ) -> list[dict[str, object]]:
        plan = self.existing_fillet_resize_plan(face_id, target_radius)
        if plan["status"] == "blocked":
            raise ValueError(str(plan["message"]))
        return [
            {
                "role": "remove",
                "label": "将移除并重建的已有圆角面",
                "polydata": self.build_face_polydata(face_ids=[face_id], deflection=deflection),
            }
        ]

    def push_pull_preview_polydata(self, face_id: int, distance: float, deflection: float = 0.8):
        plan = self.push_pull_plan(face_id, distance)
        if plan["status"] == "blocked":
            raise ValueError(str(plan["message"]))
        face = self.faces[face_id]
        scope_face_ids = _int_values(plan.get("push_pull_scope_face_ids")) or [face_id]
        profile_shape = self._push_pull_profile_shape(scope_face_ids)
        surf = BRepAdaptor_Surface(face)
        if surf.GetType() != GeomAbs_Plane:
            raise ValueError("Push/pull preview currently supports planar faces only.")

        outward = plan["outward_direction"]
        vec = gp_Vec(
            float(outward[0]) * distance,
            float(outward[1]) * distance,
            float(outward[2]) * distance,
        )
        preview_shape = BRepPrimAPI_MakePrism(profile_shape, vec).Shape()
        BRepMesh_IncrementalMesh(preview_shape, deflection)
        return _shape_faces_polydata(preview_shape)

    def straight_edge_length_preview_polydata(
        self,
        edge_id: int,
        target_length: float,
        deflection: float = 0.8,
        anchor_mode: str = "auto",
        strategy_mode: str = "auto",
    ):
        plan = self.general_edge_length_plan(
            edge_id,
            target_length,
            anchor_mode=anchor_mode,
            strategy_mode=strategy_mode,
        )
        if plan["status"] == "blocked":
            raise ValueError(str(plan["message"]))
        if plan.get("resize_strategy") == "local-edge-only-deform":
            preview_shape = self._local_edge_deform_shape(plan)
            BRepMesh_IncrementalMesh(preview_shape, deflection)
            return _shape_faces_polydata(preview_shape)
        if plan.get("resize_strategy") == "move-edge-end-plane-by-push-pull":
            return self.push_pull_preview_polydata(int(plan["end_face_id"]), float(plan["push_pull_distance"]), deflection)
        if plan.get("resize_strategy") == "resize-adjacent-cylinder-from-circular-edge-length":
            face_id = int(plan["cylinder_resize_face_id"])
            target_diameter = float(plan["cylinder_resize_target_diameter"])
            if plan.get("circular_edge_cylinder_mode") == "boss":
                return self.cylindrical_boss_resize_preview_polydata(face_id, target_diameter, deflection)
            return self.cylindrical_resize_preview_polydata(face_id, target_diameter, deflection)
        preview_shape = self._edge_length_affine_preview_shape(plan)
        BRepMesh_IncrementalMesh(preview_shape, deflection)
        return _shape_faces_polydata(preview_shape)

    def resize_straight_edge_length(
        self,
        edge_id: int,
        target_length: float,
        anchor_mode: str = "auto",
        strategy_mode: str = "auto",
    ) -> str:
        return self.resize_general_edge_length(
            edge_id,
            target_length,
            anchor_mode=anchor_mode,
            strategy_mode=strategy_mode,
        )

    def resize_general_edge_length(
        self,
        edge_id: int,
        target_length: float,
        anchor_mode: str = "auto",
        strategy_mode: str = "auto",
    ) -> str:
        plan = self.general_edge_length_plan(
            edge_id,
            target_length,
            anchor_mode=anchor_mode,
            strategy_mode=strategy_mode,
        )
        if plan["status"] == "blocked":
            raise ValueError(str(plan["message"]))
        part_id = int(plan.get("part_id", -1))
        part = self.part_by_id(part_id) if part_id >= 0 else None
        old_part_shape = part.shape if part is not None else None
        if plan.get("resize_strategy") == "local-edge-only-deform":
            try:
                self._apply_local_edge_deform(plan)
                result_check = self._edge_length_result_summary_or_raise(plan)
                return (
                    "Edge length resize completed by local edge-only deformation: "
                    f"edge {edge_id}, current_length={float(plan['current_length']):g}, "
                    f"target_length={float(plan['target_length']):g}, "
                    f"delta={float(plan['delta_length']):g}, "
                    f"anchor={plan.get('local_edge_deform_anchor')}, "
                    f"rebuilt_faces={plan.get('local_edge_deform_face_count')}, "
                    f"target={plan.get('local_edge_deform_target_kind')}, "
                    f"risk={plan['risk']}. {result_check}"
                )
            except Exception:
                if part is not None and old_part_shape is not None:
                    part.shape = old_part_shape
                    self.refresh_topology()
                raise
        if plan.get("resize_strategy") == "move-edge-end-plane-by-push-pull":
            try:
                push_result = self.push_pull_face(int(plan["end_face_id"]), float(plan["push_pull_distance"]))
                result_check = self._edge_length_result_summary_or_raise(plan)
                return (
                    "Edge length resize completed by end-face push/pull: "
                    f"edge {edge_id}, current_length={float(plan['current_length']):g}, "
                    f"target_length={float(plan['target_length']):g}, "
                    f"delta={float(plan['delta_length']):g}, "
                    f"end_face={int(plan['end_face_id'])}, "
                    f"push_pull_distance={float(plan['push_pull_distance']):g}, "
                    f"anchor={plan.get('edge_length_anchor_label')}, "
                    f"risk={plan['risk']}. {result_check} {push_result}"
                )
            except Exception:
                if part is not None and old_part_shape is not None:
                    part.shape = old_part_shape
                    self.refresh_topology()
                raise

        if plan.get("resize_strategy") == "resize-adjacent-cylinder-from-circular-edge-length":
            try:
                face_id = int(plan["cylinder_resize_face_id"])
                target_diameter = float(plan["cylinder_resize_target_diameter"])
                if plan.get("circular_edge_cylinder_mode") == "boss":
                    resize_result = self.resize_cylindrical_boss(face_id, target_diameter)
                else:
                    resize_result = self.resize_cylindrical_hole(face_id, target_diameter)
                result_check = self._edge_length_result_summary_or_raise(plan)
                return (
                    "Edge length resize completed by adjacent cylinder diameter edit: "
                    f"edge {edge_id}, current_length={float(plan['current_length']):g}, "
                    f"target_length={float(plan['target_length']):g}, "
                    f"delta={float(plan['delta_length']):g}, "
                    f"cylinder_face={face_id}, "
                    f"target_diameter={target_diameter:g}, "
                    f"mode={plan.get('circular_edge_cylinder_mode_label')}, "
                    f"risk={plan['risk']}. {result_check} {resize_result}"
                )
            except Exception:
                if part is not None and old_part_shape is not None:
                    part.shape = old_part_shape
                    self.refresh_topology()
                raise

        try:
            self._apply_edge_length_affine_transform(plan)
            result_check = self._edge_length_result_summary_or_raise(plan)
            return (
                "Edge length resize completed by geometric scale fallback: "
                f"edge {edge_id}, current_length={float(plan['current_length']):g}, "
                f"target_length={float(plan['target_length']):g}, "
                f"delta={float(plan['delta_length']):g}, "
                f"scale={float(plan['affine_scale']):g}, "
                f"transform={plan.get('affine_transform_label') or plan.get('affine_transform_kind')}, "
                f"predicted_edge_length={float(plan.get('affine_predicted_edge_length') or 0.0):g}, "
                f"axis_source={plan.get('affine_axis_source')}, "
                f"anchor={plan.get('edge_length_anchor_label')}, "
                f"target={plan.get('affine_target_kind')}, "
                f"risk={plan['risk']}. {result_check}"
            )
        except Exception:
            if part is not None and old_part_shape is not None:
                part.shape = old_part_shape
                self.refresh_topology()
            raise

    def move_edge_endpoint(
        self,
        edge_id: int,
        endpoint_role: str,
        target_point: tuple[float, float, float],
    ) -> str:
        plan = self.edge_endpoint_move_plan(edge_id, endpoint_role, target_point)
        if plan["status"] == "blocked":
            raise ValueError(str(plan["message"]))
        if plan.get("resize_strategy") != "local-edge-endpoint-deform":
            raise ValueError("Unsupported Edge endpoint move strategy.")

        part_id = int(plan.get("part_id", -1))
        part = self.part_by_id(part_id) if part_id >= 0 else None
        old_part_shape = part.shape if part is not None else None
        try:
            self._apply_local_edge_deform(plan)
            result_check = self._edge_length_result_summary_or_raise(plan)
            return (
                "Edge endpoint move completed by local edge deformation: "
                f"edge {edge_id}, "
                f"endpoint={plan.get('edge_endpoint_role')}, "
                f"current_endpoint={plan.get('current_endpoint_point')}, "
                f"target_endpoint={plan.get('target_endpoint_point')}, "
                f"move={plan.get('moved_endpoint_delta')}, "
                f"current_length={float(plan['current_length']):g}, "
                f"target_length={float(plan['target_length']):g}, "
                f"delta={float(plan['delta_length']):g}, "
                f"rebuilt_faces={plan.get('local_edge_deform_face_count')}, "
                f"target={plan.get('local_edge_deform_target_kind')}, "
                f"risk={plan['risk']}. {result_check}"
            )
        except Exception:
            if part is not None and old_part_shape is not None:
                part.shape = old_part_shape
                self.refresh_topology()
            raise

    def move_edge_center(
        self,
        edge_id: int,
        target_center: tuple[float, float, float],
    ) -> str:
        plan = self.edge_center_move_plan(edge_id, target_center)
        if plan["status"] == "blocked":
            raise ValueError(str(plan["message"]))
        if plan.get("resize_strategy") != "local-edge-center-deform":
            raise ValueError("Unsupported Edge center move strategy.")

        part_id = int(plan.get("part_id", -1))
        part = self.part_by_id(part_id) if part_id >= 0 else None
        old_part_shape = part.shape if part is not None else None
        try:
            self._apply_local_edge_deform(plan)
            result_check = self._edge_length_result_summary_or_raise(plan)
            return (
                "Edge center move completed by local edge deformation: "
                f"edge {edge_id}, "
                f"current_center={plan.get('current_edge_center')}, "
                f"target_center={plan.get('target_edge_center')}, "
                f"move={plan.get('moved_edge_center_delta')}, "
                f"edge_length={float(plan['current_length']):g}, "
                f"rebuilt_faces={plan.get('local_edge_deform_face_count')}, "
                f"target={plan.get('local_edge_deform_target_kind')}, "
                f"risk={plan['risk']}. {result_check}"
            )
        except Exception:
            if part is not None and old_part_shape is not None:
                part.shape = old_part_shape
                self.refresh_topology()
            raise

    def face_center_local_move_preview_polydata(
        self,
        face_id: int,
        target_center: tuple[float, float, float],
        deflection: float = 0.8,
    ):
        plan = self.face_center_local_move_plan(face_id, target_center)
        if plan["status"] == "blocked":
            raise ValueError(str(plan["message"]))
        preview_shape = self._local_face_deform_shape(plan)
        BRepMesh_IncrementalMesh(preview_shape, deflection)
        return _shape_faces_polydata(preview_shape)

    def move_face_center_local(
        self,
        face_id: int,
        target_center: tuple[float, float, float],
    ) -> str:
        plan = self.face_center_local_move_plan(face_id, target_center)
        if plan["status"] == "blocked":
            raise ValueError(str(plan["message"]))

        self._remember_face_target_logical_id(plan, face_id)
        _action_result, result_check = self._run_checked_face_edit(
            plan,
            lambda: self._apply_local_face_deform(plan),
        )
        return (
            "Face center move completed by local face-only deformation: "
            f"face {face_id}, "
            f"current_center={plan.get('current_face_center')}, "
            f"target_center={plan.get('target_face_center')}, "
            f"move={plan.get('face_center_move_vector')}, "
            f"moved_points={plan.get('local_face_deform_moved_point_count')}, "
            f"rebuilt_faces={plan.get('local_face_deform_face_count')}, "
            f"target={plan.get('local_face_deform_target_kind')}, "
            f"risk={plan['risk']}. {result_check}"
        )

    def face_area_local_resize_preview_polydata(
        self,
        face_id: int,
        target_area: float,
        deflection: float = 0.8,
    ):
        plan = self.face_area_local_resize_plan(face_id, target_area)
        if plan["status"] == "blocked":
            raise ValueError(str(plan["message"]))
        preview_shape = self._local_face_deform_shape(plan)
        BRepMesh_IncrementalMesh(preview_shape, deflection)
        return _shape_faces_polydata(preview_shape)

    def resize_face_area_local(self, face_id: int, target_area: float) -> str:
        plan = self.face_area_local_resize_plan(face_id, target_area)
        if plan["status"] == "blocked":
            raise ValueError(str(plan["message"]))

        self._remember_face_target_logical_id(plan, face_id)
        _action_result, result_check = self._run_checked_face_edit(
            plan,
            lambda: self._apply_local_face_deform(plan),
        )
        return (
            "Face area resize completed by local face-only deformation: "
            f"face {face_id}, "
            f"current_area={float(plan['current_area']):g}, "
            f"target_area={float(plan['target_area']):g}, "
            f"delta={float(plan['area_delta']):g}, "
            f"area_scale={float(plan['local_face_area_scale']):g}, "
            f"moved_points={plan.get('local_face_deform_moved_point_count')}, "
            f"rebuilt_faces={plan.get('local_face_deform_face_count')}, "
            f"target={plan.get('local_face_deform_target_kind')}, "
            f"risk={plan['risk']}. {result_check}"
        )

    def face_size_local_resize_preview_polydata(
        self,
        face_id: int,
        target_size: float,
        axis: str = "width",
        deflection: float = 0.8,
    ):
        plan = self.face_size_local_resize_plan(face_id, target_size, axis)
        if plan["status"] == "blocked":
            raise ValueError(str(plan["message"]))
        preview_shape = self._local_face_deform_shape(plan)
        BRepMesh_IncrementalMesh(preview_shape, deflection)
        return _shape_faces_polydata(preview_shape)

    def resize_face_size_local(self, face_id: int, target_size: float, axis: str = "width") -> str:
        plan = self.face_size_local_resize_plan(face_id, target_size, axis)
        if plan["status"] == "blocked":
            raise ValueError(str(plan["message"]))

        self._remember_face_target_logical_id(plan, face_id)
        _action_result, result_check = self._run_checked_face_edit(
            plan,
            lambda: self._apply_local_face_deform(plan),
        )
        return (
            "Face local size resize completed by local face-only deformation: "
            f"face {face_id}, "
            f"axis={plan.get('face_size_axis')}, "
            f"current_size={float(plan['current_face_size']):g}, "
            f"target_size={float(plan['target_face_size']):g}, "
            f"delta={float(plan['face_size_delta']):g}, "
            f"scale={float(plan['face_size_scale']):g}, "
            f"moved_points={plan.get('local_face_deform_moved_point_count')}, "
            f"rebuilt_faces={plan.get('local_face_deform_face_count')}, "
            f"target={plan.get('local_face_deform_target_kind')}, "
            f"risk={plan['risk']}. {result_check}"
        )

    def face_size_owning_scale_preview_polydata(
        self,
        face_id: int,
        target_size: float,
        axis: str = "width",
        deflection: float = 0.8,
    ):
        plan = self.face_size_owning_scale_plan(face_id, target_size, axis)
        if plan["status"] == "blocked":
            raise ValueError(str(plan["message"]))
        if plan.get("owning_face_size_rebuild_mode") == "planar-rebuild":
            preview_shape = self._local_face_deform_shape(plan)
        else:
            preview_shape = self._edge_length_affine_preview_shape(plan)
        BRepMesh_IncrementalMesh(preview_shape, deflection)
        return _shape_faces_polydata(preview_shape)

    def resize_face_size_owning_scale(self, face_id: int, target_size: float, axis: str = "width") -> str:
        plan = self.face_size_owning_scale_plan(face_id, target_size, axis)
        if plan["status"] == "blocked":
            raise ValueError(str(plan["message"]))

        self._remember_face_target_logical_id(plan, face_id)
        _action_result, result_check = self._run_checked_face_edit(
            plan,
            lambda: (
                self._apply_local_face_deform(plan)
                if plan.get("owning_face_size_rebuild_mode") == "planar-rebuild"
                else self._apply_edge_length_affine_transform(plan)
            ),
        )
        return (
            "Face owning size resize completed by axis-affine scaling: "
            f"face {face_id}, "
            f"axis={plan.get('face_size_axis')}, "
            f"current_size={float(plan['current_face_size']):g}, "
            f"target_size={float(plan['target_face_size']):g}, "
            f"delta={float(plan['face_size_delta']):g}, "
            f"scale={float(plan['face_size_scale']):g}, "
            f"rebuild_mode={plan.get('owning_face_size_rebuild_mode')}, "
            f"target={plan.get('affine_target_kind')}, "
            f"risk={plan['risk']}. {result_check}"
        )

    def _remember_face_target_logical_id(self, plan: dict[str, object], face_id: int) -> None:
        try:
            if 0 <= int(face_id) < len(self.faces):
                plan["target_logical_id"] = self.face_region_logical_id(int(face_id))
        except Exception:
            pass

    def _face_edit_snapshot(self, plan: dict[str, object]) -> list[tuple[object, TopoDS_Shape]]:
        part_id = _int_or_none(plan.get("part_id"))
        snapshot: list[tuple[object, TopoDS_Shape]] = []
        if part_id is not None:
            part = self.part_by_id(part_id)
            if part is not None:
                snapshot.append((part, part.shape))
        if snapshot:
            return snapshot
        for part in self.display_parts():
            snapshot.append((part, part.shape))
        return snapshot

    def _restore_face_edit_snapshot(self, snapshot: list[tuple[object, TopoDS_Shape]]) -> None:
        for part, shape in snapshot:
            part.shape = shape
        self.refresh_topology()

    def _checked_face_edit_result_summary(self, plan: dict[str, object]) -> str:
        part_id = _int_or_none(plan.get("part_id"))
        part = self.part_by_id(part_id) if part_id is not None else None
        if part is not None:
            _ensure_valid_shape(part.shape)
        else:
            _ensure_valid_shape(self.shape)

        check = self._face_edit_result_check(plan)
        if check is None:
            return "Face result check unavailable."
        metric = check.get("metric")
        scope = check.get("scope")
        if int(check.get("face_id", -1)) < 0:
            raise RuntimeError(f"Face edit result has no matching target Face, metric={metric}, scope={scope}.")
        error = float(check.get("error", math.inf))
        tolerance = float(check.get("tolerance", 0.0))
        if not math.isfinite(error) or error > tolerance:
            target = check.get("target")
            actual = check.get("actual")
            target_text = _format_tuple(target) if isinstance(target, tuple) else _format_result_number(target)
            actual_text = _format_tuple(actual) if isinstance(actual, tuple) else _format_result_number(actual)
            raise RuntimeError(
                "Face edit result target check failed: "
                f"metric={metric}, actual={actual_text}, target={target_text}, "
                f"error={error:g}, tolerance={tolerance:g}, scope={scope}."
            )

        first_level_summary = ""
        if str(plan.get("surface") or "") == "plane":
            matched_face_id = int(check["face_id"])
            topology = self.face_first_level_topology(matched_face_id)
            boundary_edges = int(topology.get("first_level_boundary_edge_count", 0) or 0)
            boundary_vertices = int(topology.get("first_level_boundary_vertex_count", 0) or 0)
            adjacent_faces = int(topology.get("first_level_adjacent_face_count", 0) or 0)
            expected_edges = int(plan.get("first_level_boundary_edge_count", 0) or 0)
            expected_vertices = int(plan.get("first_level_boundary_vertex_count", 0) or 0)
            expected_adjacent = int(plan.get("first_level_adjacent_face_count", 0) or 0)
            expected_inner_wires = int(plan.get("selected_inner_boundary_wires", 0) or 0)
            matched_info = self.quick_face_info(matched_face_id)
            boundary_wires = int(matched_info.get("boundary_wires", 0) or 0)
            inner_boundary_wires = int(matched_info.get("inner_boundary_wires", 0) or 0)
            expected_scope_area = _float_or_none(plan.get("push_pull_scope_area"))
            matched_area = _float_or_none(matched_info.get("area"))
            same_domain_count = int(plan.get("same_domain_face_count", 1) or 1)
            polygonal_plan = expected_edges >= 3 and expected_vertices >= 3
            area_summary = ""
            if (
                expected_scope_area is not None
                and expected_scope_area > 1e-9
                and matched_area is not None
                and str(check.get("metric") or "") == "plane_position"
            ):
                area_tolerance = max(expected_scope_area * 0.02, 1e-4)
                if abs(matched_area - expected_scope_area) > area_tolerance:
                    raise RuntimeError(
                        "Face edit result lost part of the pushed/pulled Face region area; "
                        f"expected_area={expected_scope_area:g}, actual_area={matched_area:g}, "
                        f"tolerance={area_tolerance:g}."
                    )
                area_summary = f"area={matched_area:g}, expected_area={expected_scope_area:g}; "
            if polygonal_plan:
                if same_domain_count > 1:
                    minimum_edges = 3
                    minimum_vertices = 3
                    minimum_adjacent = min(max(expected_adjacent, 1), 3) if expected_adjacent > 0 else 0
                else:
                    minimum_edges = expected_edges
                    minimum_vertices = expected_vertices
                    minimum_adjacent = expected_adjacent
            else:
                minimum_edges = 1 if expected_edges > 0 else 0
                minimum_vertices = 0
                minimum_adjacent = 1 if expected_adjacent > 0 else 0
            if boundary_edges <= 0:
                raise RuntimeError(
                    "Face edit result first-level topology check failed: "
                    f"boundary_edges={boundary_edges}, boundary_vertices={boundary_vertices}."
                )
            if minimum_vertices > 0 and boundary_vertices < minimum_vertices:
                raise RuntimeError(
                    "Face edit result lost required first-level boundary vertices; "
                    f"required_after>={minimum_vertices}, expected_before={expected_vertices}, "
                    f"actual_after={boundary_vertices}."
                )
            if minimum_edges > 0 and boundary_edges < minimum_edges:
                raise RuntimeError(
                    "Face edit result lost required first-level boundary edges; "
                    f"required_after>={minimum_edges}, expected_before={expected_edges}, "
                    f"actual_after={boundary_edges}."
                )
            if minimum_adjacent > 0 and adjacent_faces < minimum_adjacent:
                raise RuntimeError(
                    "Face edit result lost required direct shared-edge adjacent Faces; "
                    f"required_after>={minimum_adjacent}, expected_before={expected_adjacent}, "
                    f"actual_after={adjacent_faces}."
                )
            if expected_inner_wires > 0 and inner_boundary_wires < expected_inner_wires:
                raise RuntimeError(
                    "Face edit result lost required inner boundary wire(s); "
                    f"required_after>={expected_inner_wires}, actual_after={inner_boundary_wires}, "
                    f"boundary_wires={boundary_wires}."
                )

            try:
                facts = self.face_first_level_facts(matched_face_id, scope="face")
            except Exception as exc:
                raise RuntimeError(
                    "Face edit result first-level fact graph check failed: "
                    f"could not rebuild facts for Face {matched_face_id}: {exc}"
                ) from exc

            fact_status = str(facts.get("first_level_fact_status") or "")
            fact_scope = str(facts.get("first_level_fact_scope") or "")
            fact_boundary = str(facts.get("first_level_fact_relation_boundary") or "")
            fact_depth = int(facts.get("first_level_fact_relation_depth", 0) or 0)
            fact_subject = int(facts.get("first_level_fact_subject_face_count", 0) or 0)
            fact_boundary_edges = int(facts.get("first_level_fact_boundary_edge_count", 0) or 0)
            fact_boundary_vertices = int(facts.get("first_level_fact_boundary_vertex_count", 0) or 0)
            fact_adjacent = int(facts.get("first_level_fact_adjacent_face_count", 0) or 0)
            fact_included = int(facts.get("first_level_fact_included_face_count", 0) or 0)
            expected_fact_edges = int(plan.get("first_level_fact_boundary_edge_count", expected_edges) or 0)
            expected_fact_vertices = int(plan.get("first_level_fact_boundary_vertex_count", expected_vertices) or 0)
            expected_fact_adjacent = int(plan.get("first_level_fact_adjacent_face_count", expected_adjacent) or 0)
            fact_ignored_depths = tuple(str(item) for item in facts.get("first_level_fact_ignored_relation_depths", ()) or ())
            fact_role_groups = tuple(facts.get("first_level_fact_role_groups") or ())

            if fact_status != "ready" or fact_scope != "face" or fact_depth != 1 or fact_boundary != "shared-edge":
                raise RuntimeError(
                    "Face edit result first-level fact graph is not ready: "
                    f"status={fact_status}, scope={fact_scope}, depth={fact_depth}, boundary={fact_boundary}."
                )
            if fact_subject <= 0 or fact_included < fact_subject:
                raise RuntimeError(
                    "Face edit result first-level fact graph lost the edited subject region: "
                    f"subject_faces={fact_subject}, included_faces={fact_included}."
                )
            if "second-level" not in fact_ignored_depths or "third-level" not in fact_ignored_depths:
                raise RuntimeError(
                    "Face edit result first-level fact graph no longer records deferred deeper relations: "
                    f"ignored_depths={fact_ignored_depths}."
                )
            if not any(isinstance(item, dict) and item.get("role") == "selected-same-domain-region" for item in fact_role_groups):
                raise RuntimeError("Face edit result first-level fact graph lost the selected-region role group.")
            if expected_fact_adjacent > 0 and not any(
                isinstance(item, dict) and item.get("role") == "direct-adjacent" for item in fact_role_groups
            ):
                raise RuntimeError("Face edit result first-level fact graph lost the direct-adjacent role group.")

            if polygonal_plan:
                if same_domain_count > 1:
                    minimum_fact_edges = 3
                    minimum_fact_vertices = 3
                    minimum_fact_adjacent = min(max(expected_fact_adjacent, 1), 3) if expected_fact_adjacent > 0 else 0
                else:
                    minimum_fact_edges = expected_fact_edges
                    minimum_fact_vertices = expected_fact_vertices
                    minimum_fact_adjacent = expected_fact_adjacent
            else:
                minimum_fact_edges = 1 if expected_fact_edges > 0 else 0
                minimum_fact_vertices = 0
                minimum_fact_adjacent = 1 if expected_fact_adjacent > 0 else 0
            if minimum_fact_edges > 0 and fact_boundary_edges < minimum_fact_edges:
                raise RuntimeError(
                    "Face edit result first-level fact graph lost boundary Edges; "
                    f"required_after>={minimum_fact_edges}, expected_before={expected_fact_edges}, "
                    f"actual_after={fact_boundary_edges}."
                )
            if minimum_fact_vertices > 0 and fact_boundary_vertices < minimum_fact_vertices:
                raise RuntimeError(
                    "Face edit result first-level fact graph lost boundary Vertices; "
                    f"required_after>={minimum_fact_vertices}, expected_before={expected_fact_vertices}, "
                    f"actual_after={fact_boundary_vertices}."
                )
            if minimum_fact_adjacent > 0 and fact_adjacent < minimum_fact_adjacent:
                raise RuntimeError(
                    "Face edit result first-level fact graph lost direct adjacent Faces; "
                    f"required_after>={minimum_fact_adjacent}, expected_before={expected_fact_adjacent}, "
                    f"actual_after={fact_adjacent}."
                )
            first_level_summary = (
                " First-level check: "
                f"boundary_edges={boundary_edges}, boundary_vertices={boundary_vertices}, "
                f"adjacent_faces={adjacent_faces}, inner_wires={inner_boundary_wires}; "
                f"{area_summary}"
                f"fact_subject_faces={fact_subject}, fact_included_faces={fact_included}."
            )
        return self._face_edit_result_summary(plan, check) + first_level_summary

    def _run_checked_face_edit(
        self,
        plan: dict[str, object],
        action: Callable[[], object],
    ) -> tuple[object, str]:
        snapshot = self._face_edit_snapshot(plan)
        previous_logical_ids = tuple(getattr(self, "face_logical_ids", ()))
        previous_faces = tuple(self.faces)
        target_logical_id = _int_or_none(plan.get("target_logical_id"))
        if target_logical_id is None:
            plan_face_id = _int_or_none(plan.get("face_id"))
            if plan_face_id is not None and 0 <= plan_face_id < len(self.faces):
                try:
                    target_logical_id = self.face_region_logical_id(plan_face_id)
                except Exception:
                    target_logical_id = None
        excluded_logical_ids = (target_logical_id,)
        try:
            action_result = action()
            self._apply_preserved_face_logical_ids_by_shape_identity(
                previous_faces,
                previous_logical_ids,
                excluded_logical_ids=excluded_logical_ids,
            )
            result_check = self._checked_face_edit_result_summary(plan)
            return action_result, result_check
        except Exception as exc:
            self._restore_face_edit_snapshot(snapshot)
            self._restore_face_logical_ids_if_count_matches(previous_logical_ids)
            raise RuntimeError(f"Face edit failed and the model was restored: {exc}") from exc

    def _face_edit_result_summary(
        self,
        plan: dict[str, object],
        check: dict[str, object] | None = None,
    ) -> str:
        if check is None:
            check = self._face_edit_result_check(plan)
        if check is None:
            return "Face result check unavailable."
        if int(check.get("face_id", -1)) < 0:
            return f"Face result check: no matching Face found, metric={check.get('metric')}, scope={check.get('scope')}."
        target = check.get("target")
        actual = check.get("actual")
        target_text = _format_tuple(target) if isinstance(target, tuple) else _format_result_number(target)
        actual_text = _format_tuple(actual) if isinstance(actual, tuple) else _format_result_number(actual)
        return (
            "Face result check: "
            f"nearest_face={check['face_id']}, "
            f"metric={check['metric']}, "
            f"actual={actual_text}, "
            f"target={target_text}, "
            f"error={float(check['error']):g}, "
            f"tolerance={float(check['tolerance']):g}, "
            f"scope={check['scope']}."
        )

    def _face_edit_result_check(self, plan: dict[str, object]) -> dict[str, object] | None:
        face_ids, scope = self._face_edit_result_candidate_ids(plan)
        if not face_ids:
            return None

        metric = ""
        target: float | tuple[float, ...] | None = None
        tolerance = 1e-4
        getter: Callable[[int], float | tuple[float, ...] | None] | None = None

        target_area = _float_or_none(plan.get("target_area"))
        target_size = _float_or_none(plan.get("target_face_size"))
        target_center = _tuple_or_none(plan.get("target_face_center"))
        target_position = _float_or_none(plan.get("target_plane_position"))
        target_thickness = _float_or_none(plan.get("shell_target_thickness"))
        embedded_small_radius = _float_or_none(plan.get("embedded_cone_target_small_radius"))
        embedded_large_radius = _float_or_none(plan.get("embedded_cone_target_large_radius"))

        if target_area is not None and target_area > 0:
            metric = "area"
            target = target_area
            tolerance = max(abs(target_area) * 0.02, 1e-4)
            getter = lambda face_id: _float_or_none(self.quick_face_info(face_id).get("area"))
        elif target_size is not None and target_size > 0:
            axis_key = "height" if str(plan.get("face_size_axis") or "").lower() == "height" else "width"
            info_key = "local_face_height" if axis_key == "height" else "local_face_width"
            metric = info_key
            target = target_size
            tolerance = max(abs(target_size) * 0.02, 1e-4)
            getter = lambda face_id, key=info_key: _float_or_none(self.quick_face_info(face_id).get(key))
        elif target_center is not None:
            metric = "center"
            target = target_center
            reference = max(max(abs(item) for item in target_center), 1.0)
            tolerance = max(reference * 1e-5, 1e-4)

            def center_getter(face_id: int) -> tuple[float, float, float] | None:
                info = self.quick_face_info(face_id)
                return _tuple_or_none(info.get("area_center")) or _tuple_or_none(info.get("bbox_center"))

            getter = center_getter
        elif target_position is not None:
            direction = (
                _tuple_normalized(_tuple_or_none(plan.get("plane_direction")))
                or _tuple_normalized(_tuple_or_none(plan.get("outward_direction")))
            )
            if direction is None:
                return None
            metric = "plane_position"
            target = target_position
            bbox_diagonal = _float_or_none(plan.get("bbox_diagonal")) or _shape_diagonal(self.shape)
            tolerance = max(bbox_diagonal * 1e-4, abs(target_position) * 1e-5, 1e-4)

            def plane_position_getter(face_id: int) -> float | None:
                if face_id < 0 or face_id >= len(self.faces):
                    return None
                try:
                    surf = BRepAdaptor_Surface(self.faces[face_id])
                except Exception:
                    return None
                if surf.GetType() != GeomAbs_Plane:
                    return None
                origin = _point_tuple(surf.Plane().Location())
                return _tuple_dot(origin, direction)

            getter = plane_position_getter
        elif target_thickness is not None and target_thickness > 0:
            metric = "shell_thickness"
            target = target_thickness
            tolerance = max(abs(target_thickness) * 0.03, 1e-4)
            getter = lambda face_id: _float_or_none(self.feature_info(face_id).get("shell_thickness_estimate"))
        elif (
            embedded_small_radius is not None
            and embedded_small_radius > 0
            and embedded_large_radius is not None
            and embedded_large_radius > embedded_small_radius
        ):
            metric = "cone_boundary_radii"
            target = (embedded_small_radius, embedded_large_radius)
            tolerance = max(abs(embedded_large_radius) * 0.01, abs(embedded_small_radius) * 0.01, 1e-4)

            def cone_boundary_getter(face_id: int) -> tuple[float, float] | None:
                info = self.face_info(face_id)
                axis_point = _tuple_or_none(info.get("axis_point"))
                axis_direction = _tuple_normalized(_tuple_or_none(info.get("axis")))
                if axis_point is None or axis_direction is None:
                    return None
                circles = self._conical_face_circle_boundaries(face_id, axis_point, axis_direction)
                radii = sorted(float(circle["radius"]) for circle in circles)
                if len(radii) != 2:
                    return None
                return (radii[0], radii[1])

            getter = cone_boundary_getter
        else:
            resize_strategy = str(plan.get("resize_strategy") or "")
            surface = str(plan.get("surface") or "")
            if "semi-angle" in resize_strategy:
                numeric_specs = (
                    ("semi_angle_degrees", "target_semi_angle_degrees", 0.01, 0.05),
                    ("reference_radius", "target_reference_radius", 0.01, 1e-4),
                    ("radius", "target_radius", 0.01, 1e-4),
                )
            elif surface == "torus":
                if str(plan.get("torus_radius_mode") or "") == "major":
                    numeric_specs = (
                        ("major_radius", "target_major_radius", 0.01, 1e-4),
                        ("minor_radius", "target_minor_radius", 0.01, 1e-4),
                    )
                else:
                    numeric_specs = (
                        ("minor_radius", "target_minor_radius", 0.01, 1e-4),
                        ("major_radius", "target_major_radius", 0.01, 1e-4),
                    )
            else:
                numeric_specs = (
                    ("reference_radius", "target_reference_radius", 0.01, 1e-4),
                    ("major_radius", "target_major_radius", 0.01, 1e-4),
                    ("minor_radius", "target_minor_radius", 0.01, 1e-4),
                    ("radius", "target_radius", 0.01, 1e-4),
                    ("semi_angle_degrees", "target_semi_angle_degrees", 0.01, 0.05),
                )
            for info_key, target_key, ratio, floor in numeric_specs:
                value = _float_or_none(plan.get(target_key))
                if value is None or value <= 0:
                    continue
                metric = info_key
                target = value
                tolerance = max(abs(value) * ratio, floor)
                if info_key == "semi_angle_degrees":
                    getter = lambda face_id: _angle_degrees_or_none(self.quick_face_info(face_id).get("semi_angle"))
                else:
                    getter = lambda face_id, key=info_key: _float_or_none(self.quick_face_info(face_id).get(key))
                break

        if getter is None or target is None:
            return None

        preferred_ids = _int_values(plan.get("result_candidate_face_ids"))
        logical_id = _int_or_none(plan.get("target_logical_id"))
        if logical_id is not None:
            try:
                preferred_ids.extend(self.face_ids_for_logical_id(logical_id))
            except Exception:
                pass
        plan_face_id = _int_or_none(plan.get("face_id"))
        if plan_face_id is not None:
            preferred_ids.append(plan_face_id)
        if preferred_ids:
            preferred_best: dict[str, object] | None = None
            for face_id in preferred_ids:
                if face_id not in face_ids:
                    continue
                try:
                    actual = getter(face_id)
                except Exception:
                    actual = None
                if actual is None:
                    continue
                error = _result_value_error(actual, target)
                if preferred_best is None or error < float(preferred_best["error"]):
                    preferred_best = {
                        "face_id": face_id,
                        "metric": metric,
                        "actual": actual,
                        "target": target,
                        "error": error,
                        "tolerance": tolerance,
                        "scope": scope,
                    }
            if preferred_best is not None and float(preferred_best["error"]) <= tolerance:
                return preferred_best

        best: dict[str, object] | None = None
        for face_id in face_ids:
            try:
                actual = getter(face_id)
            except Exception:
                actual = None
            if actual is None:
                continue
            error = _result_value_error(actual, target)
            if best is None or error < float(best["error"]):
                best = {
                    "face_id": face_id,
                    "metric": metric,
                    "actual": actual,
                    "target": target,
                    "error": error,
                    "tolerance": tolerance,
                    "scope": scope,
                }
        if best is not None:
            return best
        return {
            "face_id": -1,
            "metric": metric,
            "actual": "",
            "target": target,
            "error": math.inf,
            "tolerance": tolerance,
            "scope": scope,
        }

    def _face_edit_result_candidate_ids(self, plan: dict[str, object]) -> tuple[list[int], str]:
        part_id = _int_or_none(plan.get("part_id"))
        solid_id = _int_or_none(plan.get("solid_id"))
        surface = str(plan.get("surface") or "")
        target_kind = str(
            plan.get("local_face_deform_target_kind")
            or plan.get("affine_target_kind")
            or plan.get("target_kind")
            or ("solid" if solid_id is not None and solid_id >= 0 else "part")
        )
        scope = f"part {part_id}" if part_id is not None else "model"
        if target_kind == "solid" and solid_id is not None and solid_id >= 0:
            scope = f"solid {solid_id}"

        primary: list[int] = []
        logical_id = _int_or_none(plan.get("target_logical_id"))
        if logical_id is not None:
            try:
                primary.extend(self.face_ids_for_logical_id(logical_id))
            except Exception:
                pass
        plan_face_id = _int_or_none(plan.get("face_id"))
        if plan_face_id is not None:
            primary.append(plan_face_id)
        primary.extend(_int_values(plan.get("result_candidate_face_ids")))

        def filtered(source_ids: Iterable[int], *, require_solid: bool = True) -> list[int]:
            result: list[int] = []
            for candidate_id in source_ids:
                try:
                    face_id = int(candidate_id)
                except (TypeError, ValueError):
                    continue
                if not (0 <= face_id < len(self.faces)):
                    continue
                if part_id is not None and int(self.face_part_ids[face_id]) != part_id:
                    continue
                if (
                    require_solid
                    and solid_id is not None
                    and solid_id >= 0
                    and int(self.face_solid_ids[face_id]) != solid_id
                ):
                    continue
                if surface in {"plane", "cylinder", "cone", "sphere", "torus"}:
                    try:
                        if self.face_surface_kind(face_id) != surface:
                            continue
                    except Exception:
                        continue
                if face_id not in result:
                    result.append(face_id)
            return result

        primary_ids = filtered(primary)
        result_candidate_ids = filtered(_int_values(plan.get("result_candidate_face_ids")))
        if result_candidate_ids:
            combined: list[int] = []
            for face_id in [*result_candidate_ids, *primary_ids]:
                if face_id not in combined:
                    combined.append(face_id)
            return combined, scope
        all_ids = filtered(range(len(self.faces)))
        if not all_ids and solid_id is not None and solid_id >= 0:
            all_ids = filtered(range(len(self.faces)), require_solid=False)
        combined: list[int] = []
        for face_id in [*primary_ids, *all_ids]:
            if face_id not in combined:
                combined.append(face_id)
        return combined, scope

    def _edge_length_result_summary(self, plan: dict[str, object]) -> str:
        check = self._edge_length_result_check(plan)
        if check is None:
            return "Result check unavailable."
        return (
            "Result check: "
            f"match={check['match_method']}, "
            f"nearest_edge={check['edge_id']}, "
            f"nearest_length={float(check['nearest_length']):g}, "
            f"target_error={float(check['target_error']):g}, "
            f"relative_error={float(check['relative_error']):g}, "
            f"endpoint_error={float(check['endpoint_error']):g}, "
            f"scope={check['scope']}."
        )

    def _edge_length_result_summary_or_raise(self, plan: dict[str, object]) -> str:
        check = self._edge_length_result_check(plan)
        if check is None:
            raise RuntimeError("Edge长度编辑结果无法校验，模型已恢复到修改前状态。")
        target_length = float(plan.get("target_length", 0.0) or 0.0)
        length_tolerance = max(_shape_diagonal(self.shape) * 1e-5, target_length * 1e-4, 1e-5)
        if float(check.get("target_error", 0.0) or 0.0) > length_tolerance:
            raise RuntimeError(
                "Edge长度编辑结果没有达到目标值，模型已恢复到修改前状态。"
                f"最近Edge {check.get('edge_id')} 的长度约 {float(check.get('nearest_length', 0.0) or 0.0):g}，"
                f"目标长度 {target_length:g}，误差 {float(check.get('target_error', 0.0) or 0.0):g}。"
            )

        expected = self._edge_length_expected_endpoints(plan)
        endpoint_error = float(check.get("endpoint_error", -1.0) or -1.0)
        if expected is not None and endpoint_error >= 0.0:
            endpoint_tolerance = max(_shape_diagonal(self.shape) * 1e-4, target_length * 1e-3, 1e-4)
            if endpoint_error > endpoint_tolerance:
                raise RuntimeError(
                    "Edge长度编辑后的目标端点位置不符合所选建模意图，模型已恢复到修改前状态。"
                    f"最近Edge {check.get('edge_id')} 的端点误差约 {endpoint_error:g}，"
                    f"允许误差 {endpoint_tolerance:g}。"
                )

        return (
            "Result check: "
            f"match={check['match_method']}, "
            f"nearest_edge={check['edge_id']}, "
            f"nearest_length={float(check['nearest_length']):g}, "
            f"target_error={float(check['target_error']):g}, "
            f"relative_error={float(check['relative_error']):g}, "
            f"endpoint_error={float(check['endpoint_error']):g}, "
            f"scope={check['scope']}."
        )

    def _edge_length_result_check(self, plan: dict[str, object]) -> dict[str, object] | None:
        try:
            target_length = float(plan.get("target_length", 0.0))
        except (TypeError, ValueError):
            return None
        if target_length <= 1e-9 or not self.edges:
            return None

        try:
            part_id = int(plan.get("part_id", -1))
        except (TypeError, ValueError):
            part_id = -1
        try:
            solid_id = int(plan.get("solid_id", -1))
        except (TypeError, ValueError):
            solid_id = -1

        target_kind = str(
            plan.get("local_edge_deform_target_kind")
            or plan.get("affine_target_kind")
            or ("solid" if solid_id >= 0 else "part")
        )
        edge_ids = [edge_id for edge_id in range(len(self.edges)) if part_id < 0 or self.edge_part_ids[edge_id] == part_id]
        scope = f"零件 {part_id}" if part_id >= 0 else "model"
        if target_kind == "solid" and solid_id >= 0:
            solid_edge_ids = [edge_id for edge_id in edge_ids if self.edge_solid_ids[edge_id] == solid_id]
            if solid_edge_ids:
                edge_ids = solid_edge_ids
                scope = f"solid {solid_id}"
        if not edge_ids:
            edge_ids = list(range(len(self.edges)))
            scope = "model"

        expected = self._edge_length_expected_endpoints(plan)
        best_length: tuple[float, int, float, float | None] | None = None
        best_endpoint: tuple[float, float, int, float] | None = None
        for edge_id in edge_ids:
            try:
                length = float(self.edge_info(edge_id).get("length", 0.0))
            except Exception:
                continue
            if length <= 1e-9:
                continue
            error = abs(length - target_length)
            endpoint_error = None
            if expected is not None:
                endpoint_error = self._edge_endpoint_pair_error(edge_id, expected[0], expected[1])
                if endpoint_error is not None and (
                    best_endpoint is None
                    or endpoint_error < best_endpoint[0]
                    or (
                        abs(endpoint_error - best_endpoint[0]) <= 1e-9
                        and (error < best_endpoint[1] or (abs(error - best_endpoint[1]) <= 1e-9 and edge_id < best_endpoint[2]))
                    )
                ):
                    best_endpoint = (endpoint_error, error, edge_id, length)
            if best_length is None or error < best_length[0] or (
                abs(error - best_length[0]) <= 1e-9 and edge_id < best_length[1]
            ):
                best_length = (error, edge_id, length, endpoint_error)

        if best_length is None:
            return None
        match_method = "length"
        endpoint_error_value = best_length[3]
        error, edge_id, length = best_length[0], best_length[1], best_length[2]
        if expected is not None and best_endpoint is not None:
            endpoint_tolerance = max(_shape_diagonal(self.shape) * 1e-4, target_length * 1e-3, 1e-4)
            if best_endpoint[0] <= endpoint_tolerance:
                endpoint_error_value, error, edge_id, length = best_endpoint
                match_method = str(expected[2])
        return {
            "edge_id": edge_id,
            "nearest_length": length,
            "target_error": error,
            "relative_error": error / max(target_length, 1e-9),
            "endpoint_error": endpoint_error_value if endpoint_error_value is not None else -1.0,
            "match_method": match_method,
            "scope": scope,
        }

    def _edge_length_expected_endpoints(
        self,
        plan: dict[str, object],
    ) -> tuple[tuple[float, float, float], tuple[float, float, float], str] | None:
        start = _tuple_or_none(plan.get("start_point"))
        end = _tuple_or_none(plan.get("end_point"))
        if start is None or end is None:
            return None
        strategy = str(plan.get("resize_strategy", ""))
        if strategy in {"local-edge-only-deform", "local-edge-endpoint-deform", "local-edge-center-deform"}:
            start_move = _tuple_or_none(plan.get("local_edge_deform_start_move")) or (0.0, 0.0, 0.0)
            end_move = _tuple_or_none(plan.get("local_edge_deform_end_move")) or (0.0, 0.0, 0.0)
            if strategy == "local-edge-endpoint-deform":
                match_label = "endpoint-local-coordinate"
            elif strategy == "local-edge-center-deform":
                match_label = "endpoint-local-center"
            else:
                match_label = "endpoint-local"
            return (
                (start[0] + start_move[0], start[1] + start_move[1], start[2] + start_move[2]),
                (end[0] + end_move[0], end[1] + end_move[1], end[2] + end_move[2]),
                match_label,
            )
        if strategy == "move-edge-end-plane-by-push-pull":
            movement = _tuple_or_none(plan.get("desired_movement_vector"))
            endpoint_role = str(plan.get("end_face_endpoint_role", ""))
            if movement is None or endpoint_role not in {"start", "end"}:
                return None
            if endpoint_role == "start":
                start = (start[0] + movement[0], start[1] + movement[1], start[2] + movement[2])
            else:
                end = (end[0] + movement[0], end[1] + movement[1], end[2] + movement[2])
            return start, end, "endpoint-push-pull"
        if strategy == "scale-owning-shape-from-edge":
            transformed_start = self._edge_length_affine_point(start, plan)
            transformed_end = self._edge_length_affine_point(end, plan)
            if transformed_start is None or transformed_end is None:
                return None
            return transformed_start, transformed_end, "endpoint-affine"
        return None

    def _edge_endpoint_pair_error(
        self,
        edge_id: int,
        expected_start: tuple[float, float, float],
        expected_end: tuple[float, float, float],
    ) -> float | None:
        info = self.edge_info(edge_id)
        start = _tuple_or_none(info.get("start_point"))
        end = _tuple_or_none(info.get("end_point"))
        if start is None or end is None:
            return None
        direct = max(_vector_length(_tuple_sub(start, expected_start)), _vector_length(_tuple_sub(end, expected_end)))
        reversed_order = max(
            _vector_length(_tuple_sub(start, expected_end)),
            _vector_length(_tuple_sub(end, expected_start)),
        )
        return min(direct, reversed_order)

    def _edge_length_affine_point(
        self,
        point: tuple[float, float, float],
        plan: dict[str, object],
    ) -> tuple[float, float, float] | None:
        axis_point = _tuple_or_none(plan.get("affine_axis_point"))
        if axis_point is None:
            return None
        try:
            scale = float(plan.get("affine_scale", 1.0))
        except (TypeError, ValueError):
            return None
        relative = _tuple_sub(point, axis_point)
        transform_kind = str(plan.get("affine_transform_kind", "axis-affine"))
        if transform_kind == "uniform":
            moved = _tuple_scale(relative, scale)
        else:
            axis_direction = _tuple_normalized(_tuple_or_none(plan.get("affine_axis_direction")))
            if axis_direction is None:
                return None
            axial = _tuple_scale(axis_direction, _tuple_dot(relative, axis_direction))
            radial = _tuple_sub(relative, axial)
            if transform_kind == "radial-affine":
                moved = (
                    axial[0] + radial[0] * scale,
                    axial[1] + radial[1] * scale,
                    axial[2] + radial[2] * scale,
                )
            else:
                moved = (
                    radial[0] + axial[0] * scale,
                    radial[1] + axial[1] * scale,
                    radial[2] + axial[2] * scale,
                )
        return (axis_point[0] + moved[0], axis_point[1] + moved[1], axis_point[2] + moved[2])

    def _local_edge_deform_shape(self, plan: dict[str, object]) -> TopoDS_Shape:
        _target_kind, solid, _part, _source_solid = self._local_edge_deform_target(plan)
        tolerance = max(_shape_diagonal(solid) * 1e-7, abs(float(plan.get("delta_length", 0.0))) * 1e-7, 1e-6)
        faces = _explore(solid, TopAbs_FACE)
        moved_faces: list[TopoDS_Shape] = []
        moved_points: dict[tuple[int, int, int], tuple[float, float, float]] = {}
        for face in faces:
            points = self._local_deform_face_vertex_points(face, tolerance)
            if len(points) < 3:
                raise RuntimeError("Local edge deformation could not read a stable face vertex loop.")
            for point in points:
                moved = self._local_edge_deform_moved_point(point, plan, tolerance)
                moved_points[self._local_point_key(moved, tolerance)] = moved

        if not moved_points:
            raise RuntimeError("Local edge deformation produced no moved vertices.")
        center = (
            sum(point[0] for point in moved_points.values()) / len(moved_points),
            sum(point[1] for point in moved_points.values()) / len(moved_points),
            sum(point[2] for point in moved_points.values()) / len(moved_points),
        )

        for face in faces:
            points = [
                self._local_edge_deform_moved_point(point, plan, tolerance)
                for point in self._local_deform_face_vertex_points(face, tolerance)
            ]
            points = self._dedupe_local_points(points, tolerance)
            if len(points) < 3:
                raise RuntimeError("Local edge deformation collapsed a face.")
            points = self._orient_local_polygon_outward(points, center)
            if self._local_points_are_planar(points, tolerance):
                moved_faces.append(self._make_local_polygon_face(points))
            elif len(points) == 4:
                moved_faces.append(self._make_local_bilinear_quad_face(points, tolerance))
            else:
                for index in range(1, len(points) - 1):
                    triangle = [points[0], points[index], points[index + 1]]
                    triangle = self._orient_local_polygon_outward(triangle, center)
                    moved_faces.append(self._make_local_polygon_face(triangle))

        sewing = BRepBuilderAPI_Sewing(tolerance)
        for face in moved_faces:
            sewing.Add(face)
        sewing.Perform()
        sewed = sewing.SewedShape()
        if sewed.IsNull():
            raise RuntimeError("Local edge deformation sewing produced an empty shape.")
        if sewed.ShapeType() == TopAbs_SHELL:
            shell = topods.Shell(sewed)
        else:
            shells = _explore(sewed, TopAbs_SHELL)
            if not shells:
                raise RuntimeError("Local edge deformation did not produce a sewable shell.")
            shell = topods.Shell(shells[0])
        solid_builder = BRepBuilderAPI_MakeSolid(shell)
        solid = solid_builder.Solid()
        if solid.IsNull():
            raise RuntimeError("Local edge deformation could not create a solid from the rebuilt shell.")
        return _ensure_valid_or_repaired_shape(solid, "local edge deformation")

    def _apply_local_edge_deform(self, plan: dict[str, object]) -> None:
        target_kind, _source_shape, part, source_solid = self._local_edge_deform_target(plan)
        transformed = self._local_edge_deform_shape(plan)
        if target_kind == "part":
            part.shape = transformed
        else:
            part_solids = _explore(part.shape, TopAbs_SOLID)
            replaced = False
            shapes: list[TopoDS_Shape] = []
            for item in part_solids:
                if not replaced and source_solid is not None and _same_shape(item, source_solid):
                    shapes.append(transformed)
                    replaced = True
                else:
                    shapes.append(item)
            if not replaced:
                raise RuntimeError(f"Could not locate solid {plan.get('solid_id')} inside part {plan.get('part_id')}.")
            part.shape = _compound_from_shapes(shapes)
            _ensure_valid_shape(part.shape)
        self.refresh_topology()

    def _local_face_deform_shape(self, plan: dict[str, object]) -> TopoDS_Shape:
        _target_kind, solid, _part, _source_solid = self._local_face_deform_target(plan)
        move_distance = _float_or_none(plan.get("local_face_deform_distance_hint"))
        if move_distance is None:
            move_distance = _float_or_none(plan.get("face_center_move_distance"))
        if move_distance is None:
            move_distance = 0.0
        tolerance = max(_shape_diagonal(solid) * 1e-7, abs(move_distance) * 1e-7, 1e-6)
        faces = _explore(solid, TopAbs_FACE)
        moved_faces: list[TopoDS_Shape] = []
        moved_points: dict[tuple[int, int, int], tuple[float, float, float]] = {}
        moved_count = 0
        for face in faces:
            points = self._local_deform_face_vertex_points(face, tolerance)
            if len(points) < 3:
                raise RuntimeError("Local face deformation could not read a stable face vertex loop.")
            for point in points:
                moved = self._local_face_deform_moved_point(point, plan, tolerance)
                if _vector_length(_tuple_sub(moved, point)) > tolerance:
                    moved_count += 1
                moved_points[self._local_point_key(moved, tolerance)] = moved

        if not moved_points or moved_count == 0:
            raise RuntimeError("Local face deformation produced no moved vertices.")
        center = (
            sum(point[0] for point in moved_points.values()) / len(moved_points),
            sum(point[1] for point in moved_points.values()) / len(moved_points),
            sum(point[2] for point in moved_points.values()) / len(moved_points),
        )

        for face in faces:
            points = [
                self._local_face_deform_moved_point(point, plan, tolerance)
                for point in self._local_deform_face_vertex_points(face, tolerance)
            ]
            points = self._dedupe_local_points(points, tolerance)
            if len(points) < 3:
                raise RuntimeError("Local face deformation collapsed a face.")
            points = self._orient_local_polygon_outward(points, center)
            if self._local_points_are_planar(points, tolerance):
                moved_faces.append(self._make_local_polygon_face(points))
            else:
                for index in range(1, len(points) - 1):
                    triangle = [points[0], points[index], points[index + 1]]
                    triangle = self._orient_local_polygon_outward(triangle, center)
                    moved_faces.append(self._make_local_polygon_face(triangle))

        sewing = BRepBuilderAPI_Sewing(tolerance)
        for face in moved_faces:
            sewing.Add(face)
        sewing.Perform()
        sewed = sewing.SewedShape()
        if sewed.IsNull():
            raise RuntimeError("Local face deformation sewing produced an empty shape.")
        if sewed.ShapeType() == TopAbs_SHELL:
            shell = topods.Shell(sewed)
        else:
            shells = _explore(sewed, TopAbs_SHELL)
            if not shells:
                raise RuntimeError("Local face deformation did not produce a sewable shell.")
            shell = topods.Shell(shells[0])
        solid_builder = BRepBuilderAPI_MakeSolid(shell)
        solid_shape = solid_builder.Solid()
        if solid_shape.IsNull():
            raise RuntimeError("Local face deformation could not create a solid from the rebuilt shell.")
        return _ensure_valid_or_repaired_shape(solid_shape, "local face deformation")

    def _apply_local_face_deform(self, plan: dict[str, object]) -> None:
        target_kind, source_shape, part, source_solid = self._local_face_deform_target(plan)
        target_face_id = int(plan.get("face_id", -1))
        target_part_id = int(plan.get("part_id", -1))
        target_logical_id: int | None = None
        target_points: tuple[tuple[float, float, float], ...] = ()
        move_distance = _float_or_none(plan.get("local_face_deform_distance_hint"))
        if move_distance is None:
            move_distance = _float_or_none(plan.get("face_center_move_distance"))
        if move_distance is None:
            move_distance = 0.0
        mapping_tolerance = max(_shape_diagonal(source_shape) * 1e-7, abs(move_distance) * 1e-7, 1e-6)
        if 0 <= target_face_id < len(self.faces):
            try:
                target_logical_id = self.face_region_logical_id(target_face_id)
                target_points = self._local_face_deform_target_points_for_face(
                    target_face_id,
                    plan,
                    mapping_tolerance,
                )
            except Exception:
                target_logical_id = None
                target_points = ()
        transformed = self._local_face_deform_shape(plan)
        if target_kind == "part":
            part.shape = transformed
        else:
            part_solids = _explore(part.shape, TopAbs_SOLID)
            replaced = False
            shapes: list[TopoDS_Shape] = []
            for item in part_solids:
                if not replaced and source_solid is not None and _same_shape(item, source_solid):
                    shapes.append(transformed)
                    replaced = True
                else:
                    shapes.append(item)
            if not replaced:
                raise RuntimeError(f"Could not locate solid {plan.get('solid_id')} inside part {plan.get('part_id')}.")
            part.shape = _compound_from_shapes(shapes)
            _ensure_valid_shape(part.shape)
        self.refresh_topology()
        if target_logical_id is not None and target_points:
            self._assign_logical_id_to_matching_face_points(
                target_logical_id,
                target_points,
                target_part_id,
                mapping_tolerance,
            )

    def _local_face_deform_target_points_for_face(
        self,
        face_id: int,
        plan: dict[str, object],
        tolerance: float,
    ) -> tuple[tuple[float, float, float], ...]:
        points = self._local_deform_face_vertex_points(self.faces[face_id], tolerance)
        return tuple(self._local_face_deform_moved_point(point, plan, tolerance) for point in points)

    def _assign_logical_id_to_matching_face_points(
        self,
        logical_id: int,
        target_points: Iterable[tuple[float, float, float]],
        part_id: int,
        tolerance: float,
    ) -> None:
        target = self._dedupe_local_points([tuple(point) for point in target_points], tolerance)
        if len(target) < 3:
            return
        max_error = max(tolerance * 500.0, _shape_diagonal(self.shape) * 1e-6, 1e-4)
        best_face_id: int | None = None
        best_error = math.inf
        for face_id, face in enumerate(self.faces):
            if part_id >= 0 and self.face_part_ids[face_id] != part_id:
                continue
            try:
                points = self._dedupe_local_points(self._local_deform_face_vertex_points(face, tolerance), tolerance)
            except Exception:
                continue
            if len(points) < 3:
                continue
            error = self._local_point_cloud_error(target, points)
            error += abs(len(points) - len(target)) * max_error * 0.25
            if error < best_error:
                best_error = error
                best_face_id = face_id
        if best_face_id is None or best_error > max_error:
            return
        region_ids = self.connected_same_domain_face_ids(best_face_id) or [best_face_id]
        self.assign_logical_face_region_exclusive(int(logical_id), region_ids)

    def _local_point_cloud_error(
        self,
        left: list[tuple[float, float, float]],
        right: list[tuple[float, float, float]],
    ) -> float:
        if not left or not right:
            return math.inf

        def one_way(source: list[tuple[float, float, float]], target: list[tuple[float, float, float]]) -> float:
            return max(min(_vector_length(_tuple_sub(item, other)) for other in target) for item in source)

        return max(one_way(left, right), one_way(right, left))

    def _translated_face_region_mapping_specs(
        self,
        specs: Iterable[dict[str, object]],
        vector: tuple[float, float, float],
        *,
        logical_id: int | None = None,
    ) -> list[dict[str, object]]:
        shifted_specs: list[dict[str, object]] = []
        for spec in specs:
            shifted = dict(spec)
            if str(shifted.get("surface", "")) == "plane":
                point = _tuple_or_none(shifted.get("point"))
                if point is not None:
                    shifted["point"] = _tuple_add(point, vector)
            if logical_id is not None:
                shifted["logical_id"] = int(logical_id)
            shifted_specs.append(shifted)
        return shifted_specs

    def _apply_face_region_mapping_specs_exclusive(
        self,
        logical_id: int | None,
        specs: Iterable[dict[str, object]],
    ) -> None:
        if logical_id is None:
            return
        region_ids: set[int] = set()
        for spec in specs:
            try:
                seed_face_ids = self._matching_face_ids_for_region_spec(spec)
            except Exception:
                seed_face_ids = []
            for seed_face_id in seed_face_ids:
                region_ids.update(self.connected_same_domain_face_ids(seed_face_id) or [seed_face_id])
        if region_ids:
            self.assign_logical_face_region_exclusive(int(logical_id), region_ids)

    def _apply_preserved_face_logical_ids_by_shape_identity(
        self,
        previous_faces: Iterable[TopoDS_Shape],
        previous_logical_ids: Iterable[int],
        *,
        excluded_logical_ids: Iterable[int | None] = (),
    ) -> int:
        excluded = {int(item) for item in excluded_logical_ids if item is not None}
        old_faces = list(previous_faces)
        old_logical_ids = [int(item) for item in previous_logical_ids]
        if not old_faces or len(old_faces) != len(old_logical_ids):
            return 0

        unmatched_new_ids: set[int] = set(range(len(self.faces)))
        pending: list[tuple[TopoDS_Shape, int]] = []
        matched_by_logical_id: dict[int, set[int]] = {}

        for old_face_id, old_face in enumerate(old_faces):
            logical_id = old_logical_ids[old_face_id]
            if logical_id in excluded:
                continue
            if (
                old_face_id < len(self.faces)
                and old_face_id in unmatched_new_ids
                and _same_shape(old_face, self.faces[old_face_id])
            ):
                matched_by_logical_id.setdefault(logical_id, set()).add(old_face_id)
                unmatched_new_ids.remove(old_face_id)
            else:
                pending.append((old_face, logical_id))

        for old_face, logical_id in pending:
            if logical_id in excluded:
                continue
            match_id: int | None = None
            for new_face_id in tuple(unmatched_new_ids):
                if _same_shape(old_face, self.faces[new_face_id]):
                    match_id = new_face_id
                    break
            if match_id is None:
                continue
            matched_by_logical_id.setdefault(logical_id, set()).add(match_id)
            unmatched_new_ids.remove(match_id)

        reassigned = 0
        assigned_face_ids: set[int] = set()
        logical_targets: dict[int, set[int]] = {}
        for logical_id, face_ids in sorted(matched_by_logical_id.items()):
            valid_face_ids = set(face_ids) - assigned_face_ids
            if not valid_face_ids:
                continue
            logical_targets[int(logical_id)] = valid_face_ids
            assigned_face_ids.update(valid_face_ids)
            reassigned += len(valid_face_ids)
        if not logical_targets:
            return 0

        new_logical_ids = list(self.face_logical_ids)
        replacement_id = max(
            [len(self.faces), *[int(item) for item in new_logical_ids], *logical_targets.keys()],
            default=len(self.faces),
        ) + 1
        for face_id, logical_id in enumerate(list(new_logical_ids)):
            target_face_ids = logical_targets.get(int(logical_id))
            if target_face_ids is None or face_id in target_face_ids:
                continue
            new_logical_ids[face_id] = replacement_id
            replacement_id += 1
        for logical_id, face_ids in logical_targets.items():
            for face_id in face_ids:
                if 0 <= face_id < len(new_logical_ids):
                    new_logical_ids[face_id] = logical_id
        self.face_logical_ids = new_logical_ids
        self._quick_face_info_cache.clear()
        self._face_info_cache.clear()
        self._feature_info_cache.clear()
        self._same_domain_face_ids_cache.clear()
        self._face_first_level_topology_cache.clear()
        self._cylindrical_first_level_topology_cache.clear()
        self._face_first_level_fact_cache.clear()
        self._local_face_deform_readiness_cache.clear()
        return reassigned

    def _local_face_deform_target(
        self,
        plan: dict[str, object],
    ) -> tuple[str, TopoDS_Shape, object, TopoDS_Shape | None]:
        part_id = int(plan.get("part_id", -1))
        solid_id = int(plan.get("solid_id", -1))
        part = self.part_by_id(part_id)
        if part is None:
            raise ValueError(f"Unknown part id {part_id}")
        if solid_id < 0 or solid_id >= len(self.solids):
            raise ValueError(f"Unknown solid id {solid_id}")
        target_kind = str(plan.get("local_face_deform_target_kind", "part"))
        solid = self.solids[solid_id][1]
        return ("solid" if target_kind == "solid" else "part"), solid, part, solid

    def _local_edge_deform_target(
        self,
        plan: dict[str, object],
    ) -> tuple[str, TopoDS_Shape, object, TopoDS_Shape | None]:
        part_id = int(plan.get("part_id", -1))
        solid_id = int(plan.get("solid_id", -1))
        part = self.part_by_id(part_id)
        if part is None:
            raise ValueError(f"Unknown part id {part_id}")
        if solid_id < 0 or solid_id >= len(self.solids):
            raise ValueError(f"Unknown solid id {solid_id}")
        target_kind = str(plan.get("local_edge_deform_target_kind", "part"))
        solid = self.solids[solid_id][1]
        return ("solid" if target_kind == "solid" else "part"), solid, part, solid

    def _local_deform_face_vertex_points(
        self,
        face: TopoDS_Shape,
        tolerance: float,
    ) -> list[tuple[float, float, float]]:
        points: list[tuple[float, float, float]] = []
        explorer = TopExp_Explorer(face, TopAbs_VERTEX)
        while explorer.More():
            vertex = topods.Vertex(explorer.Current())
            point = _point_tuple(BRep_Tool.Pnt(vertex))
            if not any(_vector_length(_tuple_sub(point, existing)) <= tolerance for existing in points):
                points.append(point)
            explorer.Next()
        if len(points) < 3:
            return points
        surf = BRepAdaptor_Surface(face)
        normal = _tuple_normalized(_dir_tuple(surf.Plane().Axis().Direction()))
        if normal is None:
            return points
        if face.Orientation() == TopAbs_REVERSED:
            normal = _tuple_scale(normal, -1.0)
        return self._order_local_polygon_points(points, normal)

    def _order_local_polygon_points(
        self,
        points: list[tuple[float, float, float]],
        normal: tuple[float, float, float],
    ) -> list[tuple[float, float, float]]:
        center = (
            sum(point[0] for point in points) / len(points),
            sum(point[1] for point in points) / len(points),
            sum(point[2] for point in points) / len(points),
        )
        reference = (1.0, 0.0, 0.0) if abs(normal[0]) < 0.9 else (0.0, 1.0, 0.0)
        u_axis = _tuple_normalized(_tuple_cross(normal, reference))
        if u_axis is None:
            return points
        v_axis = _tuple_normalized(_tuple_cross(normal, u_axis))
        if v_axis is None:
            return points
        ordered = sorted(
            points,
            key=lambda point: math.atan2(
                _tuple_dot(_tuple_sub(point, center), v_axis),
                _tuple_dot(_tuple_sub(point, center), u_axis),
            ),
        )
        polygon_normal = self._local_polygon_normal(ordered)
        if polygon_normal is not None and _tuple_dot(polygon_normal, normal) < 0:
            ordered.reverse()
        return ordered

    def _local_edge_deform_moved_point(
        self,
        point: tuple[float, float, float],
        plan: dict[str, object],
        tolerance: float,
    ) -> tuple[float, float, float]:
        start = _tuple_or_none(plan.get("start_point"))
        end = _tuple_or_none(plan.get("end_point"))
        start_move = _tuple_or_none(plan.get("local_edge_deform_start_move")) or (0.0, 0.0, 0.0)
        end_move = _tuple_or_none(plan.get("local_edge_deform_end_move")) or (0.0, 0.0, 0.0)
        if start is not None and _vector_length(_tuple_sub(point, start)) <= tolerance:
            return (point[0] + start_move[0], point[1] + start_move[1], point[2] + start_move[2])
        if end is not None and _vector_length(_tuple_sub(point, end)) <= tolerance:
            return (point[0] + end_move[0], point[1] + end_move[1], point[2] + end_move[2])
        return point

    def _local_face_deform_moved_point(
        self,
        point: tuple[float, float, float],
        plan: dict[str, object],
        tolerance: float,
    ) -> tuple[float, float, float]:
        point_targets = plan.get("local_face_deform_source_point_targets")
        if isinstance(point_targets, (list, tuple)):
            for item in point_targets:
                if not isinstance(item, (list, tuple)) or len(item) < 2:
                    continue
                source = _tuple_or_none(item[0])
                target = _tuple_or_none(item[1])
                if source is not None and target is not None and _vector_length(_tuple_sub(point, source)) <= tolerance:
                    return target
        source_points = tuple(_tuple_or_none(item) for item in plan.get("local_face_deform_source_points", ()))
        move = _tuple_or_none(plan.get("face_center_move_vector")) or (0.0, 0.0, 0.0)
        for source in source_points:
            if source is not None and _vector_length(_tuple_sub(point, source)) <= tolerance:
                return (point[0] + move[0], point[1] + move[1], point[2] + move[2])
        return point

    def _make_local_polygon_face(self, points: list[tuple[float, float, float]]) -> TopoDS_Shape:
        polygon = BRepBuilderAPI_MakePolygon()
        for point in points:
            polygon.Add(gp_Pnt(*point))
        polygon.Close()
        if hasattr(polygon, "IsDone") and not polygon.IsDone():
            raise RuntimeError("Local edge deformation could not create a polygon wire.")
        maker = BRepBuilderAPI_MakeFace(polygon.Wire())
        if hasattr(maker, "IsDone") and not maker.IsDone():
            raise RuntimeError("Local edge deformation could not create a face from a polygon wire.")
        face = maker.Face()
        if face.IsNull():
            raise RuntimeError("Local edge deformation created an empty face.")
        return face

    def _make_local_bilinear_quad_face(
        self,
        points: list[tuple[float, float, float]],
        tolerance: float,
    ) -> TopoDS_Shape:
        if len(points) != 4:
            raise RuntimeError("Local edge deformation bilinear face needs exactly four points.")
        grid = TColgp_Array2OfPnt(1, 2, 1, 2)
        grid.SetValue(1, 1, gp_Pnt(*points[0]))
        grid.SetValue(2, 1, gp_Pnt(*points[1]))
        grid.SetValue(1, 2, gp_Pnt(*points[3]))
        grid.SetValue(2, 2, gp_Pnt(*points[2]))
        surface = GeomAPI_PointsToBSplineSurface(grid).Surface()
        maker = BRepBuilderAPI_MakeFace(surface, max(float(tolerance), 1e-7))
        if hasattr(maker, "IsDone") and not maker.IsDone():
            raise RuntimeError("Local edge deformation could not create a bilinear quad face.")
        face = maker.Face()
        if face.IsNull():
            raise RuntimeError("Local edge deformation created an empty bilinear quad face.")
        return face

    def _dedupe_local_points(
        self,
        points: list[tuple[float, float, float]],
        tolerance: float,
    ) -> list[tuple[float, float, float]]:
        result: list[tuple[float, float, float]] = []
        for point in points:
            if not any(_vector_length(_tuple_sub(point, existing)) <= tolerance for existing in result):
                result.append(point)
        if len(result) > 1 and _vector_length(_tuple_sub(result[0], result[-1])) <= tolerance:
            result.pop()
        return result

    def _local_points_are_planar(
        self,
        points: list[tuple[float, float, float]],
        tolerance: float,
    ) -> bool:
        if len(points) <= 3:
            return True
        normal = self._local_polygon_normal(points)
        if normal is None:
            return False
        origin = points[0]
        return all(abs(_tuple_dot(_tuple_sub(point, origin), normal)) <= tolerance * 20.0 for point in points[3:])

    def _local_polygon_normal(
        self,
        points: list[tuple[float, float, float]],
    ) -> tuple[float, float, float] | None:
        normal = (0.0, 0.0, 0.0)
        count = len(points)
        for index, point in enumerate(points):
            next_point = points[(index + 1) % count]
            normal = (
                normal[0] + (point[1] - next_point[1]) * (point[2] + next_point[2]),
                normal[1] + (point[2] - next_point[2]) * (point[0] + next_point[0]),
                normal[2] + (point[0] - next_point[0]) * (point[1] + next_point[1]),
            )
        return _tuple_normalized(normal)

    def _orient_local_polygon_outward(
        self,
        points: list[tuple[float, float, float]],
        shape_center: tuple[float, float, float],
    ) -> list[tuple[float, float, float]]:
        normal = self._local_polygon_normal(points)
        if normal is None:
            return points
        center = (
            sum(point[0] for point in points) / len(points),
            sum(point[1] for point in points) / len(points),
            sum(point[2] for point in points) / len(points),
        )
        if _tuple_dot(normal, _tuple_sub(center, shape_center)) < 0:
            return list(reversed(points))
        return points

    def _local_point_key(self, point: tuple[float, float, float], tolerance: float) -> tuple[int, int, int]:
        scale = max(float(tolerance), 1e-9)
        return (round(point[0] / scale), round(point[1] / scale), round(point[2] / scale))

    def _edge_length_affine_preview_shape(self, plan: dict[str, object]) -> TopoDS_Shape:
        target_kind, source_shape, _part, _solid = self._edge_length_affine_target(plan)
        return self._affine_scaled_shape_along_edge(source_shape, plan)

    def _refine_affine_edge_length_scale(self, plan: dict[str, object]) -> str:
        edge_id = int(plan.get("edge_id", -1))
        if edge_id < 0 or edge_id >= len(self.edges):
            return ""
        target_length = float(plan.get("target_length", 0.0))
        if target_length <= 1e-9:
            return ""
        initial_scale = float(plan.get("affine_scale", 1.0))
        plan["affine_initial_scale"] = initial_scale
        refined_scale = initial_scale
        measured_length = 0.0
        iterations = 0
        tolerance = max(target_length * 5e-4, 1e-5)
        for _index in range(3):
            iterations += 1
            plan["affine_scale"] = refined_scale
            try:
                transformed_edge = self._affine_scaled_shape_along_edge(self.edges[edge_id], plan)
                props = GProp_GProps()
                brepgprop.LinearProperties(transformed_edge, props)
                measured_length = float(props.Mass())
            except Exception:
                plan["affine_scale"] = initial_scale
                return "几何缩放比例预校正失败，将使用原始目标比例。"
            if measured_length <= 1e-9:
                plan["affine_scale"] = initial_scale
                return "几何缩放比例预校正失败：预估Edge长度无效。"
            if abs(measured_length - target_length) <= tolerance:
                break
            refined_scale *= target_length / measured_length

        plan["affine_scale"] = refined_scale
        try:
            transformed_edge = self._affine_scaled_shape_along_edge(self.edges[edge_id], plan)
            props = GProp_GProps()
            brepgprop.LinearProperties(transformed_edge, props)
            final_measured_length = float(props.Mass())
            if final_measured_length > 1e-9:
                measured_length = final_measured_length
        except Exception:
            pass
        plan["affine_predicted_edge_length"] = measured_length
        plan["affine_scale_correction"] = refined_scale / initial_scale if abs(initial_scale) > 1e-12 else 1.0
        plan["affine_scale_refine_iterations"] = iterations
        if abs(refined_scale - initial_scale) > max(abs(initial_scale) * 1e-4, 1e-6):
            plan["affine_scale_refine_note"] = "已用预变换Edge长度微调几何缩放比例。"
            return "已用预变换Edge长度微调几何缩放比例，使目标Edge长度更接近输入值。"
        plan["affine_scale_refine_note"] = ""
        return ""

    def _apply_edge_length_affine_transform(self, plan: dict[str, object]) -> None:
        target_kind, source_shape, part, solid = self._edge_length_affine_target(plan)
        previous_logical_ids = tuple(getattr(self, "face_logical_ids", ()))
        transformed = self._affine_scaled_shape_along_edge(source_shape, plan)
        _ensure_valid_shape(transformed)
        if target_kind == "part":
            part.shape = transformed
        else:
            part_solids = _explore(part.shape, TopAbs_SOLID)
            replaced = False
            shapes: list[TopoDS_Shape] = []
            for item in part_solids:
                if not replaced and _same_shape(item, solid):
                    shapes.append(transformed)
                    replaced = True
                else:
                    shapes.append(item)
            if not replaced:
                raise RuntimeError(f"Could not locate solid {plan.get('solid_id')} inside part {plan.get('part_id')}.")
            part.shape = _compound_from_shapes(shapes)
            _ensure_valid_shape(part.shape)
        self.refresh_topology()
        self._restore_face_logical_ids_if_count_matches(previous_logical_ids)

    def _edge_length_affine_target(
        self,
        plan: dict[str, object],
    ) -> tuple[str, TopoDS_Shape, object, TopoDS_Shape | None]:
        part_id = int(plan.get("part_id", -1))
        solid_id = int(plan.get("solid_id", -1))
        part = self.part_by_id(part_id)
        if part is None:
            raise ValueError(f"Unknown part id {part_id}")
        target_kind = str(plan.get("affine_target_kind", "part"))
        if target_kind == "solid" and 0 <= solid_id < len(self.solids):
            return target_kind, self.solids[solid_id][1], part, self.solids[solid_id][1]
        return "part", part.shape, part, None

    def _affine_scaled_shape_along_edge(self, shape: TopoDS_Shape, plan: dict[str, object]) -> TopoDS_Shape:
        axis_point = _tuple_or_none(plan.get("affine_axis_point"))
        axis_direction = _tuple_normalized(_tuple_or_none(plan.get("affine_axis_direction")))
        scale = float(plan.get("affine_scale", 1.0))
        transform_kind = str(plan.get("affine_transform_kind", "axis-affine"))
        if axis_point is None:
            raise ValueError("Missing affine edge-length axis.")
        if transform_kind == "uniform":
            transform = gp_Trsf()
            transform.SetScale(gp_Pnt(*axis_point), scale)
            builder = BRepBuilderAPI_Transform(shape, transform, True)
            builder.Build()
            if not builder.IsDone():
                raise RuntimeError("Uniform edge-length scale transform failed.")
            result = builder.Shape()
            if result.IsNull():
                raise RuntimeError("Uniform edge-length scale transform produced an empty shape.")
            return result

        if axis_direction is None:
            raise ValueError("Missing affine edge-length axis direction.")
        ux, uy, uz = axis_direction
        if transform_kind == "radial-affine":
            matrix = [
                [scale + (1.0 - scale) * ux * ux, (1.0 - scale) * ux * uy, (1.0 - scale) * ux * uz],
                [(1.0 - scale) * uy * ux, scale + (1.0 - scale) * uy * uy, (1.0 - scale) * uy * uz],
                [(1.0 - scale) * uz * ux, (1.0 - scale) * uz * uy, scale + (1.0 - scale) * uz * uz],
            ]
        else:
            matrix = [
                [1.0 + (scale - 1.0) * ux * ux, (scale - 1.0) * ux * uy, (scale - 1.0) * ux * uz],
                [(scale - 1.0) * uy * ux, 1.0 + (scale - 1.0) * uy * uy, (scale - 1.0) * uy * uz],
                [(scale - 1.0) * uz * ux, (scale - 1.0) * uz * uy, 1.0 + (scale - 1.0) * uz * uz],
            ]
        cx, cy, cz = axis_point
        moved_center = (
            matrix[0][0] * cx + matrix[0][1] * cy + matrix[0][2] * cz,
            matrix[1][0] * cx + matrix[1][1] * cy + matrix[1][2] * cz,
            matrix[2][0] * cx + matrix[2][1] * cy + matrix[2][2] * cz,
        )
        translation = (cx - moved_center[0], cy - moved_center[1], cz - moved_center[2])
        transform = gp_GTrsf()
        for row in range(3):
            for column in range(3):
                transform.SetValue(row + 1, column + 1, matrix[row][column])
        transform.SetTranslationPart(gp_XYZ(*translation))
        builder = BRepBuilderAPI_GTransform(shape, transform, True)
        builder.Build()
        if not builder.IsDone():
            raise RuntimeError(f"{transform_kind} edge-length transform failed.")
        result = builder.Shape()
        if result.IsNull():
            raise RuntimeError(f"{transform_kind} edge-length transform produced an empty shape.")
        return result

    def push_pull_face(self, face_id: int, distance: float) -> str:
        plan = self.push_pull_plan(face_id, distance)
        if plan["status"] == "blocked":
            raise ValueError(str(plan["message"]))
        face = self.faces[face_id]
        surf = BRepAdaptor_Surface(face)
        if surf.GetType() != GeomAbs_Plane:
            raise ValueError("Push/pull currently supports planar faces only.")

        part_id = self.face_part_ids[face_id]
        part = self.part_by_id(part_id)
        if part is None:
            raise ValueError(f"Unknown part id {part_id}")

        outward = plan["outward_direction"]
        scope_face_ids = _int_values(plan.get("push_pull_scope_face_ids")) or [face_id]
        boundary_shell_extension = None
        if plan.get("cylindrical_cap_extension_kind") is None:
            boundary_shell_extension = self._planar_cap_boundary_shell_extension_plan(
                face_id,
                float(distance),
                outward,
                scope_face_ids,
            )
        if boundary_shell_extension is not None:
            target_logical_id: int | None = None
            target_region_mapping_specs: list[dict[str, object]] = []
            try:
                target_logical_id = self.face_region_logical_id(face_id)
                plan["target_logical_id"] = target_logical_id
                target_region_mapping_specs = self._translated_face_region_mapping_specs(
                    self._face_region_mapping_specs([face_id]),
                    _tuple_scale(outward, float(distance)),
                    logical_id=target_logical_id,
                )
            except Exception:
                target_logical_id = None
                target_region_mapping_specs = []

            def apply_boundary_shell_extension() -> None:
                previous_face_count = len(self.faces)
                part.shape = self._planar_cap_boundary_shell_extension_shape(
                    face_id,
                    boundary_shell_extension,
                    float(distance),
                    outward,
                )
                self.refresh_topology()
                if len(self.faces) > previous_face_count:
                    plan["result_candidate_face_ids"] = tuple(range(previous_face_count, len(self.faces)))
                self._apply_face_region_mapping_specs_exclusive(target_logical_id, target_region_mapping_specs)

            _action_result, result_check = self._run_checked_face_edit(plan, apply_boundary_shell_extension)
            return (
                "Planar face push/pull completed: planar cap boundary-shell rebuild, "
                f"semantic_distance={distance:g}, "
                f"boundary_edges={int(boundary_shell_extension['cap_boundary_edge_count'])}, "
                f"inner_wires={int(boundary_shell_extension['inner_boundary_wires'])}, "
                f"adjacent_faces={int(boundary_shell_extension['adjacent_face_count'])}, "
                f"outward_direction={_format_tuple(outward)}, "
                f"direction_confidence={plan['direction_confidence']}, "
                f"risk={plan['risk']}. {result_check}"
            )
        profile_shape = self._push_pull_profile_shape(scope_face_ids)
        boundary_edge_ids = self._region_boundary_edge_ids(scope_face_ids)
        side_face_ids = sorted(
            set(self._adjacent_face_ids_for_edges(boundary_edge_ids, face_id)) - set(scope_face_ids)
        )
        side_region_mapping_specs = self._face_region_mapping_specs(side_face_ids)
        target_logical_id: int | None = None
        target_region_mapping_specs: list[dict[str, object]] = []
        try:
            target_logical_id = self.face_region_logical_id(face_id)
            plan["target_logical_id"] = target_logical_id
            target_region_mapping_specs = self._translated_face_region_mapping_specs(
                self._face_region_mapping_specs([face_id]),
                _tuple_scale(outward, float(distance)),
                logical_id=target_logical_id,
            )
        except Exception:
            target_logical_id = None
            target_region_mapping_specs = []

        cap_extension = self._cylindrical_cap_extension_plan(face_id, distance, outward)
        prismatic_cap_rebuild: dict[str, object] | None = None
        if cap_extension is None or str(cap_extension.get("cap_extension_method") or "") == "cap-profile-prism":
            try:
                prismatic_cap_rebuild = self._prismatic_cap_rebuild_candidate(
                    face_id,
                    float(distance),
                    outward,
                    profile_shape,
                )
            except Exception:
                prismatic_cap_rebuild = None
        if prismatic_cap_rebuild is not None:
            def apply_prismatic_cap_rebuild() -> None:
                part.shape = prismatic_cap_rebuild["replacement_shape"]
                self.refresh_topology()
                self._apply_face_region_mapping_specs(side_region_mapping_specs)
                self._apply_face_region_mapping_specs_exclusive(target_logical_id, target_region_mapping_specs)

            _action_result, result_check = self._run_checked_face_edit(plan, apply_prismatic_cap_rebuild)
            return (
                "Planar face push/pull completed: prismatic cap analytic rebuild, "
                f"semantic_distance={distance:g}, "
                f"old_height={float(prismatic_cap_rebuild['old_height']):g}, "
                f"new_height={float(prismatic_cap_rebuild['new_height']):g}, "
                f"side_faces={int(prismatic_cap_rebuild['side_face_count'])}, "
                f"cap_planes={int(prismatic_cap_rebuild['cap_plane_count'])}, "
                f"outward_direction={_format_tuple(outward)}, "
                f"direction_confidence={plan['direction_confidence']}, "
                f"risk={plan['risk']}. {result_check}"
            )
        slow_boolean_blocker = self._slow_push_pull_boolean_blocker(plan, cap_extension)
        if slow_boolean_blocker:
            raise ValueError(slow_boolean_blocker)
        if cap_extension is not None:
            use_cap_profile_prism = (
                int(cap_extension.get("cap_extra_adjacent_face_count") or 0) > 0
                and str(cap_extension.get("cap_extension_method") or "") == "cap-profile-prism"
            )
            use_cap_local_shell_rebuild = str(cap_extension.get("cap_extension_method") or "") == "local-shell-rebuild"
            simple_replacement = (
                cap_extension["tool_shape"]
                if (
                    not use_cap_profile_prism
                    and not use_cap_local_shell_rebuild
                    and self._simple_cylindrical_cap_extension_rebuild_available(face_id, cap_extension)
                )
                else None
            )
            if use_cap_profile_prism:
                cap_operation = "profile-extend" if float(distance) > 0.0 else "profile-retract"
            else:
                cap_operation = str(cap_extension.get("cap_operation") or "extend")
            if use_cap_profile_prism:
                local_delta_shape = self._cap_profile_prism_delta_shape(
                    profile_shape,
                    part.shape,
                    outward,
                    float(distance),
                )
                cap_extension["local_delta_shape"] = local_delta_shape
                cap_extension["extension_shape"] = local_delta_shape
                cap_extension["cap_extension_method"] = "cap-profile-prism"
            elif use_cap_local_shell_rebuild:
                local_delta_shape = None
            else:
                local_delta_shape = (
                    cap_extension.get("local_delta_shape")
                    or cap_extension.get("extension_shape")
                    or cap_extension.get("removal_shape")
                )
            if simple_replacement is None and local_delta_shape is None and not use_cap_local_shell_rebuild:
                raise RuntimeError("Cylindrical cap push/pull plan did not produce a local delta shape.")

            def apply_cap_extension() -> None:
                if simple_replacement is not None:
                    result = simple_replacement
                elif use_cap_local_shell_rebuild:
                    result = self._cylindrical_cap_local_shell_rebuild_shape(
                        face_id,
                        cap_extension,
                        float(distance),
                        outward,
                    )
                elif cap_operation in {"retract", "profile-retract"}:
                    op = BRepAlgoAPI_Cut(part.shape, local_delta_shape)
                    result = _finalize_boolean_result(op, "cylindrical cap push/pull local retraction", use_glue=False)
                    result = _cleanup_push_pull_result(result, part.shape, profile_shape, distance)
                else:
                    op = BRepAlgoAPI_Fuse(part.shape, local_delta_shape)
                    result = _finalize_boolean_result(op, "cylindrical cap push/pull local extension", use_glue=False)
                    result = _cleanup_push_pull_result(result, part.shape, profile_shape, distance)
                previous_face_count = len(self.faces)
                part.shape = result
                self.refresh_topology()
                if use_cap_local_shell_rebuild and len(self.faces) > previous_face_count:
                    plan["result_candidate_face_ids"] = tuple(range(previous_face_count, len(self.faces)))
                self._apply_face_region_mapping_specs(side_region_mapping_specs)
                self._apply_face_region_mapping_specs_exclusive(target_logical_id, target_region_mapping_specs)

            _action_result, result_check = self._run_checked_face_edit(plan, apply_cap_extension)
            action = (
                "cylindrical cap analytic rebuild"
                if simple_replacement is not None
                else (
                    "cylindrical cap local shell rebuild"
                    if use_cap_local_shell_rebuild
                    else (
                    "cylindrical cap profile-prism extension"
                    if cap_operation == "profile-extend"
                    else "cylindrical cap profile-prism retraction"
                    if cap_operation == "profile-retract"
                    else (
                    "cylindrical cap local retraction"
                    if cap_operation == "retract"
                    else "cylindrical cap local extension"
                    )
                    )
                )
            )
            return (
                f"Planar face push/pull completed: {action}, "
                f"semantic_distance={distance:g}, "
                f"radius={float(cap_extension['radius']):g}, "
                f"inner_radius={_format_result_number(cap_extension.get('inner_radius'))}, "
                f"old_height={float(cap_extension['old_height']):g}, "
                f"new_height={float(cap_extension['new_height']):g}, "
                f"extension_height={_format_result_number(cap_extension.get('extension_height'))}, "
                f"cap_operation={cap_operation}, "
                f"cap_extension_kind={cap_extension.get('cap_extension_kind')}, "
                f"cap_extension_method={cap_extension.get('cap_extension_method')}, "
                f"side_faces={cap_extension['side_face_ids']}, "
                f"outward_direction={_format_tuple(outward)}, "
                f"direction_confidence={plan['direction_confidence']}, "
                f"risk={plan['risk']}. {result_check}"
            )

        overlap = _boolean_overlap_distance(part.shape, distance)
        start_offset = -overlap if distance >= 0 else overlap
        tool_distance = distance + overlap if distance >= 0 else distance - overlap
        tool_face = _translated_shape(profile_shape, outward, start_offset)
        vec = gp_Vec(
            float(outward[0]) * tool_distance,
            float(outward[1]) * tool_distance,
            float(outward[2]) * tool_distance,
        )
        tool_shape = BRepPrimAPI_MakePrism(tool_face, vec).Shape()
        def apply_push_pull() -> None:
            op = BRepAlgoAPI_Fuse(part.shape, tool_shape) if distance >= 0 else BRepAlgoAPI_Cut(part.shape, tool_shape)
            result = _finalize_boolean_result(op, "push/pull")
            result = _cleanup_push_pull_result(result, part.shape, profile_shape, distance)
            part.shape = result
            self.refresh_topology()
            self._apply_face_region_mapping_specs(side_region_mapping_specs)
            self._apply_face_region_mapping_specs_exclusive(target_logical_id, target_region_mapping_specs)

        _action_result, result_check = self._run_checked_face_edit(plan, apply_push_pull)
        action = "fused outward prism" if distance >= 0 else "cut inward prism"
        return (
            "Planar face push/pull completed: "
            f"{action}, semantic_distance={distance:g}, "
            f"tool_overlap={overlap:g}, "
            f"scope_faces={len(scope_face_ids)}, "
            f"outward_direction={_format_tuple(outward)}, "
            f"direction_confidence={plan['direction_confidence']}, "
            f"risk={plan['risk']}. {result_check}"
        )

    def _cylindrical_cap_local_shell_rebuild_shape(
        self,
        face_id: int,
        cap_extension: dict[str, object],
        distance: float,
        outward: tuple[float, float, float],
    ) -> TopoDS_Shape:
        part_id = self.face_part_ids[face_id]
        solid_id = self.face_solid_ids[face_id]
        part = self.part_by_id(part_id)
        if part is None:
            raise ValueError(f"Unknown part id {part_id}")
        if solid_id < 0 or solid_id >= len(self.solids):
            raise ValueError(f"Face {face_id} is not attached to a rebuildable Solid.")
        source_solid = self.solids[solid_id][1]
        cap_scope_face_ids = _int_values(cap_extension.get("cap_scope_face_ids")) or [face_id]
        side_specs = [item for item in cap_extension.get("side_rebuild_specs", ()) if isinstance(item, dict)]
        if not side_specs:
            raise RuntimeError("Cylindrical cap local shell rebuild has no side Face rebuild specs.")
        axis_alignment = _float_or_none(cap_extension.get("axis_alignment"))
        if axis_alignment is None:
            raise RuntimeError("Cylindrical cap local shell rebuild has no axis direction.")
        if float(distance) <= 0.0 or str(cap_extension.get("cap_operation") or "") != "extend":
            raise RuntimeError(
                "Cylindrical cap local shell rebuild currently supports outward cap extension only."
            )
        remove_face_ids = sorted(set(cap_scope_face_ids))
        remove_faces = [self.faces[item] for item in remove_face_ids if 0 <= item < len(self.faces)]
        if not remove_faces:
            raise RuntimeError("Cylindrical cap local shell rebuild has no removable source Faces.")

        tolerance = max(
            _shape_diagonal(source_solid) * 1e-7,
            abs(float(distance)) * 1e-7,
            1e-6,
        )
        rebuilt_faces: list[TopoDS_Shape] = []
        removed_count = 0
        for source_face in _explore(source_solid, TopAbs_FACE):
            if any(_same_shape(source_face, removable) for removable in remove_faces):
                removed_count += 1
                continue
            rebuilt_faces.append(source_face)
        if removed_count < len(remove_faces):
            raise RuntimeError(
                "Cylindrical cap local shell rebuild could not find every source Face in the Solid."
            )

        for cap_face_id in cap_scope_face_ids:
            if cap_face_id < 0 or cap_face_id >= len(self.faces):
                continue
            moved_cap = _translated_shape(
                self.faces[cap_face_id],
                (float(outward[0]), float(outward[1]), float(outward[2])),
                float(distance),
            )
            _ensure_valid_shape(moved_cap)
            rebuilt_faces.append(moved_cap)

        for spec in side_specs:
            side_face_id = int(spec.get("face_id", -1))
            if side_face_id < 0 or side_face_id >= len(self.faces):
                raise RuntimeError("Cylindrical cap local shell rebuild references an invalid side Face.")
            surf = BRepAdaptor_Surface(self.faces[side_face_id])
            if surf.GetType() != GeomAbs_Cylinder:
                raise RuntimeError("Cylindrical cap local shell rebuild side Face is not cylindrical.")
            u_min = float(spec["u_min"])
            u_max = float(spec["u_max"])
            if axis_alignment > 0.0:
                v_min = float(spec["old_v_max"])
                v_max = float(spec["new_v_max"])
            else:
                v_min = float(spec["new_v_min"])
                v_max = float(spec["old_v_min"])
            if v_max <= v_min + tolerance:
                raise RuntimeError("Cylindrical cap local shell rebuild collapsed a side Face.")
            side_face = BRepBuilderAPI_MakeFace(surf.Cylinder(), u_min, u_max, v_min, v_max).Face()
            side_face.Orientation(self.faces[side_face_id].Orientation())
            _ensure_valid_shape(side_face)
            rebuilt_faces.append(side_face)

        sewing = BRepBuilderAPI_Sewing(tolerance)
        for rebuilt_face in rebuilt_faces:
            sewing.Add(rebuilt_face)
        sewing.Perform()
        sewed = sewing.SewedShape()
        if sewed.IsNull():
            raise RuntimeError("Cylindrical cap local shell rebuild sewing produced an empty shape.")
        if sewed.ShapeType() == TopAbs_SHELL:
            shell = topods.Shell(sewed)
        else:
            shells = _explore(sewed, TopAbs_SHELL)
            if not shells:
                raise RuntimeError("Cylindrical cap local shell rebuild did not produce a sewable shell.")
            shell = topods.Shell(shells[0])
        solid_builder = BRepBuilderAPI_MakeSolid(shell)
        rebuilt_solid = solid_builder.Solid()
        if rebuilt_solid.IsNull():
            raise RuntimeError("Cylindrical cap local shell rebuild could not create a Solid.")
        rebuilt_solid = _ensure_valid_or_repaired_shape(rebuilt_solid, "cylindrical cap local shell rebuild")

        part_solids = _explore(part.shape, TopAbs_SOLID)
        if not part_solids:
            return rebuilt_solid
        if len(part_solids) == 1 and _same_shape(part_solids[0], source_solid):
            return rebuilt_solid
        shapes: list[TopoDS_Shape] = []
        replaced = False
        for item in part_solids:
            if not replaced and _same_shape(item, source_solid):
                shapes.append(rebuilt_solid)
                replaced = True
            else:
                shapes.append(item)
        if not replaced:
            raise RuntimeError(f"Could not locate solid {solid_id} inside part {part_id}.")
        return _ensure_valid_or_repaired_shape(
            _compound_from_shapes(shapes),
            "cylindrical cap local shell rebuild compound",
        )

    def _cap_profile_prism_delta_shape(
        self,
        profile_shape: TopoDS_Shape,
        source_shape: TopoDS_Shape,
        outward: tuple[float, float, float],
        distance: float,
    ) -> TopoDS_Shape:
        if abs(distance) <= 1e-9:
            raise ValueError("Cap profile prism push/pull requires a non-zero distance.")
        overlap = _boolean_overlap_distance(source_shape, distance)
        if distance > 0:
            start_offset = -overlap
            tool_distance = distance + overlap
        else:
            start_offset = overlap
            tool_distance = distance - overlap
        tool_face = _translated_shape(profile_shape, outward, start_offset)
        vec = gp_Vec(
            float(outward[0]) * tool_distance,
            float(outward[1]) * tool_distance,
            float(outward[2]) * tool_distance,
        )
        tool_shape = BRepPrimAPI_MakePrism(tool_face, vec).Shape()
        _ensure_valid_shape(tool_shape)
        return tool_shape

    def _prismatic_cap_rebuild_candidate(
        self,
        face_id: int,
        distance: float,
        outward: tuple[float, float, float],
        profile_shape: TopoDS_Shape,
    ) -> dict[str, object] | None:
        if abs(distance) <= 1e-9:
            return None
        if face_id < 0 or face_id >= len(self.faces):
            return None
        part_id = self.face_part_ids[face_id]
        solid_id = self.face_solid_ids[face_id]
        part = self.part_by_id(part_id)
        if part is None or solid_id < 0 or solid_id >= len(self.solids):
            return None
        if sum(1 for candidate_part_id, _solid in self.solids if candidate_part_id == part_id) != 1:
            return None

        source_surf = BRepAdaptor_Surface(self.faces[face_id])
        if source_surf.GetType() != GeomAbs_Plane:
            return None
        axis_direction_tuple = _tuple_normalized(outward)
        if axis_direction_tuple is None:
            return None
        axis_point = source_surf.Plane().Location()
        axis_direction = gp_Dir(*axis_direction_tuple)
        solid = self.solids[solid_id][1]
        axis_interval = _shape_axis_interval(solid, axis_point, axis_direction)
        if axis_interval is None:
            return None
        interval_min, interval_max = float(axis_interval[0]), float(axis_interval[1])
        old_height = max(interval_max - interval_min, 0.0)
        if old_height <= 1e-9:
            return None
        tolerance = max(_shape_diagonal(solid) * 1e-6, abs(distance) * 1e-6, old_height * 1e-6, 1e-5)
        if abs(interval_max) > max(old_height * 0.08, tolerance * 20.0):
            return None
        new_height = old_height + float(distance)
        if new_height <= max(old_height * 1e-5, tolerance):
            return None

        cap_parameters: list[float] = []
        side_face_count = 0
        solid_face_ids = [index for index, item in enumerate(self.face_solid_ids) if item == solid_id]
        if len(solid_face_ids) < 3 or len(solid_face_ids) > 128:
            return None
        for candidate_face_id in solid_face_ids:
            try:
                surf = BRepAdaptor_Surface(self.faces[candidate_face_id])
            except Exception:
                return None
            surface_type = surf.GetType()
            if surface_type == GeomAbs_Plane:
                normal = surf.Plane().Axis().Direction()
                normal_dot = abs(_direction_dot(normal, axis_direction))
                if normal_dot >= 0.92:
                    center = _surface_center(self.faces[candidate_face_id])
                    cap_parameters.append(_axis_parameter(axis_point, axis_direction, center))
                elif normal_dot <= 0.12:
                    side_face_count += 1
                else:
                    return None
            elif surface_type == GeomAbs_Cylinder:
                cylinder_axis = surf.Cylinder().Axis().Direction()
                if abs(_direction_dot(cylinder_axis, axis_direction)) < 0.92:
                    return None
                side_face_count += 1
            else:
                return None

        unique_cap_parameters: list[float] = []
        for parameter in sorted(cap_parameters):
            if not any(abs(parameter - existing) <= tolerance * 20.0 for existing in unique_cap_parameters):
                unique_cap_parameters.append(parameter)
        if len(unique_cap_parameters) != 2 or side_face_count <= 0:
            return None
        if abs(max(unique_cap_parameters)) > max(old_height * 0.08, tolerance * 20.0):
            return None
        if abs(min(unique_cap_parameters) - interval_min) > max(old_height * 0.08, tolerance * 20.0):
            return None

        profile_start = _translated_shape(profile_shape, axis_direction_tuple, interval_min)
        vec = gp_Vec(
            float(axis_direction_tuple[0]) * new_height,
            float(axis_direction_tuple[1]) * new_height,
            float(axis_direction_tuple[2]) * new_height,
        )
        replacement = BRepPrimAPI_MakePrism(profile_start, vec).Shape()
        replacement = _ensure_valid_or_repaired_shape(replacement, "prismatic cap analytic rebuild")
        replacement = _unify_same_domain_shape(replacement)
        replacement = _ensure_valid_or_repaired_shape(replacement, "prismatic cap analytic rebuild unify")
        return {
            "replacement_shape": replacement,
            "old_height": old_height,
            "new_height": new_height,
            "axis_interval": axis_interval,
            "side_face_count": side_face_count,
            "cap_plane_count": len(cap_parameters),
            "cap_position_count": len(unique_cap_parameters),
            "axis_direction": axis_direction_tuple,
            "start_offset": interval_min,
        }

    def _slow_push_pull_boolean_blocker(
        self,
        plan: dict[str, object],
        cap_extension: dict[str, object] | None,
    ) -> str:
        distance = abs(float(plan.get("distance", 0.0) or 0.0))
        if distance <= 1e-9:
            return ""
        face_count = len(self.faces)
        selected_inner_wires = int(plan.get("selected_inner_boundary_wires", 0) or 0)
        bbox_diagonal = _float_or_none(plan.get("bbox_diagonal")) or 0.0
        face_ratio = distance / bbox_diagonal if bbox_diagonal > 1e-9 else None
        cap_method = str(cap_extension.get("cap_extension_method") or "") if cap_extension is not None else ""
        old_height = _float_or_none(cap_extension.get("old_height")) if cap_extension is not None else None
        height_ratio = distance / old_height if old_height is not None and old_height > 1e-9 else None

        if (
            cap_method == "cap-profile-prism"
            and height_ratio is not None
            and height_ratio > 0.35
        ):
            return (
                "已识别为带槽口/台阶等额外一级相邻面的端盖，但无法把它安全简化成解析重建；"
                "继续走通用 OCCT 布尔很容易长时间卡住。已快速阻止本次大距离拉伸/切除，"
                "请先缩小修改距离，或后续用更明确的槽/台阶一级关系编辑入口处理。"
            )

        if (
            cap_extension is None
            and face_count > 600
            and selected_inner_wires > 0
            and (
                face_ratio is None
                or face_ratio > 0.2
                or distance > 10.0
            )
        ):
            return (
                "当前 Face 有多个内孔/内边界，并且所属 STEP 实体很复杂；程序没有识别到可安全解析重建的单一拉伸体。"
                "继续使用通用布尔拉伸/切除很可能再次超时。已快速阻止本次大距离拉伸/切除；"
                "简单空心圆柱、多个贯穿孔圆柱和普通板件端盖已经会走快速解析重建，"
                "这种复杂大实体需要先做更明确的特征隔离/一级关系编辑。"
            )
        return ""

    def _planar_cap_boundary_shell_extension_plan(
        self,
        face_id: int,
        distance: float,
        outward: tuple[float, float, float],
        scope_face_ids: Iterable[int] | None = None,
    ) -> dict[str, object] | None:
        if abs(float(distance)) <= 1e-9:
            return None
        if face_id < 0 or face_id >= len(self.faces):
            return None
        try:
            surf = BRepAdaptor_Surface(self.faces[face_id])
        except Exception:
            return None
        if surf.GetType() != GeomAbs_Plane:
            return None
        solid_id = self.face_solid_ids[face_id]
        part_id = self.face_part_ids[face_id]
        if solid_id < 0 or solid_id >= len(self.solids):
            return None
        if self.part_by_id(part_id) is None:
            return None

        try:
            wire_count = len(_explore(self.faces[face_id], TopAbs_WIRE))
        except Exception:
            wire_count = 0
        inner_wires = max(wire_count - 1, 0)
        if inner_wires <= 0:
            return None

        cap_scope_face_ids = sorted(
            {
                int(item)
                for item in (scope_face_ids or (face_id,))
                if 0 <= int(item) < len(self.faces) and int(self.face_solid_ids[int(item)]) == solid_id
            }
        )
        if not cap_scope_face_ids:
            cap_scope_face_ids = [face_id]
        boundary_edge_ids = self._region_boundary_edge_ids(cap_scope_face_ids)
        if not boundary_edge_ids:
            boundary_edge_ids = self._face_boundary_edge_ids(face_id)
        boundary_edge_ids = sorted({int(item) for item in boundary_edge_ids if 0 <= int(item) < len(self.edges)})
        if len(boundary_edge_ids) < 4:
            return None

        adjacent_ids = sorted(
            set(self._adjacent_face_ids_for_edges(boundary_edge_ids, face_id)) - set(cap_scope_face_ids)
        )
        if not adjacent_ids:
            return None

        return {
            "cap_extension_kind": "multi-boundary-planar-cap",
            "cap_extension_method": "boundary-shell-rebuild",
            "cap_operation": "extend" if float(distance) > 0.0 else "retract",
            "cap_scope_face_ids": tuple(cap_scope_face_ids),
            "cap_boundary_edge_ids": tuple(boundary_edge_ids),
            "cap_boundary_edge_count": len(boundary_edge_ids),
            "bridge_face_count": len(boundary_edge_ids),
            "inner_boundary_wires": inner_wires,
            "boundary_wires": wire_count,
            "adjacent_face_ids": tuple(adjacent_ids),
            "adjacent_face_count": len(adjacent_ids),
            "part_id": part_id,
            "solid_id": solid_id,
        }

    def _planar_cap_boundary_shell_extension_shape(
        self,
        face_id: int,
        extension: dict[str, object],
        distance: float,
        outward: tuple[float, float, float],
    ) -> TopoDS_Shape:
        if abs(float(distance)) <= 1e-9:
            raise RuntimeError("Planar cap boundary-shell rebuild requires a non-zero distance.")
        part_id = self.face_part_ids[face_id]
        solid_id = self.face_solid_ids[face_id]
        part = self.part_by_id(part_id)
        if part is None:
            raise ValueError(f"Unknown part id {part_id}")
        if solid_id < 0 or solid_id >= len(self.solids):
            raise ValueError(f"Face {face_id} is not attached to a rebuildable Solid.")
        source_solid = self.solids[solid_id][1]
        cap_scope_face_ids = _int_values(extension.get("cap_scope_face_ids")) or [face_id]
        cap_scope_face_ids = [
            item
            for item in cap_scope_face_ids
            if 0 <= item < len(self.faces) and int(self.face_solid_ids[item]) == solid_id
        ]
        if not cap_scope_face_ids:
            raise RuntimeError("Planar cap boundary-shell rebuild has no cap Face to move.")
        boundary_edge_ids = _int_values(extension.get("cap_boundary_edge_ids"))
        if not boundary_edge_ids:
            boundary_edge_ids = self._region_boundary_edge_ids(cap_scope_face_ids)
        boundary_edge_ids = sorted({item for item in boundary_edge_ids if 0 <= item < len(self.edges)})
        if len(boundary_edge_ids) < 3:
            raise RuntimeError("Planar cap boundary-shell rebuild has too few boundary Edges.")

        tolerance = max(
            _shape_diagonal(source_solid) * 1e-7,
            abs(float(distance)) * 1e-7,
            1e-6,
        )
        remove_faces = [self.faces[item] for item in cap_scope_face_ids]
        rebuilt_faces: list[TopoDS_Shape] = []
        removed_count = 0
        for source_face in _explore(source_solid, TopAbs_FACE):
            if any(_same_shape(source_face, removable) for removable in remove_faces):
                removed_count += 1
                continue
            rebuilt_faces.append(source_face)
        if removed_count < len(remove_faces):
            raise RuntimeError(
                "Planar cap boundary-shell rebuild could not find every source cap Face in the Solid."
            )

        for cap_face_id in cap_scope_face_ids:
            moved_cap = _translated_shape(
                self.faces[cap_face_id],
                (float(outward[0]), float(outward[1]), float(outward[2])),
                float(distance),
            )
            _ensure_valid_shape(moved_cap)
            rebuilt_faces.append(moved_cap)

        bridge_vector = gp_Vec(
            float(outward[0]) * float(distance),
            float(outward[1]) * float(distance),
            float(outward[2]) * float(distance),
        )
        bridge_face_count = 0
        for edge_id in boundary_edge_ids:
            bridge_shape = BRepPrimAPI_MakePrism(self.edges[edge_id], bridge_vector).Shape()
            bridge_faces = _explore(bridge_shape, TopAbs_FACE)
            if not bridge_faces and bridge_shape.ShapeType() == TopAbs_FACE:
                bridge_faces = [bridge_shape]
            if not bridge_faces:
                raise RuntimeError(
                    f"Planar cap boundary-shell rebuild could not create a bridge Face for Edge {edge_id}."
                )
            for bridge_face in bridge_faces:
                if bridge_face.IsNull():
                    raise RuntimeError(
                        f"Planar cap boundary-shell rebuild created an empty bridge Face for Edge {edge_id}."
                    )
                rebuilt_faces.append(bridge_face)
                bridge_face_count += 1
        if bridge_face_count < len(boundary_edge_ids):
            raise RuntimeError(
                "Planar cap boundary-shell rebuild created fewer bridge Faces than boundary Edges."
            )

        sewing = BRepBuilderAPI_Sewing(tolerance)
        for rebuilt_face in rebuilt_faces:
            sewing.Add(rebuilt_face)
        sewing.Perform()
        sewed = sewing.SewedShape()
        if sewed.IsNull():
            raise RuntimeError("Planar cap boundary-shell rebuild sewing produced an empty shape.")
        if sewed.ShapeType() == TopAbs_SHELL:
            shell = topods.Shell(sewed)
        else:
            shells = _explore(sewed, TopAbs_SHELL)
            if not shells:
                raise RuntimeError("Planar cap boundary-shell rebuild did not produce a sewable shell.")
            shell = topods.Shell(shells[0])
        solid_builder = BRepBuilderAPI_MakeSolid(shell)
        rebuilt_solid = solid_builder.Solid()
        if rebuilt_solid.IsNull():
            raise RuntimeError("Planar cap boundary-shell rebuild could not create a Solid.")
        rebuilt_solid = _ensure_valid_or_repaired_shape(
            rebuilt_solid,
            "planar cap boundary-shell rebuild",
        )

        part_solids = _explore(part.shape, TopAbs_SOLID)
        if not part_solids:
            return rebuilt_solid
        if len(part_solids) == 1 and _same_shape(part_solids[0], source_solid):
            return rebuilt_solid
        shapes: list[TopoDS_Shape] = []
        replaced = False
        for item in part_solids:
            if not replaced and _same_shape(item, source_solid):
                shapes.append(rebuilt_solid)
                replaced = True
            else:
                shapes.append(item)
        if not replaced:
            raise RuntimeError(f"Could not locate solid {solid_id} inside part {part_id}.")
        return _ensure_valid_or_repaired_shape(
            _compound_from_shapes(shapes),
            "planar cap boundary-shell rebuild compound",
        )

    def _cylindrical_cap_extension_plan(
        self,
        face_id: int,
        distance: float,
        outward: tuple[float, float, float],
    ) -> dict[str, object] | None:
        if abs(distance) <= 1e-9:
            return None
        if face_id < 0 or face_id >= len(self.faces):
            return None
        source_surf = BRepAdaptor_Surface(self.faces[face_id])
        if source_surf.GetType() != GeomAbs_Plane:
            return None
        source_plane = source_surf.Plane()
        cap_plane_point = source_plane.Location()
        try:
            scope_face_ids = self._connected_coplanar_planar_face_ids(face_id) or [face_id]
        except Exception:
            scope_face_ids = [face_id]
        scope_face_ids = sorted({int(item) for item in scope_face_ids if 0 <= int(item) < len(self.faces)})
        if not scope_face_ids:
            scope_face_ids = [face_id]
        try:
            region_shape = _compound_from_shapes([self.faces[item] for item in scope_face_ids])
            region_props = GProp_GProps()
            brepgprop.SurfaceProperties(region_shape, region_props)
            cap_center = region_props.CentreOfMass()
        except Exception:
            cap_center = _surface_center(self.faces[face_id])
        boundary_edge_ids = self._region_boundary_edge_ids(scope_face_ids)
        if not boundary_edge_ids:
            boundary_edge_ids = self._face_boundary_edge_ids(face_id)
        adjacent_face_ids = self._adjacent_face_ids_for_edges(boundary_edge_ids, face_id)
        if not adjacent_face_ids:
            return None

        diagonal = _shape_diagonal(self.shape)
        tolerance = min(max(diagonal * 1e-7, 1e-6), 1e-3)
        outward_dir = gp_Dir(float(outward[0]), float(outward[1]), float(outward[2]))
        candidates: list[tuple[float, dict[str, object]]] = []
        cylindrical_adjacent_face_ids: set[int] = set()
        adjacent_face_id_set = set(int(item) for item in adjacent_face_ids)

        for adjacent_id in adjacent_face_ids:
            side_surf = BRepAdaptor_Surface(self.faces[adjacent_id])
            if side_surf.GetType() != GeomAbs_Cylinder:
                continue
            angular_span = abs(side_surf.LastUParameter() - side_surf.FirstUParameter())

            cylinder = side_surf.Cylinder()
            radius = float(cylinder.Radius())
            axis = cylinder.Axis()
            axis_point = axis.Location()
            axis_dir = axis.Direction()
            axis_alignment = _direction_dot(outward_dir, axis_dir)
            if abs(axis_alignment) < 0.92:
                continue
            center_axis_distance = _point_axis_distance(axis_point, axis_dir, cap_center)

            axis_range = self._cylindrical_axis_range(adjacent_id, side_surf)
            v_min = float(axis_range["v_min"])
            v_max = float(axis_range["v_max"])
            old_height = max(v_max - v_min, 1e-9)
            cap_parameter = _axis_parameter(axis_point, axis_dir, cap_plane_point)
            start_distance = abs(cap_parameter - v_min)
            end_distance = abs(cap_parameter - v_max)
            end_tolerance = max(old_height * 0.05, radius * 0.2, tolerance * 10.0, 0.05)

            delta_abs = abs(float(distance))
            operation = "extend" if distance > 0 else "retract"
            segment_overlap = (
                min(
                    max(tolerance * 20.0, radius * 1e-5, old_height * 1e-5, 1e-5),
                    max(old_height * 0.02, 1e-5),
                    max(delta_abs * 0.05, 1e-5),
                )
                if operation == "extend"
                else 0.0
            )
            if axis_alignment > 0 and end_distance <= end_tolerance:
                new_min = v_min
                new_max = v_max + distance if distance > 0 else v_max - delta_abs
                if new_max <= new_min + max(tolerance * 10.0, old_height * 1e-5, 1e-6):
                    continue
                segment_start_parameter = v_max - segment_overlap if distance > 0 else new_max
                segment_height = delta_abs + segment_overlap if distance > 0 else delta_abs
                end_score = end_distance
            elif axis_alignment < 0 and start_distance <= end_tolerance:
                new_min = v_min - distance if distance > 0 else v_min + delta_abs
                new_max = v_max
                if new_max <= new_min + max(tolerance * 10.0, old_height * 1e-5, 1e-6):
                    continue
                segment_start_parameter = new_min if distance > 0 else v_min
                segment_height = delta_abs + segment_overlap if distance > 0 else delta_abs
                end_score = start_distance
            else:
                continue

            height = max(new_max - new_min, 1e-6)
            start = _point_on_axis(axis_point, axis_dir, new_min)
            end = _point_on_axis(axis_point, axis_dir, new_max)
            old_start = _point_on_axis(axis_point, axis_dir, v_min)
            old_end = _point_on_axis(axis_point, axis_dir, v_max)
            tool_shape = BRepPrimAPI_MakeCylinder(gp_Ax2(start, gp_Dir(axis_dir.X(), axis_dir.Y(), axis_dir.Z())), radius, height).Shape()
            segment_start = _point_on_axis(axis_point, axis_dir, segment_start_parameter)
            segment_shape = BRepPrimAPI_MakeCylinder(
                gp_Ax2(segment_start, gp_Dir(axis_dir.X(), axis_dir.Y(), axis_dir.Z())),
                radius,
                max(segment_height, 1e-6),
            ).Shape()
            score = end_score + _point_axis_distance(axis_point, axis_dir, cap_center)
            candidate = {
                "tool_shape": tool_shape,
                "extension_shape": segment_shape if operation == "extend" else None,
                "removal_shape": segment_shape if operation == "retract" else None,
                "local_delta_shape": segment_shape,
                "side_face_ids": axis_range["same_domain_face_ids"],
                "radius": radius,
                "old_height": old_height,
                "new_height": height,
                "extension_height": max(segment_height, 1e-6),
                "cap_operation": operation,
                "axis_alignment": axis_alignment,
                "angular_span": angular_span,
                "cap_center_axis_distance": center_axis_distance,
                "axis_point": _point_tuple(axis_point),
                "axis_direction": (float(axis_dir.X()), float(axis_dir.Y()), float(axis_dir.Z())),
                "cap_axis_parameter": cap_parameter,
                "old_start_parameter": v_min,
                "old_end_parameter": v_max,
                "start_parameter": new_min,
                "end_parameter": new_max,
                "old_start_point": _point_tuple(old_start),
                "old_end_point": _point_tuple(old_end),
                "start_point": _point_tuple(start),
                "end_point": _point_tuple(end),
                "extension_start_point": _point_tuple(segment_start),
                "cap_extension_kind": "solid-cylinder",
                "inner_radius": None,
                "cap_scope_face_ids": tuple(scope_face_ids),
                "cap_boundary_edge_ids": tuple(boundary_edge_ids),
            }
            candidates.append((score, candidate))
            cylindrical_adjacent_face_ids.add(int(adjacent_id))

        if not candidates:
            return None
        distinct_radii: list[float] = []
        for _score, candidate in candidates:
            radius = float(candidate["radius"])
            if not any(abs(radius - existing) <= max(radius, existing, 1.0) * 1e-5 for existing in distinct_radii):
                distinct_radii.append(radius)
        if len(distinct_radii) > 1:
            tube_candidate = self._coaxial_tube_cap_extension_candidate(candidates, tolerance)
            if tube_candidate is not None and self._tube_cap_region_matches_radii(
                scope_face_ids,
                tube_candidate,
                tolerance,
            ):
                extra_adjacent_face_ids = tuple(sorted(adjacent_face_id_set - cylindrical_adjacent_face_ids))
                tube_candidate["cap_scope_face_ids"] = tuple(scope_face_ids)
                tube_candidate["cap_boundary_edge_ids"] = tuple(boundary_edge_ids)
                tube_candidate["cap_extra_adjacent_face_ids"] = extra_adjacent_face_ids
                tube_candidate["cap_extra_adjacent_face_count"] = len(extra_adjacent_face_ids)
                if extra_adjacent_face_ids:
                    if distance > 0:
                        tube_candidate["cap_extension_method"] = "cap-profile-prism"
                    else:
                        tube_candidate.update(
                            self._cap_extra_adjacent_retract_limit(
                                extra_adjacent_face_ids,
                                tube_candidate,
                                tolerance,
                            )
                        )
                        if bool(tube_candidate.get("cap_profile_prism_retract_safe")):
                            tube_candidate["cap_extension_method"] = "cap-profile-prism"
                return tube_candidate
            stepped_candidate = self._coaxial_stepped_cap_extension_candidate(candidates, tolerance)
            if stepped_candidate is not None and self._tube_cap_region_matches_radii(
                scope_face_ids,
                stepped_candidate,
                tolerance,
            ):
                extra_adjacent_face_ids = tuple(sorted(adjacent_face_id_set - cylindrical_adjacent_face_ids))
                stepped_candidate["cap_scope_face_ids"] = tuple(scope_face_ids)
                stepped_candidate["cap_boundary_edge_ids"] = tuple(boundary_edge_ids)
                stepped_candidate["cap_extra_adjacent_face_ids"] = extra_adjacent_face_ids
                stepped_candidate["cap_extra_adjacent_face_count"] = len(extra_adjacent_face_ids)
                if (
                    str(stepped_candidate.get("cap_operation") or "") == "extend"
                    and not extra_adjacent_face_ids
                    and self._cylindrical_cap_side_faces_are_simple(
                    stepped_candidate,
                    scope_face_ids,
                    tolerance,
                    )
                ):
                    stepped_candidate["cap_extension_method"] = "local-shell-rebuild"
                    return stepped_candidate
            return None
        extra_adjacent_face_ids = tuple(sorted(adjacent_face_id_set - cylindrical_adjacent_face_ids))
        if len(distinct_radii) == 1 and extra_adjacent_face_ids:
            solid_candidate = min(candidates, key=lambda item: item[0])[1]
            if self._solid_cap_region_matches_radius(scope_face_ids, solid_candidate, tolerance):
                solid_candidate["cap_scope_face_ids"] = tuple(scope_face_ids)
                solid_candidate["cap_boundary_edge_ids"] = tuple(boundary_edge_ids)
                solid_candidate["cap_extra_adjacent_face_ids"] = extra_adjacent_face_ids
                solid_candidate["cap_extra_adjacent_face_count"] = len(extra_adjacent_face_ids)
                if distance > 0:
                    solid_candidate["cap_extension_method"] = "cap-profile-prism"
                else:
                    solid_candidate.update(
                        self._cap_extra_adjacent_retract_limit(
                            extra_adjacent_face_ids,
                            solid_candidate,
                            tolerance,
                        )
                    )
                    if bool(solid_candidate.get("cap_profile_prism_retract_safe")):
                        solid_candidate["cap_extension_method"] = "cap-profile-prism"
                return solid_candidate
        if cylindrical_adjacent_face_ids != adjacent_face_id_set:
            return None
        if any(not _is_effectively_full_cylinder(candidate) for _score, candidate in candidates):
            return None
        if any(
            float(candidate.get("cap_center_axis_distance") or 0.0)
            > max(float(candidate["radius"]) * 0.08, tolerance * 10.0)
            for _score, candidate in candidates
        ):
            return None
        return min(candidates, key=lambda item: item[0])[1]

    def _cap_extra_adjacent_retract_limit(
        self,
        extra_face_ids: Iterable[int],
        cap_extension: dict[str, object],
        tolerance: float,
    ) -> dict[str, object]:
        axis_point_tuple = _tuple_or_none(cap_extension.get("axis_point"))
        axis_direction_tuple = _tuple_normalized(_tuple_or_none(cap_extension.get("axis_direction")))
        axis_alignment = _float_or_none(cap_extension.get("axis_alignment"))
        if axis_point_tuple is None or axis_direction_tuple is None or axis_alignment is None:
            return {"cap_profile_prism_retract_safe": False}
        axis_point = gp_Pnt(*axis_point_tuple)
        axis_direction = gp_Dir(*axis_direction_tuple)
        old_start = _float_or_none(cap_extension.get("old_start_parameter"))
        old_end = _float_or_none(cap_extension.get("old_end_parameter"))
        new_start = _float_or_none(cap_extension.get("start_parameter"))
        new_end = _float_or_none(cap_extension.get("end_parameter"))
        if old_start is None or old_end is None or new_start is None or new_end is None:
            return {"cap_profile_prism_retract_safe": False}

        if axis_alignment > 0.0:
            old_cap_parameter = old_end
            target_parameter = new_end
        else:
            old_cap_parameter = old_start
            target_parameter = new_start

        limit_candidates: list[float] = []
        touch_tolerance = max(abs(old_end - old_start) * 1e-4, tolerance * 50.0, 1e-4)
        for face_id in extra_face_ids:
            if face_id < 0 or face_id >= len(self.faces):
                continue
            interval = _shape_axis_interval(self.faces[face_id], axis_point, axis_direction)
            if interval is None:
                continue
            interval_min, interval_max = float(interval[0]), float(interval[1])
            if not (interval_min - touch_tolerance <= old_cap_parameter <= interval_max + touch_tolerance):
                continue
            limit_candidates.append(interval_min if axis_alignment > 0.0 else interval_max)

        if not limit_candidates:
            return {
                "cap_profile_prism_retract_safe": False,
                "cap_profile_prism_target_parameter": target_parameter,
            }

        if axis_alignment > 0.0:
            limit_parameter = min(limit_candidates)
            safe = target_parameter >= limit_parameter - touch_tolerance
            excess = max(limit_parameter - target_parameter, 0.0)
        else:
            limit_parameter = max(limit_candidates)
            safe = target_parameter <= limit_parameter + touch_tolerance
            excess = max(target_parameter - limit_parameter, 0.0)
        return {
            "cap_profile_prism_retract_safe": safe,
            "cap_profile_prism_target_parameter": target_parameter,
            "cap_profile_prism_retract_limit_parameter": limit_parameter,
            "cap_profile_prism_retract_excess": excess,
        }

    def _solid_cap_region_matches_radius(
        self,
        face_ids: Iterable[int],
        cap_extension: dict[str, object],
        tolerance: float,
    ) -> bool:
        radius = _float_or_none(cap_extension.get("radius"))
        axis_point_tuple = _tuple_or_none(cap_extension.get("axis_point"))
        axis_direction_tuple = _tuple_normalized(_tuple_or_none(cap_extension.get("axis_direction")))
        if radius is None or radius <= 1e-9 or axis_point_tuple is None or axis_direction_tuple is None:
            return False
        axis_point = gp_Pnt(*axis_point_tuple)
        axis_direction = gp_Dir(*axis_direction_tuple)
        radial_values: list[float] = []
        for item in face_ids:
            if item < 0 or item >= len(self.faces):
                continue
            explorer = TopExp_Explorer(self.faces[item], TopAbs_VERTEX)
            while explorer.More():
                vertex = topods.Vertex(explorer.Current())
                radial_values.append(_point_axis_distance(axis_point, axis_direction, BRep_Tool.Pnt(vertex)))
                explorer.Next()
        if not radial_values:
            return False
        radial_tolerance = max(radius * 0.04, tolerance * 50.0, 1e-4)
        radial_max = max(radial_values)
        if radial_max > radius + radial_tolerance:
            return False
        if abs(radial_max - radius) > radial_tolerance:
            return False
        cap_extension["cap_region_radial_max"] = radial_max
        return True

    def _tube_cap_region_matches_radii(
        self,
        face_ids: Iterable[int],
        cap_extension: dict[str, object],
        tolerance: float,
    ) -> bool:
        outer_radius = _float_or_none(cap_extension.get("radius"))
        inner_radius = _float_or_none(cap_extension.get("inner_radius"))
        axis_point_tuple = _tuple_or_none(cap_extension.get("axis_point"))
        axis_direction_tuple = _tuple_normalized(_tuple_or_none(cap_extension.get("axis_direction")))
        if (
            outer_radius is None
            or inner_radius is None
            or outer_radius <= inner_radius
            or inner_radius <= 1e-9
            or axis_point_tuple is None
            or axis_direction_tuple is None
        ):
            return False
        axis_point = gp_Pnt(*axis_point_tuple)
        axis_direction = gp_Dir(*axis_direction_tuple)
        radial_values: list[float] = []
        for item in face_ids:
            if item < 0 or item >= len(self.faces):
                continue
            explorer = TopExp_Explorer(self.faces[item], TopAbs_VERTEX)
            while explorer.More():
                vertex = topods.Vertex(explorer.Current())
                radial_values.append(_point_axis_distance(axis_point, axis_direction, BRep_Tool.Pnt(vertex)))
                explorer.Next()
        if not radial_values:
            return False
        radial_tolerance = max(outer_radius * 0.04, inner_radius * 0.04, tolerance * 50.0, 1e-4)
        radial_min = min(radial_values)
        radial_max = max(radial_values)
        if radial_max > outer_radius + radial_tolerance:
            return False
        if radial_min < inner_radius - radial_tolerance:
            return False
        if abs(radial_max - outer_radius) > radial_tolerance:
            return False
        if abs(radial_min - inner_radius) > radial_tolerance:
            return False
        cap_extension["cap_region_radial_min"] = radial_min
        cap_extension["cap_region_radial_max"] = radial_max
        return True

    def _coaxial_tube_cap_extension_candidate(
        self,
        candidates: list[tuple[float, dict[str, object]]],
        tolerance: float,
    ) -> dict[str, object] | None:
        if len(candidates) < 2:
            return None
        radii = sorted({round(float(candidate["radius"]), 9) for _score, candidate in candidates})
        if len(radii) != 2:
            return None
        inner_radius = float(radii[0])
        outer_radius = float(radii[1])
        if inner_radius <= 1e-9 or outer_radius <= inner_radius:
            return None

        reference = candidates[0][1]
        axis_point_tuple = _tuple_or_none(reference.get("axis_point"))
        axis_direction_tuple = _tuple_normalized(_tuple_or_none(reference.get("axis_direction")))
        start_point_tuple = _tuple_or_none(reference.get("start_point"))
        end_point_tuple = _tuple_or_none(reference.get("end_point"))
        old_start_point_tuple = _tuple_or_none(reference.get("old_start_point"))
        old_end_point_tuple = _tuple_or_none(reference.get("old_end_point"))
        if (
            axis_point_tuple is None
            or axis_direction_tuple is None
            or start_point_tuple is None
            or end_point_tuple is None
            or old_start_point_tuple is None
            or old_end_point_tuple is None
        ):
            return None
        axis_point = gp_Pnt(*axis_point_tuple)
        axis_direction = gp_Dir(*axis_direction_tuple)
        start_point = gp_Pnt(*start_point_tuple)
        end_point = gp_Pnt(*end_point_tuple)
        old_start_point = gp_Pnt(*old_start_point_tuple)
        old_end_point = gp_Pnt(*old_end_point_tuple)
        start_parameter = float(reference["start_parameter"])
        end_parameter = float(reference["end_parameter"])
        old_height = float(reference["old_height"])
        new_height = float(reference["new_height"])

        side_face_ids: set[int] = set()
        score = 0.0
        reference_operation = str(reference.get("cap_operation") or "extend")
        for item_score, candidate in candidates:
            if str(candidate.get("cap_operation") or "extend") != reference_operation:
                return None
            candidate_axis_point = _tuple_or_none(candidate.get("axis_point"))
            candidate_axis_direction = _tuple_normalized(_tuple_or_none(candidate.get("axis_direction")))
            if candidate_axis_point is None or candidate_axis_direction is None:
                return None
            if abs(abs(_tuple_dot(axis_direction_tuple, candidate_axis_direction)) - 1.0) > 1e-5:
                return None
            if _point_axis_distance(axis_point, axis_direction, gp_Pnt(*candidate_axis_point)) > max(tolerance * 10.0, outer_radius * 1e-5):
                return None
            for key, expected in (("old_height", old_height), ("new_height", new_height)):
                if abs(float(candidate[key]) - expected) > max(tolerance * 10.0, old_height * 1e-5, 1e-5):
                    return None
            candidate_start = _tuple_or_none(candidate.get("start_point"))
            candidate_end = _tuple_or_none(candidate.get("end_point"))
            candidate_old_start = _tuple_or_none(candidate.get("old_start_point"))
            candidate_old_end = _tuple_or_none(candidate.get("old_end_point"))
            if (
                candidate_start is None
                or candidate_end is None
                or candidate_old_start is None
                or candidate_old_end is None
            ):
                return None
            point_tolerance = max(tolerance * 20.0, outer_radius * 1e-5, old_height * 1e-6, 1e-5)
            for actual_point, expected_point in (
                (gp_Pnt(*candidate_start), start_point),
                (gp_Pnt(*candidate_end), end_point),
                (gp_Pnt(*candidate_old_start), old_start_point),
                (gp_Pnt(*candidate_old_end), old_end_point),
            ):
                if actual_point.Distance(expected_point) > point_tolerance:
                    return None
            side_face_ids.update(_int_values(candidate.get("side_face_ids")))
            score += float(item_score)

        extension_start_point_tuple = _tuple_or_none(reference.get("extension_start_point"))
        extension_height = _float_or_none(reference.get("extension_height"))
        if extension_start_point_tuple is None or extension_height is None or extension_height <= 1e-9:
            return None
        extension_start_point = gp_Pnt(*extension_start_point_tuple)
        operation = str(reference.get("cap_operation") or "extend")

        tool_shape = self._make_coaxial_tube_shape(start_point, axis_direction, outer_radius, inner_radius, new_height)
        local_delta_shape = self._make_coaxial_tube_shape(
            extension_start_point,
            axis_direction,
            outer_radius,
            inner_radius,
            extension_height,
        )
        return {
            **reference,
            "tool_shape": tool_shape,
            "extension_shape": local_delta_shape if operation == "extend" else None,
            "removal_shape": local_delta_shape if operation == "retract" else None,
            "local_delta_shape": local_delta_shape,
            "side_face_ids": tuple(sorted(side_face_ids)),
            "radius": outer_radius,
            "inner_radius": inner_radius,
            "old_height": old_height,
            "new_height": new_height,
            "extension_height": extension_height,
            "cap_operation": operation,
            "start_parameter": start_parameter,
            "end_parameter": end_parameter,
            "cap_extension_kind": "coaxial-tube",
            "candidate_score": score,
        }

    def _coaxial_stepped_cap_extension_candidate(
        self,
        candidates: list[tuple[float, dict[str, object]]],
        tolerance: float,
    ) -> dict[str, object] | None:
        if len(candidates) < 2:
            return None
        radii = sorted({round(float(candidate["radius"]), 9) for _score, candidate in candidates})
        if len(radii) != 2:
            return None
        inner_radius = float(radii[0])
        outer_radius = float(radii[1])
        if inner_radius <= 1e-9 or outer_radius <= inner_radius:
            return None

        reference = candidates[0][1]
        axis_point_tuple = _tuple_or_none(reference.get("axis_point"))
        axis_direction_tuple = _tuple_normalized(_tuple_or_none(reference.get("axis_direction")))
        if axis_point_tuple is None or axis_direction_tuple is None:
            return None
        axis_point = gp_Pnt(*axis_point_tuple)
        axis_direction = gp_Dir(*axis_direction_tuple)
        operation = str(reference.get("cap_operation") or "extend")
        axis_alignment = _float_or_none(reference.get("axis_alignment"))
        reference_cap_parameter = _float_or_none(reference.get("cap_axis_parameter"))
        if axis_alignment is None or reference_cap_parameter is None:
            return None

        side_face_ids: set[int] = set()
        radius_ranges: dict[float, dict[str, float]] = {}
        score = 0.0
        target_cap_parameter: float | None = None
        for item_score, candidate in candidates:
            if str(candidate.get("cap_operation") or "extend") != operation:
                return None
            candidate_axis_point = _tuple_or_none(candidate.get("axis_point"))
            candidate_axis_direction = _tuple_normalized(_tuple_or_none(candidate.get("axis_direction")))
            if candidate_axis_point is None or candidate_axis_direction is None:
                return None
            if abs(abs(_tuple_dot(axis_direction_tuple, candidate_axis_direction)) - 1.0) > 1e-5:
                return None
            if _point_axis_distance(axis_point, axis_direction, gp_Pnt(*candidate_axis_point)) > max(
                tolerance * 10.0,
                outer_radius * 1e-5,
            ):
                return None
            candidate_alignment = _float_or_none(candidate.get("axis_alignment"))
            candidate_cap_parameter = _float_or_none(candidate.get("cap_axis_parameter"))
            start_parameter = _float_or_none(candidate.get("start_parameter"))
            end_parameter = _float_or_none(candidate.get("end_parameter"))
            old_start_parameter = _float_or_none(candidate.get("old_start_parameter"))
            old_end_parameter = _float_or_none(candidate.get("old_end_parameter"))
            radius = _float_or_none(candidate.get("radius"))
            if (
                candidate_alignment is None
                or candidate_cap_parameter is None
                or start_parameter is None
                or end_parameter is None
                or old_start_parameter is None
                or old_end_parameter is None
                or radius is None
                or radius <= 1e-9
            ):
                return None
            if candidate_alignment * axis_alignment <= 0.0:
                return None
            if abs(candidate_cap_parameter - reference_cap_parameter) > max(tolerance * 20.0, 1e-5):
                return None
            candidate_target = end_parameter if axis_alignment > 0.0 else start_parameter
            if target_cap_parameter is None:
                target_cap_parameter = candidate_target
            elif abs(candidate_target - target_cap_parameter) > max(tolerance * 20.0, 1e-5):
                return None

            key = min(radii, key=lambda item: abs(item - float(radius)))
            existing = radius_ranges.get(key)
            data = {
                "radius": float(radius),
                "old_start_parameter": old_start_parameter,
                "old_end_parameter": old_end_parameter,
                "start_parameter": start_parameter,
                "end_parameter": end_parameter,
                "old_height": max(old_end_parameter - old_start_parameter, 0.0),
                "new_height": max(end_parameter - start_parameter, 0.0),
            }
            if existing is not None:
                for field in ("old_start_parameter", "old_end_parameter", "start_parameter", "end_parameter"):
                    if abs(float(existing[field]) - float(data[field])) > max(tolerance * 20.0, 1e-5):
                        return None
            radius_ranges[key] = data
            side_face_ids.update(_int_values(candidate.get("side_face_ids")))
            score += float(item_score)

        if set(radius_ranges) != set(radii) or target_cap_parameter is None:
            return None

        side_specs: list[dict[str, object]] = []
        for side_face_id in sorted(side_face_ids):
            if side_face_id < 0 or side_face_id >= len(self.faces):
                return None
            try:
                surf = BRepAdaptor_Surface(self.faces[side_face_id])
            except Exception:
                return None
            if surf.GetType() != GeomAbs_Cylinder:
                return None
            cylinder = surf.Cylinder()
            radius = float(cylinder.Radius())
            key = min(radii, key=lambda item: abs(item - radius))
            if abs(radius - key) > max(key * 1e-5, tolerance * 10.0):
                return None
            side_axis = cylinder.Axis()
            if abs(abs(_direction_dot(axis_direction, side_axis.Direction())) - 1.0) > 1e-5:
                return None
            if _point_axis_distance(axis_point, axis_direction, side_axis.Location()) > max(
                tolerance * 10.0,
                outer_radius * 1e-5,
            ):
                return None
            range_data = radius_ranges[key]
            side_specs.append(
                {
                    "face_id": side_face_id,
                    "radius": radius,
                    "u_min": float(surf.FirstUParameter()),
                    "u_max": float(surf.LastUParameter()),
                    "old_v_min": float(range_data["old_start_parameter"]),
                    "old_v_max": float(range_data["old_end_parameter"]),
                    "new_v_min": float(range_data["start_parameter"]),
                    "new_v_max": float(range_data["end_parameter"]),
                }
            )

        old_height = max(float(item["old_height"]) for item in radius_ranges.values())
        new_height = max(float(item["new_height"]) for item in radius_ranges.values())
        extension_height = abs(target_cap_parameter - reference_cap_parameter)
        return {
            **reference,
            "tool_shape": None,
            "extension_shape": None,
            "removal_shape": None,
            "local_delta_shape": None,
            "side_face_ids": tuple(sorted(side_face_ids)),
            "side_rebuild_specs": tuple(side_specs),
            "radius": outer_radius,
            "inner_radius": inner_radius,
            "old_height": old_height,
            "new_height": new_height,
            "extension_height": extension_height,
            "cap_operation": operation,
            "start_parameter": min(float(item["start_parameter"]) for item in radius_ranges.values()),
            "end_parameter": max(float(item["end_parameter"]) for item in radius_ranges.values()),
            "cap_extension_kind": "coaxial-stepped-cap",
            "candidate_score": score,
        }

    def _cylindrical_cap_side_faces_are_simple(
        self,
        cap_extension: dict[str, object],
        scope_face_ids: Iterable[int],
        tolerance: float,
    ) -> bool:
        side_specs = [item for item in cap_extension.get("side_rebuild_specs", ()) if isinstance(item, dict)]
        if not side_specs:
            return False
        axis_point_tuple = _tuple_or_none(cap_extension.get("axis_point"))
        axis_direction_tuple = _tuple_normalized(_tuple_or_none(cap_extension.get("axis_direction")))
        axis_alignment = _float_or_none(cap_extension.get("axis_alignment"))
        if axis_point_tuple is None or axis_direction_tuple is None or axis_alignment is None:
            return False
        axis_point = gp_Pnt(*axis_point_tuple)
        axis_direction = gp_Dir(*axis_direction_tuple)
        cap_scope = {int(item) for item in scope_face_ids if 0 <= int(item) < len(self.faces)}
        side_face_ids = {int(item.get("face_id", -1)) for item in side_specs}
        side_face_ids = {item for item in side_face_ids if 0 <= item < len(self.faces)}
        if not side_face_ids:
            return False
        end_tolerance = max(tolerance * 50.0, 1e-4)

        for spec in side_specs:
            side_face_id = int(spec.get("face_id", -1))
            if side_face_id < 0 or side_face_id >= len(self.faces):
                return False
            if len(_explore(self.faces[side_face_id], TopAbs_WIRE)) != 1:
                return False
            edge_ids = self._face_boundary_edge_ids(side_face_id)
            if not edge_ids or len(edge_ids) > 6:
                return False
            fixed_parameter = (
                _float_or_none(spec.get("old_v_min"))
                if axis_alignment > 0.0
                else _float_or_none(spec.get("old_v_max"))
            )
            if fixed_parameter is None:
                return False
            adjacent_ids: set[int] = set()
            for edge_id in edge_ids:
                adjacent_ids.update(self._edge_adjacent_face_ids(edge_id))
            extra_ids = sorted(adjacent_ids - {side_face_id} - side_face_ids - cap_scope)
            for extra_id in extra_ids:
                if extra_id < 0 or extra_id >= len(self.faces):
                    return False
                interval = _shape_axis_interval(self.faces[extra_id], axis_point, axis_direction)
                if interval is None:
                    return False
                interval_min, interval_max = float(interval[0]), float(interval[1])
                if not (interval_min - end_tolerance <= fixed_parameter <= interval_max + end_tolerance):
                    return False
        return True

    def _make_coaxial_tube_shape(
        self,
        start: gp_Pnt,
        axis_direction,
        outer_radius: float,
        inner_radius: float,
        height: float,
    ) -> TopoDS_Shape:
        axis = gp_Ax2(start, gp_Dir(axis_direction.X(), axis_direction.Y(), axis_direction.Z()))
        outer = BRepPrimAPI_MakeCylinder(axis, outer_radius, height).Shape()
        extra = max(float(height) * 1e-5, float(outer_radius) * 1e-5, 1e-5)
        cutter_start = _point_on_axis(start, axis_direction, -extra)
        cutter_axis = gp_Ax2(cutter_start, gp_Dir(axis_direction.X(), axis_direction.Y(), axis_direction.Z()))
        inner = BRepPrimAPI_MakeCylinder(cutter_axis, inner_radius, height + 2.0 * extra).Shape()
        op = BRepAlgoAPI_Cut(outer, inner)
        return _finalize_boolean_result(op, "coaxial tube analytic rebuild", use_glue=False)

    def _simple_cylindrical_cap_extension_rebuild_available(
        self,
        face_id: int,
        cap_extension: dict[str, object],
    ) -> bool:
        if face_id < 0 or face_id >= len(self.faces):
            return False
        solid_id = self.face_solid_ids[face_id]
        part_id = self.face_part_ids[face_id]
        if solid_id < 0 or solid_id >= len(self.solids):
            return False
        if sum(1 for candidate_part_id, _solid in self.solids if candidate_part_id == part_id) != 1:
            return False

        outer_radius = _float_or_none(cap_extension.get("radius"))
        inner_radius = _float_or_none(cap_extension.get("inner_radius"))
        axis_point_tuple = _tuple_or_none(cap_extension.get("axis_point"))
        axis_direction_tuple = _tuple_normalized(_tuple_or_none(cap_extension.get("axis_direction")))
        if outer_radius is None or outer_radius <= 1e-9 or axis_point_tuple is None or axis_direction_tuple is None:
            return False
        axis_point = gp_Pnt(*axis_point_tuple)
        axis_direction = gp_Dir(*axis_direction_tuple)
        tolerance = max(float(cap_extension.get("new_height") or 0.0) * 1e-6, outer_radius * 1e-5, 1e-5)
        expected_radii = [outer_radius]
        if inner_radius is not None and inner_radius > 1e-9:
            expected_radii.append(inner_radius)

        cylinder_matches: list[float] = []
        cap_parameters: list[float] = []
        face_ids = [index for index, item in enumerate(self.face_solid_ids) if item == solid_id]
        if len(face_ids) < 3 or len(face_ids) > 96:
            return False
        saw_inner_radius = inner_radius is None or inner_radius <= 1e-9
        saw_outer_radius = False
        for candidate_face_id in face_ids:
            try:
                surf = BRepAdaptor_Surface(self.faces[candidate_face_id])
            except Exception:
                return False
            if surf.GetType() == GeomAbs_Cylinder:
                cylinder = surf.Cylinder()
                radius = float(cylinder.Radius())
                if not any(abs(radius - expected) <= max(expected * 1e-5, tolerance) for expected in expected_radii):
                    return False
                if abs(abs(_direction_dot(axis_direction, cylinder.Axis().Direction())) - 1.0) > 1e-5:
                    return False
                if _point_axis_distance(axis_point, axis_direction, cylinder.Axis().Location()) > max(tolerance * 10.0, outer_radius * 1e-5):
                    return False
                if abs(radius - outer_radius) <= max(outer_radius * 1e-5, tolerance):
                    saw_outer_radius = True
                if inner_radius is not None and inner_radius > 1e-9:
                    if abs(radius - inner_radius) <= max(inner_radius * 1e-5, tolerance):
                        saw_inner_radius = True
                cylinder_matches.append(radius)
            elif surf.GetType() == GeomAbs_Plane:
                normal = surf.Plane().Axis().Direction()
                if abs(_direction_dot(normal, axis_direction)) < 0.92:
                    return False
                center = _surface_center(self.faces[candidate_face_id])
                if _point_axis_distance(axis_point, axis_direction, center) > max(outer_radius * 0.05, tolerance * 10.0):
                    return False
                cap_parameters.append(_axis_parameter(axis_point, axis_direction, center))
            else:
                return False

        unique_cap_parameters: list[float] = []
        cap_parameter_tolerance = max(
            float(cap_extension.get("new_height") or 0.0) * 1e-5,
            outer_radius * 1e-5,
            tolerance * 10.0,
            1e-5,
        )
        for parameter in sorted(cap_parameters):
            if not any(abs(parameter - existing) <= cap_parameter_tolerance for existing in unique_cap_parameters):
                unique_cap_parameters.append(parameter)
        if len(unique_cap_parameters) != 2:
            return False
        return bool(saw_outer_radius and saw_inner_radius)

    def resize_existing_fillet(self, face_id: int, target_radius: float) -> str:
        plan = self.existing_fillet_resize_plan(face_id, target_radius)
        if plan["status"] == "blocked":
            raise ValueError(str(plan["message"]))

        part_id = int(plan["part_id"])
        part = self.part_by_id(part_id)
        if part is None:
            raise ValueError(f"Unknown part id {part_id}")

        source_face = topods.Face(self.faces[face_id])
        defeatured = _defeature_faces(part.shape, [source_face])
        axis_point = gp_Pnt(*plan["axis_point"])
        axis_dir = gp_Dir(*plan["axis"])
        root_edges = _axis_aligned_edge_candidates(
            defeatured,
            axis_point,
            axis_dir,
            expected_length=float(plan.get("height_estimate") or 0.0),
            reference_radius=float(plan["current_radius"]),
        )
        if not root_edges:
            raise RuntimeError(
                "已尝试移除已有圆角面，但没有找到可重新倒圆的轴向锐边；"
                "该圆角可能不是简单直线边圆角。"
            )

        result = None
        failures: list[str] = []
        for index, root_edge in enumerate(root_edges[:16], start=1):
            try:
                maker = BRepFilletAPI_MakeFillet(defeatured)
                maker.Add(float(target_radius), topods.Edge(root_edge))
                result = _finalize_builder_result(maker, f"existing fillet resize candidate {index}")
                break
            except Exception as exc:
                failures.append(str(exc))
        if result is None:
            detail = failures[-1] if failures else "没有可用的候选边。"
            raise RuntimeError(
                "已移除已有圆角面，但所有候选锐边都无法重新倒圆；"
                f"该圆角可能是复杂 blend 或支撑面不适合重建。最后错误：{detail}"
            )

        part.shape = result
        self.refresh_topology()
        return (
            "Existing fillet radius resize completed: "
            f"face {face_id}, current_radius={float(plan['current_radius']):g}, "
            f"target_radius={target_radius:g}, "
            f"delta_radius={float(plan['delta_radius']):g}, "
            f"support_faces={plan.get('feature_existing_fillet_support_face_ids')}, "
            f"risk={plan['risk']}."
        )

    def fillet_edge(self, edge_id: int, radius: float) -> str:
        plan = self.edge_fillet_plan(edge_id, radius)
        if plan["status"] == "blocked":
            raise ValueError(str(plan["message"]))

        part_id = self.edge_part_ids[edge_id]
        part = self.part_by_id(part_id)
        if part is None:
            raise ValueError(f"Unknown part id {part_id}")

        maker = BRepFilletAPI_MakeFillet(part.shape)
        maker.Add(radius, topods.Edge(self.edges[edge_id]))
        result = _finalize_builder_result(maker, "edge fillet")
        part.shape = result
        self.refresh_topology()
        return (
            f"Edge fillet completed: edge {edge_id}, radius={radius:g}, "
            f"edge_length={float(plan['edge_length']):g}, "
            f"radius_to_length_ratio={float(plan['radius_to_length_ratio']):g}, "
            f"risk={plan['risk']}."
        )

    def chamfer_edge(self, edge_id: int, distance: float) -> str:
        plan = self.edge_chamfer_plan(edge_id, distance)
        if plan["status"] == "blocked":
            raise ValueError(str(plan["message"]))

        part_id = self.edge_part_ids[edge_id]
        part = self.part_by_id(part_id)
        if part is None:
            raise ValueError(f"Unknown part id {part_id}")

        maker = BRepFilletAPI_MakeChamfer(part.shape)
        maker.Add(distance, topods.Edge(self.edges[edge_id]))
        result = _finalize_builder_result(maker, "edge chamfer")
        part.shape = result
        self.refresh_topology()
        return (
            f"Edge chamfer completed: edge {edge_id}, distance={distance:g}, "
            f"edge_length={float(plan['edge_length']):g}, "
            f"distance_to_length_ratio={float(plan['distance_to_length_ratio']):g}, "
            f"risk={plan['risk']}."
        )

    def chamfer_edge_asymmetric(
        self,
        edge_id: int,
        distance1: float,
        distance2: float,
        reference_face_id: int | None = None,
    ) -> str:
        plan = self.edge_asymmetric_chamfer_plan(edge_id, distance1, distance2, reference_face_id)
        if plan["status"] == "blocked":
            raise ValueError(str(plan["message"]))

        part_id = self.edge_part_ids[edge_id]
        part = self.part_by_id(part_id)
        if part is None:
            raise ValueError(f"Unknown part id {part_id}")
        resolved_reference_face_id = int(plan["reference_face_id"])

        maker = BRepFilletAPI_MakeChamfer(part.shape)
        try:
            maker.Add(
                float(distance1),
                float(distance2),
                topods.Edge(self.edges[edge_id]),
                topods.Face(self.faces[resolved_reference_face_id]),
            )
        except TypeError as exc:
            raise RuntimeError("The current OCCT binding does not support asymmetric chamfer Add(D1, D2, Edge, Face).") from exc
        result = _finalize_builder_result(maker, "asymmetric edge chamfer")
        part.shape = result
        self.refresh_topology()
        return (
            f"Asymmetric Edge chamfer completed: edge {edge_id}, "
            f"distance1={float(distance1):g}, distance2={float(distance2):g}, "
            f"reference_face={resolved_reference_face_id}, "
            f"edge_length={float(plan['edge_length']):g}, "
            f"distance1_to_length_ratio={float(plan['distance1_to_length_ratio']):g}, "
            f"distance2_to_length_ratio={float(plan['distance2_to_length_ratio']):g}, "
            f"risk={plan['risk']}."
        )

    def chamfer_edge_distance_angle(
        self,
        edge_id: int,
        distance: float,
        angle_degrees: float,
        reference_face_id: int | None = None,
    ) -> str:
        plan = self.edge_distance_angle_chamfer_plan(edge_id, distance, angle_degrees, reference_face_id)
        if plan["status"] == "blocked":
            raise ValueError(str(plan["message"]))

        part_id = self.edge_part_ids[edge_id]
        part = self.part_by_id(part_id)
        if part is None:
            raise ValueError(f"Unknown part id {part_id}")
        resolved_reference_face_id = int(plan["reference_face_id"])

        maker = BRepFilletAPI_MakeChamfer(part.shape)
        try:
            maker.AddDA(
                float(distance),
                float(plan["target_angle_radians"]),
                topods.Edge(self.edges[edge_id]),
                topods.Face(self.faces[resolved_reference_face_id]),
            )
        except AttributeError as exc:
            raise RuntimeError("The current OCCT binding does not support distance-angle chamfer AddDA(D, Angle, Edge, Face).") from exc
        except TypeError as exc:
            raise RuntimeError("The current OCCT binding rejected distance-angle chamfer AddDA(D, Angle, Edge, Face).") from exc
        result = _finalize_builder_result(maker, "distance-angle edge chamfer")
        part.shape = result
        self.refresh_topology()
        return (
            f"Distance-angle Edge chamfer completed: edge {edge_id}, "
            f"distance={float(distance):g}, angle_degrees={float(angle_degrees):g}, "
            f"reference_face={resolved_reference_face_id}, "
            f"edge_length={float(plan['edge_length']):g}, "
            f"distance_to_length_ratio={float(plan['distance_to_length_ratio']):g}, "
            f"risk={plan['risk']}."
        )

    def enlarge_cylindrical_hole(self, face_id: int, new_diameter: float) -> str:
        return self.resize_cylindrical_hole(face_id, new_diameter)

    def resize_cylindrical_slot_width(
        self,
        face_id: int,
        target_width: float,
        pair_face_id: int | None = None,
    ) -> str:
        return self._resize_cylindrical_slot_parameter(face_id, target_width, "width", pair_face_id=pair_face_id)

    def resize_cylindrical_slot_depth(
        self,
        face_id: int,
        target_depth: float,
        pair_face_id: int | None = None,
    ) -> str:
        return self._resize_cylindrical_slot_parameter(face_id, target_depth, "depth", pair_face_id=pair_face_id)

    def resize_cylindrical_slot_arc_length(
        self,
        face_id: int,
        target_arc_length: float,
        pair_face_id: int | None = None,
    ) -> str:
        return self._resize_cylindrical_slot_parameter(face_id, target_arc_length, "arc_length", pair_face_id=pair_face_id)

    def resize_cylindrical_slot_angular_span(self, face_id: int, target_angular_span: float) -> str:
        plan = self.cylindrical_slot_angular_span_plan(face_id, target_angular_span)
        if plan["status"] == "blocked":
            raise ValueError(str(plan["message"]))
        return self._resize_cylindrical_slot_angular_span_with_sector_tool(plan)

    def resize_cylindrical_slot_total_length(
        self,
        face_id: int,
        target_total_length: float,
        pair_face_id: int | None = None,
    ) -> str:
        plan = self.cylindrical_slot_total_length_plan(face_id, target_total_length, pair_face_id=pair_face_id)
        if plan["status"] == "blocked":
            raise ValueError(str(plan["message"]))
        return self._resize_cylindrical_slot_length_with_capsule_tool(plan)

    def resize_cylindrical_slot_center_distance(
        self,
        face_id: int,
        target_center_distance: float,
        pair_face_id: int | None = None,
    ) -> str:
        plan = self.cylindrical_slot_center_distance_plan(
            face_id,
            target_center_distance,
            pair_face_id=pair_face_id,
        )
        if plan["status"] == "blocked":
            raise ValueError(str(plan["message"]))
        return self._resize_cylindrical_slot_length_with_capsule_tool(plan)

    def _resize_cylindrical_slot_parameter(
        self,
        face_id: int,
        target_value: float,
        mode: str,
        pair_face_id: int | None = None,
    ) -> str:
        plan = self.cylindrical_slot_resize_plan(face_id, target_value, mode, pair_face_id=pair_face_id)
        if plan["status"] == "blocked":
            raise ValueError(str(plan["message"]))

        target_diameter = float(plan["slot_target_diameter"])
        if plan.get("slot_resize_strategy") == "paired-obround-slot-prism":
            resize_result = self._resize_cylindrical_slot_with_capsule_tool(plan)
            tool_path = "paired-obround-slot-prism"
        else:
            resize_result = self._resize_cylindrical_slot_with_sector_tool(plan)
            tool_path = "slot-sector"
        mode_key = str(plan.get("slot_resize_mode") or mode)
        if mode_key == "depth":
            current_value = plan.get("slot_current_depth")
            final_value = plan.get("slot_target_depth")
            label = "depth"
        elif mode_key == "arc_length":
            current_value = plan.get("slot_current_arc_length")
            final_value = plan.get("slot_target_arc_length")
            label = "arc_length"
        else:
            current_value = plan.get("slot_current_width")
            final_value = plan.get("slot_target_width")
            label = "width"

        def fmt(value: object) -> str:
            try:
                return f"{float(value):g}"
            except (TypeError, ValueError):
                return ""

        return (
            f"Cylindrical slot {label} resize completed: face {face_id}, "
            f"{label}={fmt(current_value)}->{fmt(final_value)}, "
            f"derived_diameter={target_diameter:g}, "
            f"angular_span={fmt(plan.get('slot_angular_span'))}, "
            f"strategy={plan.get('slot_resize_strategy')}, "
            f"tool_path={tool_path}, "
            f"risk={plan['risk']}. {resize_result}"
        )

    def _slot_fill_radius(self, plan: dict[str, object]) -> float:
        fill_radius = _float_or_none(plan.get("fill_radius"))
        nominal_diameter = _float_or_none(plan.get("current_diameter"))
        if nominal_diameter is None:
            nominal_diameter = _float_or_none(plan.get("slot_target_diameter"))
        nominal_radius = nominal_diameter * 0.5 if nominal_diameter is not None else None
        if fill_radius is None or fill_radius <= 1e-9:
            fill_radius = nominal_radius if nominal_radius is not None else 0.0
        if nominal_radius is not None and nominal_radius > 0:
            overlap = min(max(nominal_radius * 0.02, 0.02), 0.2)
            fill_radius = max(fill_radius, nominal_radius + overlap)
        return float(fill_radius)

    def _drop_tiny_artifact_solids(
        self,
        result: TopoDS_Shape,
        reference_shape: TopoDS_Shape,
    ) -> tuple[TopoDS_Shape, dict[str, object]]:
        solids = _explore(result, TopAbs_SOLID)
        if len(solids) <= 1:
            return result, {"discarded_count": 0, "discarded_volume": 0.0}

        def solid_volume(shape: TopoDS_Shape) -> float:
            value = _shape_volume_info(shape).get("volume")
            try:
                return abs(float(value))
            except (TypeError, ValueError):
                return 0.0

        volumes = [solid_volume(solid) for solid in solids]
        largest_index = max(range(len(solids)), key=lambda index: volumes[index])
        largest_volume = volumes[largest_index]
        if largest_volume <= 1e-9:
            return result, {"discarded_count": 0, "discarded_volume": 0.0}

        reference_volume = solid_volume(reference_shape)
        volume_limit = max(largest_volume, reference_volume, 1.0) * 1e-4
        tiny_indices = [index for index, volume in enumerate(volumes) if index != largest_index and volume <= volume_limit]
        discarded_volume = sum(volumes[index] for index in tiny_indices)
        if len(tiny_indices) != len(solids) - 1 or discarded_volume > volume_limit:
            return result, {"discarded_count": 0, "discarded_volume": 0.0}

        return (
            solids[largest_index],
            {
                "discarded_count": len(tiny_indices),
                "discarded_volume": discarded_volume,
                "largest_volume": largest_volume,
                "volume_limit": volume_limit,
            },
        )

    def _resize_cylindrical_slot_length_with_capsule_tool(self, plan: dict[str, object]) -> str:
        face_id = int(plan["face_id"])
        part_id = self.face_part_ids[face_id]
        part = self.part_by_id(part_id)
        if part is None:
            raise ValueError(f"Unknown part id {part_id}")

        old_part_shape = part.shape
        source_shape = part.shape
        target_plan = dict(plan)
        target_plan["slot_capsule_start_center_1"] = plan.get("slot_capsule_target_start_center_1")
        target_plan["slot_capsule_start_center_2"] = plan.get("slot_capsule_target_start_center_2")
        try:
            filler = self._slot_capsule_prism_tool(plan, self._slot_fill_radius(plan))
            fuse = BRepAlgoAPI_Fuse(part.shape, filler)
            source_shape = _finalize_boolean_result(fuse, "obround slot length fill/fuse", use_glue=False)

            cutter = self._slot_capsule_prism_tool(target_plan, float(plan["slot_target_diameter"]) / 2.0)
            op = BRepAlgoAPI_Cut(source_shape, cutter)
            result = _finalize_boolean_result(op, "obround slot length cut")
            part.shape = result
            self.refresh_topology()
            verification = self._verify_obround_slot_length_result(plan, part_id)
            if not verification["matched"]:
                raise RuntimeError(str(verification.get("detail", "obround slot length result verification failed")))
        except Exception:
            part.shape = old_part_shape
            self.refresh_topology()
            raise

        mode_label = "center distance" if plan.get("slot_resize_mode") == "center_distance" else "total length"
        return (
            f"Obround cylindrical slot {mode_label} resize completed: "
            f"length {float(plan.get('slot_current_total_length', 0.0)):g} -> {float(plan['slot_target_total_length']):g}, "
            f"center_distance={float(plan['slot_current_center_distance']):g}->{float(plan['slot_target_center_distance']):g}, "
            f"diameter={float(plan['slot_target_diameter']):g}, "
            f"paired_face={plan.get('slot_pair_face_id', '')}, "
            f"mode={plan['resize_mode']}, action=capsule fill and recut, "
            f"verified_face={verification.get('face_id', '')}."
        )

    def _resize_cylindrical_slot_angular_span_with_sector_tool(self, plan: dict[str, object]) -> str:
        face_id = int(plan["face_id"])
        part_id = self.face_part_ids[face_id]
        part = self.part_by_id(part_id)
        if part is None:
            raise ValueError(f"Unknown part id {part_id}")

        old_part_shape = part.shape
        source_shape = part.shape
        try:
            filler = self._slot_sector_prism_tool(
                face_id,
                self._slot_fill_radius(plan),
                float(plan["fill_start_parameter"]),
                float(plan["fill_end_parameter"]),
            )
            fuse = BRepAlgoAPI_Fuse(part.shape, filler)
            source_shape = _finalize_boolean_result(fuse, "slot angular-span fill/fuse", use_glue=False)

            cutter = self._slot_sector_prism_tool(
                face_id,
                float(plan["slot_target_diameter"]) / 2.0,
                float(plan["cutter_start_parameter"]),
                float(plan["cutter_end_parameter"]),
                u_first_override=float(plan["slot_target_u_first"]),
                u_last_override=float(plan["slot_target_u_last"]),
                u_padding=0.0,
            )
            op = BRepAlgoAPI_Cut(source_shape, cutter)
            result = _finalize_boolean_result(op, "slot angular-span cut")
            part.shape = result
            self.refresh_topology()
            verification = self._verify_slot_angular_span_result(plan, part_id)
            if not verification["matched"]:
                raise RuntimeError(str(verification.get("detail", "slot angular-span result verification failed")))
        except Exception:
            part.shape = old_part_shape
            self.refresh_topology()
            raise

        return (
            "Cylindrical slot angular-span resize completed: "
            f"span {float(plan['slot_current_angular_span']):g} -> {float(plan['slot_target_angular_span']):g}, "
            f"degrees={math.degrees(float(plan['slot_current_angular_span'])):g}->{math.degrees(float(plan['slot_target_angular_span'])):g}, "
            f"diameter={float(plan['slot_target_diameter']):g}, "
            f"mode={plan['resize_mode']}, action=sector fill and recut, "
            f"height={float(plan['cutter_height']):g}, "
            f"verified_face={verification.get('face_id', '')}."
        )

    def _verify_slot_angular_span_result(self, plan: dict[str, object], part_id: int) -> dict[str, object]:
        target_span = _float_or_none(plan.get("slot_target_angular_span"))
        target_diameter = _float_or_none(plan.get("slot_target_diameter"))
        if target_span is None or target_span <= 1e-9 or target_diameter is None or target_diameter <= 1e-9:
            return {"matched": False, "detail": " Missing target slot angular-span verification data."}
        try:
            axis_point = gp_Pnt(*plan["cutter_axis_point"])
            axis_direction = gp_Dir(*plan["cutter_axis_direction"])
        except Exception:
            return {"matched": False, "detail": " Missing original slot axis data."}

        target_radius = target_diameter * 0.5
        part = self.part_by_id(part_id)
        diagonal = max(_shape_diagonal(part.shape) if part is not None else 0.0, target_radius, 1.0)
        radius_tolerance = max(target_radius * 0.03, diagonal * 1e-6, 1e-5)
        axis_tolerance = max(target_radius * 0.08, diagonal * 1e-5, 1e-4)
        span_tolerance = max(target_span * 0.08, 0.02)
        best: dict[str, object] | None = None
        best_score = math.inf

        for face_id, face in enumerate(self.faces):
            if self.face_part_ids[face_id] != part_id:
                continue
            try:
                surf = BRepAdaptor_Surface(face)
                if surf.GetType() != GeomAbs_Cylinder:
                    continue
                cyl = surf.Cylinder()
                candidate_radius = float(cyl.Radius())
                radius_error = abs(candidate_radius - target_radius)
                axis_dot = abs(_direction_dot(axis_direction, cyl.Axis().Direction()))
                if axis_dot < 1.0 - 1e-5:
                    continue
                axis_distance = _point_axis_distance(axis_point, axis_direction, cyl.Axis().Location())
                angular_span = abs(float(surf.LastUParameter()) - float(surf.FirstUParameter()))
                span_error = abs(angular_span - target_span)
            except Exception:
                continue

            score = (
                radius_error / max(radius_tolerance, 1e-9)
                + axis_distance / max(axis_tolerance, 1e-9)
                + span_error / max(span_tolerance, 1e-9)
            )
            candidate = {
                "matched": (
                    radius_error <= radius_tolerance
                    and axis_distance <= axis_tolerance
                    and span_error <= span_tolerance
                ),
                "face_id": face_id,
                "angular_span": angular_span,
                "span_error": span_error,
                "diameter": candidate_radius * 2.0,
                "radius_error": radius_error,
                "axis_distance": axis_distance,
                "span_tolerance": span_tolerance,
            }
            if candidate["matched"]:
                return self._attach_cylindrical_first_level_result_check(candidate, plan)
            if score < best_score:
                best_score = score
                best = candidate

        if best is None:
            return {"matched": False, "detail": " No cylindrical slot face on the original axis was found after angular-span edit."}
        return {
            "matched": False,
            "detail": (
                f" Closest slot Face {best['face_id']} span {float(best['angular_span']):.6g}, "
                f"target {target_span:.6g}, span error {float(best['span_error']):.6g}, "
                f"diameter {float(best['diameter']):.6g}."
            ),
            **best,
        }

    def _verify_obround_slot_length_result(self, plan: dict[str, object], part_id: int) -> dict[str, object]:
        target_distance = _float_or_none(plan.get("slot_target_center_distance"))
        target_diameter = _float_or_none(plan.get("slot_target_diameter"))
        axis_dir = _tuple_normalized(_tuple_or_none(plan.get("slot_capsule_axis_direction")))
        length_dir = _tuple_normalized(_tuple_or_none(plan.get("slot_capsule_length_direction")))
        if target_distance is None or target_diameter is None or axis_dir is None or length_dir is None:
            return {"matched": False, "detail": " Missing obround slot length verification data."}
        target_radius = target_diameter * 0.5
        if target_radius <= 1e-9 or target_distance <= 1e-9:
            return {"matched": False, "detail": " Invalid target slot length or diameter."}

        part = self.part_by_id(part_id)
        diagonal = max(_shape_diagonal(part.shape) if part is not None else 0.0, target_distance, target_radius, 1.0)
        radius_tolerance = max(target_radius * 0.03, diagonal * 1e-6, 1e-5)
        distance_tolerance = max(target_distance * 0.05, target_radius * 0.08, diagonal * 1e-5, 1e-4)
        candidates: list[dict[str, object]] = []
        for face_id, face in enumerate(self.faces):
            if self.face_part_ids[face_id] != part_id:
                continue
            try:
                surf = BRepAdaptor_Surface(face)
                if surf.GetType() != GeomAbs_Cylinder:
                    continue
                cyl = surf.Cylinder()
                radius = float(cyl.Radius())
                if abs(radius - target_radius) > radius_tolerance:
                    continue
                candidate_axis = _tuple_normalized(_dir_tuple(cyl.Axis().Direction()))
                if candidate_axis is None or abs(_tuple_dot(candidate_axis, axis_dir)) < 1.0 - 1e-4:
                    continue
                axis_range = self._cylindrical_axis_range(face_id, surf)
                mid_parameter = (float(axis_range["v_min"]) + float(axis_range["v_max"])) * 0.5
                mid = _point_tuple(_point_on_axis(cyl.Axis().Location(), cyl.Axis().Direction(), mid_parameter))
                candidates.append({"face_id": face_id, "mid": mid, "radius": radius})
            except Exception:
                continue

        best: dict[str, object] | None = None
        best_score = math.inf
        for index, first in enumerate(candidates):
            for second in candidates[index + 1 :]:
                raw_offset = _tuple_sub(second["mid"], first["mid"])
                axis_offset = _tuple_scale(axis_dir, _tuple_dot(raw_offset, axis_dir))
                section_offset = _tuple_sub(raw_offset, axis_offset)
                distance = _vector_length(section_offset)
                if distance <= 1e-9:
                    continue
                direction = _tuple_normalized(section_offset)
                if direction is None or abs(_tuple_dot(direction, length_dir)) < 0.96:
                    continue
                error = abs(distance - target_distance)
                score = error / max(distance_tolerance, 1e-9)
                candidate = {
                    "matched": error <= distance_tolerance,
                    "face_id": first["face_id"],
                    "paired_face_id": second["face_id"],
                    "center_distance": distance,
                    "target_center_distance": target_distance,
                    "center_distance_error": error,
                    "center_distance_tolerance": distance_tolerance,
                }
                if candidate["matched"]:
                    return self._attach_cylindrical_first_level_result_check(candidate, plan)
                if score < best_score:
                    best_score = score
                    best = candidate

        if best is None:
            return {"matched": False, "detail": " No paired cylindrical slot ends matching the target radius were found."}
        return {
            "matched": False,
            "detail": (
                f" Closest paired slot center distance {float(best['center_distance']):.6g}, "
                f"target {target_distance:.6g}, error {float(best['center_distance_error']):.6g}."
            ),
            **best,
        }

    def _verify_obround_slot_axis_move_result(self, plan: dict[str, object], part_id: int) -> dict[str, object]:
        target_center_1 = _tuple_or_none(plan.get("slot_pair_target_axis_center_1"))
        target_center_2 = _tuple_or_none(plan.get("slot_pair_target_axis_center_2"))
        target_distance = _float_or_none(plan.get("slot_target_center_distance"))
        if target_distance is None:
            target_distance = _float_or_none(plan.get("slot_pair_axis_distance"))
        target_diameter = _float_or_none(plan.get("slot_target_diameter"))
        axis_dir = _tuple_normalized(_tuple_or_none(plan.get("slot_capsule_axis_direction")))
        length_dir = _tuple_normalized(_tuple_or_none(plan.get("slot_capsule_length_direction")))
        if (
            target_center_1 is None
            or target_center_2 is None
            or target_distance is None
            or target_diameter is None
            or axis_dir is None
            or length_dir is None
        ):
            return {"matched": False, "detail": " Missing obround slot axis verification data."}
        target_radius = target_diameter * 0.5
        if target_radius <= 1e-9 or target_distance <= 1e-9:
            return {"matched": False, "detail": " Invalid target obround slot axis data."}

        part = self.part_by_id(part_id)
        diagonal = max(_shape_diagonal(part.shape) if part is not None else 0.0, target_distance, target_radius, 1.0)
        radius_tolerance = max(target_radius * 0.03, diagonal * 1e-6, 1e-5)
        distance_tolerance = max(target_distance * 0.05, target_radius * 0.08, diagonal * 1e-5, 1e-4)
        center_tolerance = max(target_radius * 0.08, diagonal * 1e-5, 1e-4)
        candidates: list[dict[str, object]] = []
        for face_id, face in enumerate(self.faces):
            if self.face_part_ids[face_id] != part_id:
                continue
            try:
                surf = BRepAdaptor_Surface(face)
                if surf.GetType() != GeomAbs_Cylinder:
                    continue
                cyl = surf.Cylinder()
                radius = float(cyl.Radius())
                if abs(radius - target_radius) > radius_tolerance:
                    continue
                candidate_axis = _tuple_normalized(_dir_tuple(cyl.Axis().Direction()))
                if candidate_axis is None or abs(_tuple_dot(candidate_axis, axis_dir)) < 1.0 - 1e-4:
                    continue
                axis_range = self._cylindrical_axis_range(face_id, surf)
                mid_parameter = (float(axis_range["v_min"]) + float(axis_range["v_max"])) * 0.5
                mid = _point_tuple(_point_on_axis(cyl.Axis().Location(), cyl.Axis().Direction(), mid_parameter))
                candidates.append({"face_id": face_id, "mid": mid, "radius": radius})
            except Exception:
                continue

        best: dict[str, object] | None = None
        best_score = math.inf
        for index, first in enumerate(candidates):
            for second in candidates[index + 1 :]:
                raw_offset = _tuple_sub(second["mid"], first["mid"])
                axis_offset = _tuple_scale(axis_dir, _tuple_dot(raw_offset, axis_dir))
                section_offset = _tuple_sub(raw_offset, axis_offset)
                distance = _vector_length(section_offset)
                if distance <= 1e-9:
                    continue
                direction = _tuple_normalized(section_offset)
                if direction is None or abs(_tuple_dot(direction, length_dir)) < 0.96:
                    continue
                distance_error = abs(distance - target_distance)
                direct_center_error = max(
                    _vector_length(_tuple_sub(first["mid"], target_center_1)),
                    _vector_length(_tuple_sub(second["mid"], target_center_2)),
                )
                swapped_center_error = max(
                    _vector_length(_tuple_sub(first["mid"], target_center_2)),
                    _vector_length(_tuple_sub(second["mid"], target_center_1)),
                )
                center_error = min(direct_center_error, swapped_center_error)
                score = (
                    distance_error / max(distance_tolerance, 1e-9)
                    + center_error / max(center_tolerance, 1e-9)
                )
                candidate = {
                    "matched": distance_error <= distance_tolerance and center_error <= center_tolerance,
                    "face_id": first["face_id"],
                    "paired_face_id": second["face_id"],
                    "center_distance": distance,
                    "target_center_distance": target_distance,
                    "center_distance_error": distance_error,
                    "center_error": center_error,
                    "center_tolerance": center_tolerance,
                }
                if candidate["matched"]:
                    return self._attach_cylindrical_first_level_result_check(candidate, plan)
                if score < best_score:
                    best_score = score
                    best = candidate

        if best is None:
            return {"matched": False, "detail": " No paired obround slot ends were found at the target axis."}
        return {
            "matched": False,
            "detail": (
                f" Closest obround slot center error {float(best['center_error']):.6g}, "
                f"distance {float(best['center_distance']):.6g}, target distance {target_distance:.6g}."
            ),
            **best,
        }

    def _resize_cylindrical_slot_with_capsule_tool(self, plan: dict[str, object]) -> str:
        face_id = int(plan["face_id"])
        face = self.faces[face_id]
        surf = BRepAdaptor_Surface(face)
        if surf.GetType() != GeomAbs_Cylinder:
            raise ValueError("Obround slot resize currently supports cylindrical faces only.")

        cyl = surf.Cylinder()
        old_radius = float(cyl.Radius())
        new_radius = float(plan["slot_target_diameter"]) / 2.0
        if new_radius <= 0:
            raise ValueError("Target slot diameter must be greater than 0.")

        part_id = self.face_part_ids[face_id]
        part = self.part_by_id(part_id)
        if part is None:
            raise ValueError(f"Unknown part id {part_id}")

        old_part_shape = part.shape
        source_shape = part.shape
        try:
            if plan["resize_mode"] == "shrink":
                filler = self._slot_capsule_prism_tool(plan, self._slot_fill_radius(plan))
                fuse = BRepAlgoAPI_Fuse(part.shape, filler)
                source_shape = _finalize_boolean_result(fuse, "obround slot fill/fuse")

            cutter = self._slot_capsule_prism_tool(plan, new_radius)
            op = BRepAlgoAPI_Cut(source_shape, cutter)
            result = _finalize_boolean_result(op, "obround slot cut")
            part.shape = result
            self.refresh_topology()
            verification = self._verify_cylindrical_resize_result(plan, part_id)
            if not verification["matched"]:
                raise RuntimeError(str(verification.get("detail", "obround slot result verification failed")))
        except Exception:
            part.shape = old_part_shape
            self.refresh_topology()
            raise

        action = "capsule cut" if plan["resize_mode"] == "enlarge" else "capsule fill and recut"
        return (
            "Obround cylindrical slot resize completed: "
            f"diameter {old_radius * 2.0:g} -> {float(plan['slot_target_diameter']):g}, "
            f"paired_face={plan.get('slot_pair_face_id', '')}, "
            f"axis_distance={float(plan.get('slot_pair_axis_distance', 0.0)):g}, "
            f"mode={plan['resize_mode']}, action={action}, "
            f"height={float(plan['cutter_height']):g}, "
            f"verified_face={verification.get('face_id', '')}."
        )

    def _slot_capsule_prism_tool(self, plan: dict[str, object], radius: float) -> TopoDS_Shape:
        if radius <= 1e-9:
            raise ValueError("Slot capsule radius must be greater than 0.")
        center_1 = _tuple_or_none(plan.get("slot_capsule_start_center_1"))
        center_2 = _tuple_or_none(plan.get("slot_capsule_start_center_2"))
        axis_dir = _tuple_normalized(_tuple_or_none(plan.get("slot_capsule_axis_direction")))
        length_dir = _tuple_normalized(_tuple_or_none(plan.get("slot_capsule_length_direction")))
        side_dir = _tuple_normalized(_tuple_or_none(plan.get("slot_capsule_side_direction")))
        if center_1 is None or center_2 is None or axis_dir is None or length_dir is None or side_dir is None:
            raise ValueError("Obround slot tool is missing capsule frame information.")
        center_distance = _vector_length(_tuple_sub(center_2, center_1))
        if center_distance <= 1e-9:
            raise ValueError("Obround slot tool requires two distinct slot centers.")
        if abs(_tuple_dot(axis_dir, length_dir)) > 1e-4 or abs(_tuple_dot(axis_dir, side_dir)) > 1e-4:
            raise ValueError("Obround slot capsule frame is not perpendicular to the extrusion axis.")
        if abs(_tuple_dot(length_dir, side_dir)) > 1e-4:
            raise ValueError("Obround slot capsule frame length/side axes are not perpendicular.")

        height = max(float(plan.get("cutter_height", 0.0)), 1e-6)
        height_vec = gp_Vec(axis_dir[0] * height, axis_dir[1] * height, axis_dir[2] * height)
        try:
            top_1 = _tuple_add(center_1, _tuple_scale(side_dir, radius))
            top_2 = _tuple_add(center_2, _tuple_scale(side_dir, radius))
            bottom_2 = _tuple_add(center_2, _tuple_scale(side_dir, -radius))
            bottom_1 = _tuple_add(center_1, _tuple_scale(side_dir, -radius))
            end_mid_2 = _tuple_add(center_2, _tuple_scale(length_dir, radius))
            end_mid_1 = _tuple_add(center_1, _tuple_scale(length_dir, -radius))

            top_edge = BRepBuilderAPI_MakeEdge(gp_Pnt(*top_1), gp_Pnt(*top_2)).Edge()
            end_arc_2 = GC_MakeArcOfCircle(gp_Pnt(*top_2), gp_Pnt(*end_mid_2), gp_Pnt(*bottom_2)).Value()
            end_edge_2 = BRepBuilderAPI_MakeEdge(end_arc_2).Edge()
            bottom_edge = BRepBuilderAPI_MakeEdge(gp_Pnt(*bottom_2), gp_Pnt(*bottom_1)).Edge()
            end_arc_1 = GC_MakeArcOfCircle(gp_Pnt(*bottom_1), gp_Pnt(*end_mid_1), gp_Pnt(*top_1)).Value()
            end_edge_1 = BRepBuilderAPI_MakeEdge(end_arc_1).Edge()
            wire = BRepBuilderAPI_MakeWire(top_edge, end_edge_2, bottom_edge, end_edge_1).Wire()
            tool_face = _finalize_builder_result(BRepBuilderAPI_MakeFace(wire), "obround slot circular profile")
            return _finalize_builder_result(BRepPrimAPI_MakePrism(tool_face, height_vec), "obround slot capsule prism")
        except Exception:
            # Keep the older sampled profile as a fallback for unusual frames. The
            # circular profile is preferred because it preserves cylindrical slot ends.
            pass

        sample_count = max(12, min(96, int(math.pi * max(radius, 1.0) / max(radius * 0.12, 0.02))))
        points: list[tuple[float, float, float]] = [
            _tuple_add(center_1, _tuple_scale(side_dir, radius)),
            _tuple_add(center_2, _tuple_scale(side_dir, radius)),
        ]
        for index in range(1, sample_count + 1):
            theta = math.pi / 2.0 - math.pi * index / sample_count
            radial = _tuple_add(_tuple_scale(length_dir, math.cos(theta) * radius), _tuple_scale(side_dir, math.sin(theta) * radius))
            points.append(_tuple_add(center_2, radial))
        points.append(_tuple_add(center_1, _tuple_scale(side_dir, -radius)))
        for index in range(1, sample_count + 1):
            theta = -math.pi / 2.0 - math.pi * index / sample_count
            radial = _tuple_add(_tuple_scale(length_dir, math.cos(theta) * radius), _tuple_scale(side_dir, math.sin(theta) * radius))
            points.append(_tuple_add(center_1, radial))

        tool_face = self._make_local_polygon_face(self._dedupe_local_points(points, max(radius * 1e-7, 1e-7)))
        return _finalize_builder_result(BRepPrimAPI_MakePrism(tool_face, height_vec), "obround slot capsule prism")

    def _resize_cylindrical_slot_with_sector_tool(self, plan: dict[str, object]) -> str:
        face_id = int(plan["face_id"])
        face = self.faces[face_id]
        surf = BRepAdaptor_Surface(face)
        if surf.GetType() != GeomAbs_Cylinder:
            raise ValueError("Slot resize currently supports cylindrical faces only.")

        cyl = surf.Cylinder()
        old_radius = cyl.Radius()
        new_radius = float(plan["slot_target_diameter"]) / 2.0
        if new_radius <= 0:
            raise ValueError("Target slot diameter must be greater than 0.")

        part_id = self.face_part_ids[face_id]
        part = self.part_by_id(part_id)
        if part is None:
            raise ValueError(f"Unknown part id {part_id}")

        old_part_shape = part.shape
        source_shape = part.shape
        try:
            if plan["resize_mode"] == "shrink":
                filler = self._slot_sector_prism_tool(
                    face_id,
                    self._slot_fill_radius(plan),
                    float(plan["fill_start_parameter"]),
                    float(plan["fill_end_parameter"]),
                )
                fuse = BRepAlgoAPI_Fuse(part.shape, filler)
                source_shape = _finalize_boolean_result(fuse, "slot sector fill/fuse")

            cutter = self._slot_sector_prism_tool(
                face_id,
                new_radius,
                float(plan["cutter_start_parameter"]),
                float(plan["cutter_end_parameter"]),
            )
            op = BRepAlgoAPI_Cut(source_shape, cutter)
            result = _finalize_boolean_result(op, "slot sector cut")
            part.shape = result
            self.refresh_topology()
            verification = self._verify_cylindrical_resize_result(plan, part_id)
            if not verification["matched"]:
                raise RuntimeError(str(verification.get("detail", "slot sector result verification failed")))
        except Exception:
            part.shape = old_part_shape
            self.refresh_topology()
            raise

        action = "sector cut" if plan["resize_mode"] == "enlarge" else "sector fill and recut"
        return (
            "Cylindrical slot sector resize completed: "
            f"diameter {old_radius * 2.0:g} -> {float(plan['slot_target_diameter']):g}, "
            f"mode={plan['resize_mode']}, action={action}, "
            f"height={float(plan['cutter_height']):g}, "
            f"verified_face={verification.get('face_id', '')}."
        )

    def _slot_sector_prism_tool(
        self,
        face_id: int,
        radius: float,
        start_parameter: float,
        end_parameter: float,
        *,
        u_first_override: float | None = None,
        u_last_override: float | None = None,
        axis_point_offset: tuple[float, float, float] | None = None,
        u_padding: float | None = None,
    ) -> TopoDS_Shape:
        face = self.faces[face_id]
        surf = BRepAdaptor_Surface(face)
        if surf.GetType() != GeomAbs_Cylinder:
            raise ValueError("Slot sector tool requires a cylindrical face.")
        if radius <= 1e-9:
            raise ValueError("Slot sector tool radius must be greater than 0.")

        cyl = surf.Cylinder()
        axis = cyl.Axis()
        axis_point = axis.Location()
        direction = axis.Direction()
        tool_axis_point = axis_point
        if axis_point_offset is not None:
            tool_axis_point = gp_Pnt(
                axis_point.X() + float(axis_point_offset[0]),
                axis_point.Y() + float(axis_point_offset[1]),
                axis_point.Z() + float(axis_point_offset[2]),
            )
        u_first = float(surf.FirstUParameter()) if u_first_override is None else float(u_first_override)
        u_last = float(surf.LastUParameter()) if u_last_override is None else float(u_last_override)
        span = abs(u_last - u_first)
        if span <= 1e-6 or span >= math.tau * 0.98:
            raise ValueError("Slot sector tool requires a stable partial-cylinder U span.")
        if end_parameter < start_parameter:
            start_parameter, end_parameter = end_parameter, start_parameter
        height = max(float(end_parameter) - float(start_parameter), 1e-6)

        pad = (
            min(max(1e-4, 0.001 / max(float(radius), 1e-6)), max(span * 0.02, 1e-4))
            if u_padding is None
            else max(float(u_padding), 0.0)
        )
        if u_last >= u_first:
            u_start = u_first - pad
            u_end = u_last + pad
        else:
            u_start = u_first + pad
            u_end = u_last - pad
        v_mid = (float(surf.FirstVParameter()) + float(surf.LastVParameter())) / 2.0
        axis_start = _point_on_axis(tool_axis_point, direction, float(start_parameter))
        axis_start_tuple = _point_tuple(axis_start)

        def radial_point(u: float) -> tuple[float, float, float]:
            source = surf.Value(float(u), v_mid)
            source_parameter = _axis_parameter(axis_point, direction, source)
            source_axis = _point_on_axis(axis_point, direction, source_parameter)
            radial = _tuple_sub(_point_tuple(source), _point_tuple(source_axis))
            unit = _tuple_normalized(radial)
            if unit is None:
                raise ValueError("Could not derive slot sector radial direction.")
            return (
                axis_start_tuple[0] + unit[0] * float(radius),
                axis_start_tuple[1] + unit[1] * float(radius),
                axis_start_tuple[2] + unit[2] * float(radius),
            )

        height_vec = gp_Vec(direction.X() * height, direction.Y() * height, direction.Z() * height)
        try:
            start_tuple = radial_point(u_start)
            mid_tuple = radial_point((u_start + u_end) * 0.5)
            end_tuple = radial_point(u_end)
            center_point = gp_Pnt(*axis_start_tuple)
            start_point = gp_Pnt(*start_tuple)
            mid_point = gp_Pnt(*mid_tuple)
            end_point = gp_Pnt(*end_tuple)
            center_to_start = BRepBuilderAPI_MakeEdge(center_point, start_point).Edge()
            arc = GC_MakeArcOfCircle(start_point, mid_point, end_point).Value()
            arc_edge = BRepBuilderAPI_MakeEdge(arc).Edge()
            end_to_center = BRepBuilderAPI_MakeEdge(end_point, center_point).Edge()
            wire = BRepBuilderAPI_MakeWire(center_to_start, arc_edge, end_to_center).Wire()
            tool_face = _finalize_builder_result(BRepBuilderAPI_MakeFace(wire), "slot sector circular profile")
            return _finalize_builder_result(BRepPrimAPI_MakePrism(tool_face, height_vec), "slot sector prism")
        except Exception:
            # Fall back to the older sampled polygon path for unusual parameterizations.
            # The circular path is preferred because it preserves a real cylindrical
            # wall after Cut/Fuse; the fallback keeps the edit attempt available.
            pass

        sample_count = max(8, min(96, int(abs(u_end - u_start) / (math.pi / 36.0)) + 2))
        points: list[tuple[float, float, float]] = [axis_start_tuple]
        for index in range(sample_count):
            u = u_start + (u_end - u_start) * index / max(sample_count - 1, 1)
            points.append(radial_point(u))

        tool_face = self._make_local_polygon_face(points)
        return _finalize_builder_result(BRepPrimAPI_MakePrism(tool_face, height_vec), "slot sector prism")

    def move_cylindrical_slot_axis(
        self,
        face_id: int,
        target_center: tuple[float, float, float],
    ) -> str:
        plan = self.cylindrical_slot_axis_move_plan(face_id, target_center)
        if plan["status"] == "blocked":
            raise ValueError(str(plan["message"]))

        part_id = self.face_part_ids[face_id]
        part = self.part_by_id(part_id)
        if part is None:
            raise ValueError(f"Unknown part id {part_id}")

        old_part_shape = part.shape
        verification: dict[str, object] = {}
        artifact_cleanup: dict[str, object] = {"discarded_count": 0, "discarded_volume": 0.0}
        try:
            if str(plan.get("resize_strategy", "")) == "paired-obround-slot-axis-prism":
                filler = self._slot_capsule_prism_tool(plan, self._slot_fill_radius(plan))
                fuse = BRepAlgoAPI_Fuse(part.shape, filler)
                filled_shape = _finalize_boolean_result(fuse, "obround slot axis move fill/fuse", use_glue=False)

                target_plan = dict(plan)
                target_plan["slot_capsule_start_center_1"] = plan.get("slot_capsule_target_start_center_1")
                target_plan["slot_capsule_start_center_2"] = plan.get("slot_capsule_target_start_center_2")
                cutter = self._slot_capsule_prism_tool(target_plan, float(plan["slot_target_diameter"]) * 0.5)
                op = BRepAlgoAPI_Cut(filled_shape, cutter)
                result = _finalize_boolean_result(op, "obround slot axis move cut")
            else:
                filler = self._slot_sector_prism_tool(
                    face_id,
                    self._slot_fill_radius(plan),
                    float(plan["fill_start_parameter"]),
                    float(plan["fill_end_parameter"]),
                )
                fuse = BRepAlgoAPI_Fuse(part.shape, filler)
                filled_shape = _finalize_boolean_result(fuse, "slot axis move old-sector fill/fuse", use_glue=False)

                movement = _tuple_or_none(plan.get("axis_move_vector"))
                if movement is None:
                    raise ValueError("Could not derive slot axis movement vector.")
                cutter = self._slot_sector_prism_tool(
                    face_id,
                    float(plan["slot_target_diameter"]) * 0.5,
                    float(plan["cutter_start_parameter"]),
                    float(plan["cutter_end_parameter"]),
                    axis_point_offset=movement,
                )
                op = BRepAlgoAPI_Cut(filled_shape, cutter)
                result = _finalize_boolean_result(op, "slot axis move target-sector cut")
            result = _prepare_shape_for_step_export(result)
            before_solids = _topology_shape_count(old_part_shape, TopAbs_SOLID)
            after_solids = _topology_shape_count(result, TopAbs_SOLID)
            if before_solids == 1 and after_solids > 1:
                result, artifact_cleanup = self._drop_tiny_artifact_solids(result, old_part_shape)
                after_solids = _topology_shape_count(result, TopAbs_SOLID)
            if before_solids and after_solids != before_solids:
                raise RuntimeError(
                    "槽/半孔轴心移动结果改变了 Solid 数量，当前版本已回滚，"
                    "避免把一个实体拆成多个独立实体。请改用“轴心(缩放特征)”或槽孔总长度/槽宽等更稳定参数。"
                )
            part.shape = result
            self.refresh_topology()

            if str(plan.get("resize_strategy", "")) == "paired-obround-slot-axis-prism":
                verification = self._verify_obround_slot_axis_move_result(plan, part_id)
            else:
                verification_plan = dict(plan)
                verification_plan["cutter_axis_point"] = plan["target_cutter_axis_point"]
                verification_plan["cutter_start_point"] = plan["target_cutter_start_point"]
                verification = self._verify_slot_angular_span_result(verification_plan, part_id)
            if not verification["matched"]:
                detail = str(verification.get("detail", "slot axis move result verification failed"))
                raise RuntimeError(
                    "槽/半孔轴心坐标布尔计算返回了结果，但结果里没有检测到目标轴心位置的槽面，"
                    "已回滚到修改前状态。"
                    f"{detail}"
                )
        except Exception:
            part.shape = old_part_shape
            self.refresh_topology()
            raise

        return (
            "Cylindrical slot axis move completed: "
            f"face {face_id}, "
            f"center={plan.get('current_axis_center')}->{plan.get('target_axis_center')}, "
            f"move={plan.get('axis_move_vector')}, "
            f"diameter={float(plan['slot_target_diameter']):g}, "
            f"span={float(plan['slot_target_angular_span']):g}, "
            f"height={float(plan['cutter_height']):g}, "
            f"discarded_tiny_solids={int(artifact_cleanup.get('discarded_count', 0))}, "
            f"discarded_tiny_volume={float(artifact_cleanup.get('discarded_volume', 0.0)):g}, "
            f"risk={plan['risk']}, "
            f"verified_face={verification.get('face_id', '')}."
        )

    def resize_cylindrical_hole(self, face_id: int, new_diameter: float) -> str:
        plan = self.cylindrical_resize_plan(face_id, new_diameter)
        if plan["status"] == "blocked":
            raise ValueError(str(plan["message"]))

        face = self.faces[face_id]
        surf = BRepAdaptor_Surface(face)
        if surf.GetType() != GeomAbs_Cylinder:
            raise ValueError("Hole resize currently supports cylindrical faces only.")

        cyl = surf.Cylinder()
        old_radius = cyl.Radius()
        new_radius = new_diameter / 2.0
        if new_radius <= 0:
            raise ValueError("Target diameter must be greater than 0.")

        part_id = self.face_part_ids[face_id]
        part = self.part_by_id(part_id)
        if part is None:
            raise ValueError(f"Unknown part id {part_id}")

        direction = cyl.Axis().Direction()
        old_part_shape = part.shape
        source_shape = part.shape
        if plan["resize_mode"] == "shrink":
            fill_start = gp_Pnt(*plan["fill_start_point"])
            fill_axis = gp_Ax2(fill_start, gp_Dir(direction.X(), direction.Y(), direction.Z()))
            filler = BRepPrimAPI_MakeCylinder(
                fill_axis,
                float(plan["fill_radius"]),
                float(plan["fill_height"]),
            ).Shape()
            fuse = BRepAlgoAPI_Fuse(part.shape, filler)
            source_shape = _finalize_boolean_result(fuse, "cylinder fill/fuse", use_glue=False)

        cutter_start = gp_Pnt(*plan["cutter_start_point"])
        cutter_axis = gp_Ax2(cutter_start, gp_Dir(direction.X(), direction.Y(), direction.Z()))
        cutter = BRepPrimAPI_MakeCylinder(cutter_axis, new_radius, float(plan["cutter_height"])).Shape()

        op = BRepAlgoAPI_Cut(source_shape, cutter)
        result = _finalize_boolean_result(op, "cylinder cut")
        part.shape = result
        self.refresh_topology()
        verification = self._verify_cylindrical_resize_result(plan, part_id)
        if not verification["matched"]:
            part.shape = old_part_shape
            self.refresh_topology()
            detail = str(verification.get("detail", ""))
            raise RuntimeError(
                "孔/圆柱直径布尔计算返回了结果，但结果里没有检测到目标直径的圆柱面，"
                "已回滚到修改前状态。"
                f"{detail}"
            )
        action = "enlarged by bounded cut" if plan["resize_mode"] == "enlarge" else "shrunk by fill and recut"
        return (
            f"Cylindrical resize completed: diameter {old_radius * 2.0:g} -> {new_diameter:g}, "
            f"mode={plan['resize_mode']}, action={action}, "
            f"risk={plan['risk']}, feature={plan['feature_guess']}, "
            f"cutter={plan['cutter_strategy']}, height={float(plan['cutter_height']):g}, "
            f"verified_face={verification.get('face_id', '')}."
        )

    def move_cylindrical_hole_axis(
        self,
        face_id: int,
        target_center: tuple[float, float, float],
    ) -> str:
        plan = self.cylindrical_axis_move_plan(face_id, target_center)
        if plan["status"] == "blocked":
            raise ValueError(str(plan["message"]))

        part_id = self.face_part_ids[face_id]
        part = self.part_by_id(part_id)
        if part is None:
            raise ValueError(f"Unknown part id {part_id}")

        direction = gp_Dir(*plan["cutter_axis_direction"])
        old_part_shape = part.shape
        try:
            fill_start = gp_Pnt(*plan["fill_start_point"])
            fill_axis = gp_Ax2(fill_start, direction)
            filler = BRepPrimAPI_MakeCylinder(
                fill_axis,
                float(plan["fill_radius"]),
                float(plan["fill_height"]),
            ).Shape()
            fuse = BRepAlgoAPI_Fuse(part.shape, filler)
            filled_shape = _finalize_boolean_result(fuse, "cylinder axis move old-hole fill/fuse", use_glue=False)

            cutter_start = gp_Pnt(*plan["target_cutter_start_point"])
            cutter_axis = gp_Ax2(cutter_start, direction)
            cutter = BRepPrimAPI_MakeCylinder(
                cutter_axis,
                float(plan["target_radius"]),
                float(plan["cutter_height"]),
            ).Shape()
            op = BRepAlgoAPI_Cut(filled_shape, cutter)
            result = _finalize_boolean_result(op, "cylinder axis move target-hole cut")
            part.shape = result
            self.refresh_topology()

            verification_plan = dict(plan)
            verification_plan["cutter_axis_point"] = plan["target_cutter_axis_point"]
            verification_plan["cutter_start_point"] = plan["target_cutter_start_point"]
            verification = self._verify_cylindrical_resize_result(verification_plan, part_id)
            if not verification["matched"]:
                raise RuntimeError(str(verification.get("detail", "cylinder axis move result verification failed")))
        except Exception:
            part.shape = old_part_shape
            self.refresh_topology()
            raise

        return (
            "Cylindrical hole axis move completed: "
            f"face {face_id}, "
            f"center={plan.get('current_axis_center')}->{plan.get('target_axis_center')}, "
            f"move={plan.get('axis_move_vector')}, "
            f"diameter={float(plan['target_diameter']):g}, "
            f"height={float(plan['cutter_height']):g}, "
            f"risk={plan['risk']}, "
            f"verified_face={verification.get('face_id', '')}."
        )

    def _cylindrical_result_first_level_minimums(self, plan: dict[str, object] | None) -> dict[str, int]:
        if not isinstance(plan, dict):
            return {}

        span = (
            _float_or_none(plan.get("slot_angular_span"))
            or _float_or_none(plan.get("slot_target_angular_span"))
            or _float_or_none(plan.get("angular_span"))
        )
        is_partial = bool(
            str(plan.get("slot_kind") or "")
            or str(plan.get("slot_resize_mode") or "").startswith("slot")
            or (span is not None and span < math.tau * 0.92)
        )
        stable_floor = 4 if is_partial else 2
        minimums: dict[str, int] = {}
        count_keys = {
            "cylindrical_feature_boundary_edge_count": "boundary_edge_count",
            "cylindrical_feature_boundary_vertex_count": "boundary_vertex_count",
            "cylindrical_feature_adjacent_face_count": "adjacent_face_count",
        }
        for plan_key, summary_key in count_keys.items():
            value = _int_or_none(plan.get(plan_key))
            if value is None or value <= 0:
                continue
            minimums[summary_key] = max(1, min(int(value), stable_floor))
        return minimums

    def _attach_cylindrical_first_level_result_check(
        self,
        candidate: dict[str, object],
        plan: dict[str, object] | None = None,
    ) -> dict[str, object]:
        if not candidate.get("matched"):
            return candidate
        face_ids: list[int] = []
        for key in ("face_id", "paired_face_id"):
            face_id = _int_or_none(candidate.get(key))
            if face_id is not None and face_id not in face_ids:
                face_ids.append(face_id)
        if not face_ids:
            return {
                **candidate,
                "matched": False,
                "first_level_topology_matched": False,
                "detail": " Result verification matched geometry but did not identify a Face ID for first-level topology.",
            }

        summaries: list[dict[str, object]] = []
        for face_id in face_ids:
            try:
                topology = self.cylindrical_feature_first_level_topology(face_id)
                side_face_count = int(topology.get("cylindrical_feature_side_face_count", 0) or 0)
                boundary_edge_count = int(topology.get("cylindrical_feature_boundary_edge_count", 0) or 0)
                boundary_vertex_count = int(topology.get("cylindrical_feature_boundary_vertex_count", 0) or 0)
                adjacent_face_count = int(topology.get("cylindrical_feature_adjacent_face_count", 0) or 0)
                end_face_count = int(topology.get("cylindrical_feature_end_face_count", 0) or 0)
                bottom_face_count = int(topology.get("cylindrical_feature_bottom_face_count", 0) or 0)
                opening_face_count = int(topology.get("cylindrical_feature_opening_face_count", 0) or 0)
                slot_boundary_face_count = int(topology.get("cylindrical_feature_slot_boundary_face_count", 0) or 0)
            except Exception as exc:
                return {
                    **candidate,
                    "matched": False,
                    "first_level_topology_matched": False,
                    "detail": f" Result Face {face_id} matched target geometry but first-level topology failed: {exc}",
                }
            summaries.append(
                {
                    "face_id": face_id,
                    "side_face_count": side_face_count,
                    "boundary_edge_count": boundary_edge_count,
                    "boundary_vertex_count": boundary_vertex_count,
                    "adjacent_face_count": adjacent_face_count,
                    "end_face_count": end_face_count,
                    "bottom_face_count": bottom_face_count,
                    "opening_face_count": opening_face_count,
                    "slot_boundary_face_count": slot_boundary_face_count,
                }
            )
            if side_face_count <= 0 or boundary_edge_count <= 0 or adjacent_face_count <= 0:
                return {
                    **candidate,
                    "matched": False,
                    "first_level_topology_matched": False,
                    "first_level_topology_summaries": tuple(summaries),
                    "detail": (
                        f" Result Face {face_id} matched target geometry but lost first-level topology "
                        f"(side={side_face_count}, boundary_edges={boundary_edge_count}, "
                        f"adjacent_faces={adjacent_face_count})."
                    ),
                }
            minimums = self._cylindrical_result_first_level_minimums(plan)
            under_minimum: list[str] = []
            summary_values = summaries[-1]
            for key, minimum in minimums.items():
                actual = int(summary_values.get(key, 0) or 0)
                if actual < minimum:
                    under_minimum.append(f"{key}={actual} < {minimum}")
            if under_minimum:
                return {
                    **candidate,
                    "matched": False,
                    "first_level_topology_matched": False,
                    "first_level_topology_summaries": tuple(summaries),
                    "first_level_topology_minimums": dict(minimums),
                    "detail": (
                        f" Result Face {face_id} matched target geometry but its first-level topology is weaker "
                        f"than the edit plan requires ({'; '.join(under_minimum)})."
                    ),
                }

        return {
            **candidate,
            "first_level_topology_matched": True,
            "first_level_topology_summaries": tuple(summaries),
            "first_level_topology_minimums": self._cylindrical_result_first_level_minimums(plan),
        }

    def _verify_cylindrical_resize_result(self, plan: dict[str, object], part_id: int) -> dict[str, object]:
        target_diameter = float(plan.get("target_diameter", 0.0))
        target_radius = target_diameter / 2.0
        if target_radius <= 1e-9:
            return {"matched": False, "detail": " 目标直径无效。"}
        try:
            axis_point = gp_Pnt(*plan["cutter_axis_point"])
            axis_direction = gp_Dir(*plan["cutter_axis_direction"])
        except Exception:
            return {"matched": False, "detail": " 缺少原孔轴信息，无法确认结果。"}

        part = self.part_by_id(part_id)
        diagonal = max(_shape_diagonal(part.shape) if part is not None else 0.0, target_radius, 1.0)
        radius_tolerance = max(target_radius * 0.02, diagonal * 1e-6, 1e-5)
        axis_tolerance = max(target_radius * 0.08, diagonal * 1e-5, 1e-4)
        best: dict[str, object] | None = None
        best_score = math.inf

        for face_id, face in enumerate(self.faces):
            if self.face_part_ids[face_id] != part_id:
                continue
            try:
                surf = BRepAdaptor_Surface(face)
                if surf.GetType() != GeomAbs_Cylinder:
                    continue
                cyl = surf.Cylinder()
                candidate_radius = float(cyl.Radius())
                radius_error = abs(candidate_radius - target_radius)
                axis_dot = abs(_direction_dot(axis_direction, cyl.Axis().Direction()))
                if axis_dot < 1.0 - 1e-5:
                    continue
                axis_distance = _point_axis_distance(axis_point, axis_direction, cyl.Axis().Location())
            except Exception:
                continue

            score = radius_error / max(radius_tolerance, 1e-9) + axis_distance / max(axis_tolerance, 1e-9)
            candidate = {
                "matched": radius_error <= radius_tolerance and axis_distance <= axis_tolerance,
                "face_id": face_id,
                "diameter": candidate_radius * 2.0,
                "radius_error": radius_error,
                "axis_distance": axis_distance,
                "radius_tolerance": radius_tolerance,
                "axis_tolerance": axis_tolerance,
            }
            if candidate["matched"]:
                return self._attach_cylindrical_first_level_result_check(candidate, plan)
            if score < best_score:
                best_score = score
                best = candidate

        if best is None:
            return {"matched": False, "detail": " 未找到同零件内与原孔轴平行的圆柱面。"}
        return {
            "matched": False,
            "detail": (
                f" 最近候选 Face {best['face_id']} 的直径约 {float(best['diameter']):.6g}，"
                f"目标直径 {target_diameter:.6g}，"
                f"半径误差 {float(best['radius_error']):.6g}，"
                f"轴距 {float(best['axis_distance']):.6g}。"
            ),
            **best,
        }

    def _verify_cylindrical_height_result(self, plan: dict[str, object], part_id: int) -> dict[str, object]:
        target_height = _float_or_none(plan.get("target_height"))
        target_radius = _float_or_none(plan.get("radius"))
        diameter = _float_or_none(plan.get("diameter"))
        if target_radius is None and diameter is not None:
            target_radius = diameter * 0.5
        axis_direction_tuple = _tuple_normalized(
            _tuple_or_none(plan.get("axis")) or _tuple_or_none(plan.get("affine_axis_direction"))
        )
        axis_point_tuple = (
            _tuple_or_none(plan.get("axis_point"))
            or _tuple_or_none(plan.get("affine_axis_point"))
            or _tuple_or_none(plan.get("scale_center"))
        )
        if (
            target_height is None
            or target_height <= 1e-9
            or target_radius is None
            or target_radius <= 1e-9
            or axis_direction_tuple is None
            or axis_point_tuple is None
        ):
            return {"matched": False, "detail": " Missing cylindrical height verification data."}

        target_axis_direction = gp_Dir(*axis_direction_tuple)
        target_axis_point = gp_Pnt(*axis_point_tuple)
        part = self.part_by_id(part_id)
        diagonal = max(_shape_diagonal(part.shape) if part is not None else 0.0, target_height, target_radius, 1.0)
        height_tolerance = max(target_height * 0.005, diagonal * 1e-5, 1e-4)
        radius_tolerance = max(target_radius * 0.02, diagonal * 1e-6, 1e-5)
        axis_tolerance = max(target_radius * 0.08, diagonal * 1e-5, 1e-4)
        best: dict[str, object] | None = None
        best_score = math.inf

        for candidate_face_id, face in enumerate(self.faces):
            if self.face_part_ids[candidate_face_id] != part_id:
                continue
            try:
                surf = BRepAdaptor_Surface(face)
                if surf.GetType() != GeomAbs_Cylinder:
                    continue
                cyl = surf.Cylinder()
                candidate_radius = float(cyl.Radius())
                radius_error = abs(candidate_radius - target_radius)
                axis_dot = abs(_direction_dot(target_axis_direction, cyl.Axis().Direction()))
                if axis_dot < 1.0 - 1e-5:
                    continue
                axis_distance = _point_axis_distance(target_axis_point, target_axis_direction, cyl.Axis().Location())
                if axis_distance > axis_tolerance:
                    continue
                try:
                    feature = self.feature_info(candidate_face_id)
                except Exception:
                    feature = {}
                axis_range = self._cylindrical_axis_range(
                    candidate_face_id,
                    surf,
                    _int_values(feature.get("feature_side_face_ids")),
                )
                candidate_height = float(axis_range.get("span", 0.0))
                height_error = abs(candidate_height - target_height)
            except Exception:
                continue

            score = (
                height_error / max(height_tolerance, 1e-9)
                + radius_error / max(radius_tolerance, 1e-9)
                + axis_distance / max(axis_tolerance, 1e-9)
            )
            candidate = {
                "matched": (
                    height_error <= height_tolerance
                    and radius_error <= radius_tolerance
                    and axis_distance <= axis_tolerance
                ),
                "face_id": candidate_face_id,
                "height": candidate_height,
                "target_height": target_height,
                "height_error": height_error,
                "height_tolerance": height_tolerance,
                "radius": candidate_radius,
                "target_radius": target_radius,
                "radius_error": radius_error,
                "radius_tolerance": radius_tolerance,
                "axis_distance": axis_distance,
                "axis_tolerance": axis_tolerance,
            }
            if candidate["matched"]:
                return self._attach_cylindrical_first_level_result_check(candidate, plan)
            if score < best_score:
                best_score = score
                best = candidate

        if best is None:
            return {"matched": False, "detail": " No same-axis cylindrical Face was found after height edit."}
        return {
            "matched": False,
            "detail": (
                f" Closest cylindrical Face {best['face_id']} height {float(best['height']):.6g}, "
                f"target height {target_height:.6g}, height error {float(best['height_error']):.6g}, "
                f"radius {float(best['radius']):.6g}, target radius {target_radius:.6g}, "
                f"axis distance {float(best['axis_distance']):.6g}."
            ),
            **best,
        }

    def _verify_axis_height_span_result(self, plan: dict[str, object], part_id: int) -> dict[str, object]:
        target_height = _float_or_none(plan.get("target_height"))
        axis_direction_tuple = _tuple_normalized(
            _tuple_or_none(plan.get("affine_axis_direction")) or _tuple_or_none(plan.get("axis"))
        )
        axis_point_tuple = (
            _tuple_or_none(plan.get("affine_axis_point"))
            or _tuple_or_none(plan.get("scale_center"))
            or _tuple_or_none(plan.get("axis_point"))
        )
        if target_height is None or target_height <= 1e-9 or axis_direction_tuple is None or axis_point_tuple is None:
            return {"matched": False, "detail": " Missing axis span verification data."}

        shape: TopoDS_Shape | None = None
        target_kind = str(plan.get("affine_target_kind") or plan.get("target_kind") or "part")
        solid_id = _int_or_none(plan.get("solid_id"))
        if (
            target_kind == "solid"
            and solid_id is not None
            and 0 <= solid_id < len(self.solids)
            and int(self.solids[solid_id][0]) == int(part_id)
        ):
            shape = self.solids[solid_id][1]
        if shape is None:
            part = self.part_by_id(part_id)
            shape = part.shape if part is not None else None
        if shape is None:
            return {"matched": False, "detail": " Could not find edited part or solid for axis span verification."}

        axis_point = gp_Pnt(*axis_point_tuple)
        axis_direction = gp_Dir(*axis_direction_tuple)
        try:
            axis_interval = _shape_axis_interval(shape, axis_point, axis_direction)
        except Exception as exc:
            return {"matched": False, "detail": f" Could not measure edited axis span: {exc}"}
        actual_height = max(float(axis_interval[1]) - float(axis_interval[0]), 0.0)
        diagonal = max(_shape_diagonal(shape), target_height, 1.0)
        tolerance = max(target_height * 0.005, diagonal * 1e-5, 1e-4)
        error = abs(actual_height - target_height)
        return {
            "matched": error <= tolerance,
            "face_id": _int_or_none(plan.get("face_id")),
            "axis_span": actual_height,
            "target_height": target_height,
            "height_error": error,
            "height_tolerance": tolerance,
            "axis_interval": axis_interval,
            "target_kind": target_kind,
            "detail": (
                f" Axis span {actual_height:.6g}, target height {target_height:.6g}, "
                f"height error {error:.6g}."
            ),
        }

    def _verify_cylindrical_depth_result(self, plan: dict[str, object], part_id: int) -> dict[str, object]:
        target_depth = _float_or_none(plan.get("target_depth"))
        target_diameter = _float_or_none(plan.get("diameter") or plan.get("target_diameter"))
        axis_direction_tuple = _tuple_normalized(_tuple_or_none(plan.get("depth_axis_direction")))
        open_point_tuple = _tuple_or_none(plan.get("depth_open_point"))
        if (
            target_depth is None
            or target_depth <= 1e-9
            or target_diameter is None
            or target_diameter <= 1e-9
            or axis_direction_tuple is None
            or open_point_tuple is None
        ):
            return {"matched": False, "detail": " Missing blind-depth verification data."}

        target_radius = target_diameter * 0.5
        target_axis_direction = gp_Dir(*axis_direction_tuple)
        target_open_point = gp_Pnt(*open_point_tuple)
        part = self.part_by_id(part_id)
        diagonal = max(_shape_diagonal(part.shape) if part is not None else 0.0, target_depth, target_radius, 1.0)
        radius_tolerance = max(target_radius * 0.03, diagonal * 1e-6, 1e-5)
        axis_tolerance = max(target_radius * 0.08, diagonal * 1e-5, 1e-4)
        depth_tolerance = max(target_depth * 0.03, diagonal * 1e-5, 1e-4)
        best: dict[str, object] | None = None
        best_score = math.inf

        for candidate_face_id, face in enumerate(self.faces):
            if self.face_part_ids[candidate_face_id] != part_id:
                continue
            try:
                surf = BRepAdaptor_Surface(face)
                if surf.GetType() != GeomAbs_Cylinder:
                    continue
                cyl = surf.Cylinder()
                candidate_radius = float(cyl.Radius())
                radius_error = abs(candidate_radius - target_radius)
                axis_dot = abs(_direction_dot(target_axis_direction, cyl.Axis().Direction()))
                if axis_dot < 1.0 - 1e-5:
                    continue
                axis_distance = _point_axis_distance(cyl.Axis().Location(), cyl.Axis().Direction(), target_open_point)
                if axis_distance > axis_tolerance:
                    continue
                feature = self.feature_info(candidate_face_id)
                bottom_face_ids = tuple(feature.get("feature_bottom_face_ids", ()) or ())
                if not bottom_face_ids:
                    continue
                depth_plan = self.cylindrical_depth_plan(
                    candidate_face_id,
                    target_depth,
                    bottom_face_id=int(bottom_face_ids[0]),
                )
                candidate_depth = _float_or_none(depth_plan.get("current_depth"))
                if candidate_depth is None or candidate_depth <= 1e-9:
                    continue
                depth_error = abs(candidate_depth - target_depth)
            except Exception:
                continue

            score = (
                radius_error / max(radius_tolerance, 1e-9)
                + axis_distance / max(axis_tolerance, 1e-9)
                + depth_error / max(depth_tolerance, 1e-9)
            )
            candidate = {
                "matched": (
                    radius_error <= radius_tolerance
                    and axis_distance <= axis_tolerance
                    and depth_error <= depth_tolerance
                ),
                "face_id": candidate_face_id,
                "depth": candidate_depth,
                "target_depth": target_depth,
                "depth_error": depth_error,
                "depth_tolerance": depth_tolerance,
                "diameter": candidate_radius * 2.0,
                "radius_error": radius_error,
                "axis_distance": axis_distance,
                "radius_tolerance": radius_tolerance,
                "axis_tolerance": axis_tolerance,
            }
            if candidate["matched"]:
                return self._attach_cylindrical_first_level_result_check(candidate, plan)
            if score < best_score:
                best_score = score
                best = candidate

        if best is None:
            return {"matched": False, "detail": " No measurable blind cylindrical feature remained after depth edit."}
        return {
            "matched": False,
            "detail": (
                f" Closest blind cylindrical Face {best['face_id']} depth {float(best['depth']):.6g}, "
                f"target {target_depth:.6g}, depth error {float(best['depth_error']):.6g}, "
                f"diameter {float(best['diameter']):.6g}."
            ),
            **best,
        }

    def _verify_cylindrical_suppress_result(self, plan: dict[str, object], part_id: int) -> dict[str, object]:
        target_radius = _float_or_none(plan.get("radius"))
        if target_radius is None:
            target_diameter = _float_or_none(plan.get("diameter"))
            target_radius = target_diameter * 0.5 if target_diameter is not None else None
        axis_point_tuple = _tuple_or_none(plan.get("axis_point"))
        axis_direction_tuple = _tuple_normalized(_tuple_or_none(plan.get("axis")))
        fill_start_tuple = _tuple_or_none(plan.get("fill_start_point"))
        fill_height = _float_or_none(plan.get("fill_height"))
        if (
            target_radius is None
            or target_radius <= 1e-9
            or axis_point_tuple is None
            or axis_direction_tuple is None
            or fill_start_tuple is None
            or fill_height is None
            or fill_height <= 1e-9
        ):
            return {"matched": False, "detail": " Missing cylindrical suppress verification data."}

        axis_point = gp_Pnt(*axis_point_tuple)
        axis_direction = gp_Dir(*axis_direction_tuple)
        fill_start = gp_Pnt(*fill_start_tuple)
        fill_start_parameter = _axis_parameter(axis_point, axis_direction, fill_start)
        fill_min = min(fill_start_parameter, fill_start_parameter + fill_height)
        fill_max = max(fill_start_parameter, fill_start_parameter + fill_height)

        part = self.part_by_id(part_id)
        diagonal = max(_shape_diagonal(part.shape) if part is not None else 0.0, target_radius, fill_height, 1.0)
        radius_tolerance = max(target_radius * 0.03, diagonal * 1e-6, 1e-5)
        axis_tolerance = max(target_radius * 0.08, diagonal * 1e-5, 1e-4)
        overlap_tolerance = max(fill_height * 0.05, diagonal * 1e-5, 1e-4)
        remaining: list[dict[str, object]] = []

        for face_id, face in enumerate(self.faces):
            if self.face_part_ids[face_id] != part_id:
                continue
            try:
                surf = BRepAdaptor_Surface(face)
                if surf.GetType() != GeomAbs_Cylinder:
                    continue
                cyl = surf.Cylinder()
                candidate_radius = float(cyl.Radius())
                radius_error = abs(candidate_radius - target_radius)
                if radius_error > radius_tolerance:
                    continue
                axis_dot = abs(_direction_dot(axis_direction, cyl.Axis().Direction()))
                if axis_dot < 1.0 - 1e-5:
                    continue
                axis_distance = _point_axis_distance(axis_point, axis_direction, cyl.Axis().Location())
                if axis_distance > axis_tolerance:
                    continue
                axis_range = self._cylindrical_axis_range(face_id, surf)
                candidate_start = _point_on_axis(cyl.Axis().Location(), cyl.Axis().Direction(), float(axis_range["v_min"]))
                candidate_end = _point_on_axis(cyl.Axis().Location(), cyl.Axis().Direction(), float(axis_range["v_max"]))
                candidate_min = min(
                    _axis_parameter(axis_point, axis_direction, candidate_start),
                    _axis_parameter(axis_point, axis_direction, candidate_end),
                )
                candidate_max = max(
                    _axis_parameter(axis_point, axis_direction, candidate_start),
                    _axis_parameter(axis_point, axis_direction, candidate_end),
                )
                overlap = max(0.0, min(fill_max, candidate_max) - max(fill_min, candidate_min))
                if overlap <= overlap_tolerance:
                    continue
                feature_guess = str(self.face_info(face_id).get("feature_guess") or "")
            except Exception:
                continue
            remaining.append(
                {
                    "face_id": face_id,
                    "diameter": candidate_radius * 2.0,
                    "radius_error": radius_error,
                    "axis_distance": axis_distance,
                    "axis_overlap": overlap,
                    "feature_guess": feature_guess,
                }
            )

        if remaining:
            first = remaining[0]
            return {
                "matched": False,
                "suppressed": False,
                "remaining_face_ids": tuple(int(item["face_id"]) for item in remaining),
                "remaining_count": len(remaining),
                "detail": (
                    f" Suppress result still contains {len(remaining)} same-axis cylindrical Face(s) "
                    f"in the filled range; first Face {first['face_id']} diameter {float(first['diameter']):.6g}, "
                    f"axis overlap {float(first['axis_overlap']):.6g}."
                ),
            }
        return {
            "matched": True,
            "suppressed": True,
            "remaining_face_ids": (),
            "remaining_count": 0,
        }

    def resize_cylindrical_boss(self, face_id: int, new_diameter: float) -> str:
        plan = self.cylindrical_boss_resize_plan(face_id, new_diameter)
        if plan["status"] == "blocked":
            raise ValueError(str(plan["message"]))

        part_id = self.face_part_ids[face_id]
        part = self.part_by_id(part_id)
        if part is None:
            raise ValueError(f"Unknown part id {part_id}")

        start = gp_Pnt(*plan["boss_tool_start_point"])
        direction = gp_Dir(*plan["boss_tool_axis_direction"])
        axis = gp_Ax2(start, direction)
        height = float(plan["boss_tool_height"])
        if plan["resize_mode"] == "enlarge":
            tool = BRepPrimAPI_MakeCylinder(axis, float(plan["boss_tool_radius"]), height).Shape()
            op = BRepAlgoAPI_Fuse(part.shape, tool)
            result = _finalize_boolean_result(op, "cylindrical boss fuse", use_glue=False)
            action = "enlarged by bounded fuse"
        else:
            removal = BRepPrimAPI_MakeCylinder(axis, float(plan["boss_tool_outer_radius"]), height).Shape()
            replacement = BRepPrimAPI_MakeCylinder(axis, float(plan["boss_tool_inner_radius"]), height).Shape()
            remove_op = BRepAlgoAPI_Cut(part.shape, removal)
            removed = _finalize_boolean_result(remove_op, "cylindrical boss shrink remove envelope", use_glue=False)
            if _topology_shape_count(removed, TopAbs_FACE) == 0:
                exact_start = gp_Pnt(*plan["boss_tool_exact_start_point"])
                exact_axis = gp_Ax2(exact_start, direction)
                exact_replacement = BRepPrimAPI_MakeCylinder(
                    exact_axis,
                    float(plan["boss_tool_inner_radius"]),
                    float(plan["boss_tool_exact_height"]),
                ).Shape()
                result = _ensure_valid_or_repaired_shape(exact_replacement, "cylindrical boss shrink replacement")
            else:
                fuse_op = BRepAlgoAPI_Fuse(removed, replacement)
                result = _finalize_boolean_result(fuse_op, "cylindrical boss shrink rebuild", use_glue=False)
            action = "shrunk by removing old envelope and fusing target cylinder"

        part.shape = result
        self.refresh_topology()
        return (
            f"Cylindrical boss resize completed: diameter {float(plan['current_diameter']):g} -> {new_diameter:g}, "
            f"mode={plan['resize_mode']}, action={action}, risk={plan['risk']}, "
            f"feature={plan['feature_guess']}, tool={plan['boss_tool_strategy']}, "
            f"height={float(plan['boss_tool_height']):g}."
        )

    def move_cylindrical_boss_axis(
        self,
        face_id: int,
        target_center: tuple[float, float, float],
    ) -> str:
        plan = self.cylindrical_boss_axis_move_plan(face_id, target_center)
        if plan["status"] == "blocked":
            raise ValueError(str(plan["message"]))

        part_id = self.face_part_ids[face_id]
        part = self.part_by_id(part_id)
        if part is None:
            raise ValueError(f"Unknown part id {part_id}")

        old_part_shape = part.shape
        verification: dict[str, object] = {}
        try:
            direction = gp_Dir(*plan["boss_tool_axis_direction"])
            height = float(plan["boss_tool_height"])
            removal_start = gp_Pnt(*plan["boss_tool_start_point"])
            removal_axis = gp_Ax2(removal_start, direction)
            removal_radius = float(
                plan.get("boss_tool_outer_radius")
                or plan.get("boss_tool_old_radius")
                or plan.get("target_radius")
            )
            removal = BRepPrimAPI_MakeCylinder(removal_axis, removal_radius, height).Shape()
            remove_op = BRepAlgoAPI_Cut(part.shape, removal)
            removed = _finalize_boolean_result(remove_op, "cylindrical boss axis move remove old envelope", use_glue=False)

            target_start_values = _tuple_or_none(plan.get("target_boss_tool_start_point"))
            target_height = height
            if _topology_shape_count(removed, TopAbs_FACE) == 0:
                exact_start = _tuple_or_none(plan.get("target_boss_tool_exact_start_point"))
                if exact_start is not None:
                    target_start_values = exact_start
                    target_height = float(plan.get("boss_tool_exact_height") or height)
            if target_start_values is None:
                raise ValueError("Could not derive target boss tool start point.")

            target_start = gp_Pnt(*target_start_values)
            target_axis = gp_Ax2(target_start, direction)
            replacement = BRepPrimAPI_MakeCylinder(
                target_axis,
                float(plan["target_boss_tool_radius"]),
                max(target_height, 1e-6),
            ).Shape()
            if _topology_shape_count(removed, TopAbs_FACE) == 0:
                result = _ensure_valid_or_repaired_shape(replacement, "cylindrical boss axis move replacement")
                action = "rebuilt moved cylinder"
            else:
                fuse_op = BRepAlgoAPI_Fuse(removed, replacement)
                result = _finalize_boolean_result(fuse_op, "cylindrical boss axis move fuse target cylinder", use_glue=False)
                action = "removed old envelope and fused moved cylinder"

            part.shape = result
            self.refresh_topology()

            verification_plan = dict(plan)
            verification_plan["cutter_axis_point"] = plan["target_boss_tool_axis_point"]
            verification_plan["cutter_axis_direction"] = plan["boss_tool_axis_direction"]
            verification = self._verify_cylindrical_resize_result(verification_plan, part_id)
            if not verification["matched"]:
                detail = str(verification.get("detail", "cylindrical boss axis move result verification failed"))
                raise RuntimeError(
                    "圆柱凸台轴心坐标布尔计算返回了结果，但结果里没有检测到目标轴心位置的圆柱凸台，"
                    "已回滚到修改前状态。"
                    f"{detail}"
                )
        except Exception:
            part.shape = old_part_shape
            self.refresh_topology()
            raise

        return (
            "Cylindrical boss axis move completed: "
            f"face {face_id}, "
            f"center={plan.get('current_axis_center')}->{plan.get('target_axis_center')}, "
            f"move={plan.get('axis_move_vector')}, "
            f"diameter={float(plan['target_diameter']):g}, "
            f"height={float(plan['boss_tool_height']):g}, "
            f"risk={plan['risk']}, action={action}, "
            f"verified_face={verification.get('face_id', '')}."
        )

    def suppress_cylindrical_hole(self, face_id: int) -> str:
        plan = self.cylindrical_suppress_plan(face_id)
        if plan["status"] == "blocked":
            raise ValueError(str(plan["message"]))

        part_id = self.face_part_ids[face_id]
        part = self.part_by_id(part_id)
        if part is None:
            raise ValueError(f"Unknown part id {part_id}")

        face = self.faces[face_id]
        surf = BRepAdaptor_Surface(face)
        if surf.GetType() != GeomAbs_Cylinder:
            raise ValueError("Cylinder suppress currently supports cylindrical faces only.")

        direction = surf.Cylinder().Axis().Direction()
        fill_start = gp_Pnt(*plan["fill_start_point"])
        fill_axis = gp_Ax2(fill_start, gp_Dir(direction.X(), direction.Y(), direction.Z()))
        filler = BRepPrimAPI_MakeCylinder(
            fill_axis,
            float(plan["fill_radius"]),
            float(plan["fill_height"]),
        ).Shape()
        fuse = BRepAlgoAPI_Fuse(part.shape, filler)
        result = _finalize_boolean_result(fuse, "cylinder suppress/fill", use_glue=False)
        part.shape = result
        self.refresh_topology()
        return (
            f"Cylindrical hole suppress completed: face {face_id}, "
            f"diameter={float(plan['diameter']):g}, "
            f"height={float(plan['fill_height']):g}, "
            f"risk={plan['risk']}, feature={plan['feature_guess']}."
        )

    def resize_cylindrical_depth(
        self,
        face_id: int,
        target_depth: float,
        bottom_face_id: int | None = None,
    ) -> str:
        plan = self.cylindrical_depth_plan(
            face_id,
            target_depth,
            bottom_face_id=bottom_face_id,
        )
        if plan["status"] == "blocked":
            raise ValueError(str(plan["message"]))

        part_id = self.face_part_ids[face_id]
        part = self.part_by_id(part_id)
        if part is None:
            raise ValueError(f"Unknown part id {part_id}")

        old_part_shape = part.shape
        verification: dict[str, object] = {}
        try:
            start = gp_Pnt(*plan["depth_tool_start_point"])
            direction = gp_Dir(*plan["depth_axis_direction"])
            axis = gp_Ax2(start, direction)
            tool = BRepPrimAPI_MakeCylinder(
                axis,
                float(plan["depth_tool_radius"]),
                float(plan["depth_tool_height"]),
            ).Shape()
            if plan["depth_mode"] == "deepen":
                op = BRepAlgoAPI_Cut(part.shape, tool)
                result = _finalize_boolean_result(op, "blind depth cut")
                action = "deepened by bounded cut"
            else:
                op = BRepAlgoAPI_Fuse(part.shape, tool)
                result = _finalize_boolean_result(op, "blind depth fill/fuse", use_glue=False)
                action = "made shallower by bounded fill"

            part.shape = result
            self.refresh_topology()
            verification = self._verify_cylindrical_depth_result(plan, part_id)
            if not verification["matched"]:
                detail = str(verification.get("detail", "blind depth result verification failed"))
                raise RuntimeError(
                    "盲孔/盲槽深度布尔计算返回了结果，但没有检测到达到目标深度且保留一级关系的圆柱特征，"
                    "已回滚到修改前状态。"
                    f"{detail}"
                )
        except Exception:
            part.shape = old_part_shape
            self.refresh_topology()
            raise
        return (
            f"Blind cylindrical depth completed: depth {float(plan['current_depth']):g} -> {target_depth:g}, "
            f"mode={plan['depth_mode']}, action={action}, "
            f"risk={plan['risk']}, feature={plan['feature_guess']}, "
            f"tool={plan['depth_tool_strategy']}, height={float(plan['depth_tool_height']):g}, "
            f"verified_face={verification.get('face_id', '')}."
        )