解决合并冲突

2026-09-08 13:58:58 +08:00
parent 673ae62e70 c0475c5df5
commit 235d3bf0c8
28 changed files with 5529 additions and 336 deletions
@@ -20,13 +20,13 @@ from .sketch_solver import CORE_SHAPE_GENERATORS, resolve_required_sketches


 ALL_ATOMIC_IDS = frozenset({
-    "extrude_add_blind", "extrude_add_two_sided", "extrude_cut_blind", "extrude_cut_two_sided",
-    "extrude_cut_through", "loft_add",
-    "revolve_add", "revolve_cut", "hole_blind", "hole_countersink",
+    "extrude_add_blind", "extrude_add_blind_with_hole", "extrude_add_two_sided", "extrude_cut_blind", "extrude_cut_two_sided", "extrude_surface",
+    "extrude_cut_through", "loft_add", "loft_add_with_cap_face", "sweep_add",
+    "revolve_add", "revolve_cut", "revolve_surface", "hole_blind", "hole_countersink",
    "hole_counterbore", "sphere_add", "box_add", "cylinder_add",
    "reference_plane", "reference_axis",
-    "hole_wizard", "fillet", "chamfer", "pattern_linear", "pattern_mirror",
-    "pattern_circular",
+    "hole_wizard", "fillet", "chamfer", "shell", "pattern_linear", "pattern_mirror",
+    "pattern_circular", "boolean_bodies",
    "thread_add", "thread_cut",
    "bend_add",
    "gear_add", "rack_add",
@@ -83,12 +83,24 @@ class GeometryAdapter(Protocol):
    def topology_records(self, body: Any, feature_id: str, body_id: str) -> list[TopologyRecord]: ...
    def body_solids(self, body: Any) -> list[Any]: ...
    def body_geometry(self, body: Any) -> dict[str, Any]: ...
+    def surface_geometry(self, surface: Any) -> dict[str, Any]: ...
    def faces_for_sketch(self, sketch: dict[str, Any]) -> list[Any]: ...
+    def face_with_holes(self, outer: Any, holes: list[Any]) -> Any: ...
    def loft(self, sketches: list[dict[str, Any]]) -> Any: ...
+    def loft_with_cap_face(self, cap_face: Any, sketches: list[dict[str, Any]]) -> Any: ...
+    def sweep(self, section: Any, spine: Any, *, inner_wires: list[Any] | None = None, make_solid: bool = True, is_frenet: bool = False, transition: Any = None) -> Any: ...
+    def sweep_path(self, points: list[Vector3], *, start_tangent: Vector3 | None = None, end_tangent: Vector3 | None = None, parameters: list[float] | None = None) -> Any: ...
    def extrude(self, face: Any, direction: Vector3) -> Any: ...
+    def extrude_taper(self, face: Any, direction: Vector3, taper_deg: float) -> Any: ...
    def extrude_trimmed(self, face: Any, target: Any, direction: Vector3) -> Any: ...
+    def surface_wires_for_sketch(self, sketch: dict[str, Any]) -> list[Any]: ...
+    def extrude_surface(self, wires: list[Any], direction: Vector3) -> Any: ...
+    def combine_surfaces(self, *surfaces: Any) -> Any: ...
    def revolve(self, face: Any, angle_deg: float, axis: AxisSpec) -> Any: ...
+    def revolve_surface(self, wire: Any, angle_deg: float, axis: AxisSpec) -> Any: ...
+    def intersect(self, left: Any, right: Any) -> Any: ...
    def fuse(self, body: Any | None, solid: Any) -> Any: ...
+    def combine(self, body: Any | None, solid: Any) -> Any: ...
    def cut(self, body: Any, tool: Any) -> Any: ...
    def sphere(self, radius_mm: float, center_mm: Vector3) -> Any: ...
    def thread_solid(self, spec: ThreadSpec) -> Any: ...
@@ -99,11 +111,16 @@ class GeometryAdapter(Protocol):
    def body_center(self, body: Any) -> Vector3: ...
    def body_span(self, body: Any, direction: Vector3) -> float: ...
    def vertex_coordinates(self, vertex: Any) -> Vector3: ...
+    def intersection_vertex(self, body: Any, face_sets: list[list[Any]]) -> Any: ...
    def profile_sample_points(self, face: Any) -> list[Any]: ...
+    def profile_touches_target(self, target: Any, faces: list[Any]) -> bool: ...
+    def next_body_face_after(self, body: Any, faces: list[Any], direction: Vector3, *, excluded_face: Any) -> Any: ...
    def uniform_intersection_distance(self, target: Any, faces: list[Any], direction: Vector3) -> float: ...
    def fillet(self, body: Any, radius_mm: float, edges: list[Any]) -> Any: ...
    def tangent_edges(self, body: Any, seeds: list[Any]) -> list[Any]: ...
    def chamfer(self, body: Any, distance_mm: float, distance_2_mm: float | None, edges: list[Any], face: Any | None = None) -> Any: ...
+    def surface_limited_chamfer(self, body: Any, distance_mm: float, edges: list[Any], surfaces: list[Any]) -> Any: ...
+    def shell(self, body: Any, faces: list[Any], thickness_mm: float, *, inward: bool = True) -> Any: ...
    def export(self, body: Any, path: str) -> None: ...


@@ -117,27 +134,39 @@ class ExecutionSession:
    body_id: str | None = None
    results: dict[str, FeatureResult] = field(default_factory=dict)
    replay_definitions: dict[str, FeaturePlanNode] = field(default_factory=dict)
+    body_members: dict[str, Any] = field(default_factory=dict)
+    surface_members: dict[str, Any] = field(default_factory=dict)
    selector_resolutions: list[dict[str, Any]] = field(default_factory=list)
    active_feature_id: str = ""

-    def register_body(self, feature_id: str, body: Any, *, replay_node: FeaturePlanNode | None = None) -> None:
+    def register_body(
+        self,
+        feature_id: str,
+        body: Any,
+        *,
+        replay_node: FeaturePlanNode | None = None,
+        body_members: dict[str, Any] | None = None,
+    ) -> None:
        # #7 multi-body：主体可能是 Compound（多个独立实体，例如两个不相交的
        # 拉伸）。body_id 现在反映真实实体结构而不是"最后一个特征的 id"：
        # 每个独立 Solid 一个 body:{feature}:{index}，供 selector 精确匹配目标
        # 实体；单体保持 body:{feature}（与历史行为完全一致）。
        self.body = body
        self.body_id = f"body:{feature_id}"
+        self.body_members = dict(body_members) if body_members is not None else {feature_id: body}
        solids = self.adapter.body_solids(body)
        if len(solids) <= 1:
            self.topology.replace_body_topology(feature_id, self.body_id, self.adapter.topology_records(body, feature_id, self.body_id))
        else:
-            for index, solid in enumerate(solids):
-                member_id = f"{self.body_id}:{index}"
-                self.topology.replace_body_topology(
-                    feature_id, member_id,
-                    self.adapter.topology_records(solid, feature_id, member_id),
-                    active_body_id=self.body_id,
-                )
+            # 一个 Compound 的全部成员共享同一个前置 body snapshot。逐个登记会让
+            # 已登记的本轮成员成为下一个成员的 predecessor，进而把 pattern copy
+            # 的 owner 错误转移到相邻实例。必须原子替换整个多 body 拓扑快照。
+            members = [
+                (member_id, self.adapter.topology_records(solid, feature_id, member_id))
+                for index, solid in enumerate(solids)
+                for member_id in [f"{self.body_id}:{index}"]
+            ]
+            self.topology.replace_body_topologies(feature_id, members, active_body_id=self.body_id)
        self.topology.register(TopologyRecord(
            record_id=self.body_id, kind="body", feature_id=feature_id, body_id=self.body_id,
            geometry=self.adapter.body_geometry(body), value=body, owner_feature_ids=(feature_id,),
@@ -145,16 +174,99 @@ class ExecutionSession:
        if replay_node is not None:
            self.replay_definitions[feature_id] = replay_node

-    def resolve(self, selector: dict[str, Any]) -> SelectorResolution:
-        resolution = self.topology.resolve(selector, active_body_id=self.body_id)
+    def register_surface(self, feature_id: str, surface: Any) -> str:
+        # 曲面 feature 与实体 body 生命周期相互独立：不能调用 register_body，
+        # 否则 surface 会覆盖 active solid 并改变最终 STEP 的实体结果。
+        surface_id = f"surface:{feature_id}"
+        self.surface_members[feature_id] = surface
+        for record in self.adapter.topology_records(surface, feature_id, surface_id):
+            self.topology.register(record)
+        self.topology.register(TopologyRecord(
+            record_id=surface_id, kind="surface", feature_id=feature_id, body_id=surface_id,
+            geometry=self.adapter.surface_geometry(surface), value=surface, owner_feature_ids=(feature_id,),
+        ))
+        return surface_id
+
+    def _record_selector_resolution(self, resolution: SelectorResolution) -> SelectorResolution:
        evidence = resolution.as_dict()
        evidence["feature_id"] = self.active_feature_id
        self.selector_resolutions.append(evidence)
        return resolution

-    def result(self, node: FeaturePlanNode, *, context: PlaneSpec | AxisSpec | None = None, diagnostics: list[RuntimeDiagnostic] | None = None) -> FeatureResult:
+    def _intersection_component_records(self, selector: dict[str, Any]) -> list[TopologyRecord]:
+        matched = selector.get("matched_selectors") if selector.get("match_mode") == "all" else None
+        if matched is not None:
+            if not isinstance(matched, list) or not matched:
+                raise FeatureExecutionError("intersection_selector_unbound", "Intersection selector has no bound face matches")
+            resolved = [self._record_selector_resolution(self.topology.resolve(item, active_body_id=self.body_id)) for item in matched]
+        else:
+            binding_feature_id = selector.get("binding_feature_id")
+            active_body_id = None if binding_feature_id and self.body_id != f"body:{binding_feature_id}" else self.body_id
+            resolved = [self._record_selector_resolution(self.topology.resolve(selector, active_body_id=active_body_id))]
+        failures = [item for item in resolved if item.status != "resolved" or item.record is None]
+        if failures:
+            detail = failures[0].diagnostic.message if failures[0].diagnostic else "intersection selector component was not resolved"
+            raise FeatureExecutionError("intersection_selector_component_unresolved", detail)
+        return [item.record for item in resolved if item.record is not None]
+
+    def _resolve_intersection_vertex(self, selector: dict[str, Any]) -> SelectorResolution:
+        components = selector.get("intersection_of")
+        if self.body is None:
+            return SelectorResolution(
+                selector=selector, status="not_found", candidates=(),
+                diagnostic=RuntimeDiagnostic("missing_extent_body", "Intersection selector requires an existing body"),
+            )
+        if not isinstance(components, list) or len(components) < 2:
+            return SelectorResolution(
+                selector=selector, status="not_found", candidates=(),
+                diagnostic=RuntimeDiagnostic("intersection_selector_incomplete", "Intersection selector requires at least two face components"),
+            )
+        try:
+            face_sets = [self._intersection_component_records(component) for component in components]
+            if any(record.kind != "face" for records in face_sets for record in records):
+                raise FeatureExecutionError("intersection_selector_kind", "Intersection selector components must resolve to faces")
+            vertex = self.adapter.intersection_vertex(self.body, [[record.value for record in records] for records in face_sets])
+        except FeatureExecutionError as error:
+            return SelectorResolution(
+                selector=selector, status="not_found", candidates=(),
+                diagnostic=RuntimeDiagnostic(error.code, str(error), detail=error.detail),
+            )
+        except ValueError as error:
+            return SelectorResolution(
+                selector=selector, status="not_found", candidates=(),
+                diagnostic=RuntimeDiagnostic("intersection_vertex_unresolved", str(error)),
+            )
+        point = self.adapter.vertex_coordinates(vertex)
+        record = TopologyRecord(
+            record_id=str(selector.get("stable_id") or f"intersection:{id(vertex)}"),
+            kind="vertex", feature_id=self.active_feature_id, body_id=self.body_id,
+            geometry={"center_mm": list(point)}, value=vertex,
+            owner_feature_ids=tuple(filter(None, [str(selector.get("owner_feature_id") or "")])),
+        )
+        return SelectorResolution(
+            selector=selector, status="resolved", record=record,
+            candidates=({"score": 1.0, **record.public_dict()},),
+        )
+
+    def resolve(self, selector: dict[str, Any]) -> SelectorResolution:
+        if selector.get("intersection_of") is not None:
+            return self._record_selector_resolution(self._resolve_intersection_vertex(selector))
+        owner = str(selector.get("owner_feature_id") or "")
+        active_body_id = f"surface:{owner}" if owner in self.surface_members else self.body_id
+        return self._record_selector_resolution(self.topology.resolve(selector, active_body_id=active_body_id))
+
+    def result(
+        self,
+        node: FeaturePlanNode,
+        *,
+        context: PlaneSpec | AxisSpec | None = None,
+        diagnostics: list[RuntimeDiagnostic] | None = None,
+        include_body: bool = True,
+        surface_id: str | None = None,
+    ) -> FeatureResult:
        result = FeatureResult(
-            feature_id=node.feature_id, atomic_id=node.atomic_id, status="executed", body_id=self.body_id,
+            feature_id=node.feature_id, atomic_id=node.atomic_id, status="executed",
+            body_id=self.body_id if include_body else None, surface_id=surface_id,
            context=context, replay_definition={"atomic_id": node.atomic_id, "params": deepcopy(node.params), "sketch_id": node.sketch_id},
            diagnostics=diagnostics or [],
        )
@@ -237,6 +349,17 @@ def _targeted_extent_vector(
            raise FeatureExecutionError("non_uniform_extent_target", "The target vertex does not define one extrusion distance", extent=condition)
        distance = sum(projections) / len(projections)
    else:
+        if condition == "up_to_surface" and session.adapter.profile_touches_target(target, faces):
+            # 草图轮廓本身就在所选终止面上时，selected face 只是拉伸的起始
+            # 边界。应沿实际拉伸方向穿过当前 body，取下一张完整截获 profile
+            # 的边界面作为终止面；直接裁剪到 selected face 会生成零厚度工具体。
+            try:
+                next_face = session.adapter.next_body_face_after(
+                    session.body, faces, direction, excluded_face=target,
+                )
+            except ValueError as error:
+                raise FeatureExecutionError("extent_target_not_reached", str(error), extent=condition) from error
+            return ExtentVector(vector_scale(direction, 1.0), trim_to=next_face)
        try:
            distance = session.adapter.uniform_intersection_distance(target, faces, direction)
        except ValueError as error:
@@ -255,13 +378,15 @@ def _targeted_extent_vector(
                # 裁剪体层，仍保持显式拒绝。
                return ExtentVector(vector_scale(direction, 1.0), trim_to=target)
            raise FeatureExecutionError(code, message, extent=condition) from error
+    offset = abs(float((end_condition or {}).get("offset_mm") or 0.0))
    if condition == "offset_from_surface":
-        offset = abs(float(offset_mm if offset_mm is not None else node.params.get("distance_mm") or 0.0))
+        offset = abs(float(offset_mm if offset_mm is not None else offset or node.params.get("distance_mm") or 0.0))
+    if offset:
        distance -= offset
        if distance <= 1e-6:
            raise FeatureExecutionError(
                "invalid_extent_offset",
-                "Offset distance reaches or passes the target surface",
+                "Offset distance reaches or passes the target extent",
                extent=condition, offset_mm=offset,
            )
    return ExtentVector(vector_scale(direction, distance))
@@ -415,6 +540,14 @@ def _shape_from_primary(node: FeaturePlanNode, session: ExecutionSession, *, ske
    faces = session.adapter.faces_for_sketch(selected_sketch)
    if not faces:
        raise ValueError("sketch does not create a closed profile region")
+    if node.atomic_id == "extrude_add_blind_with_hole":
+        resolved = [session.resolve(selector) for selector in node.selectors]
+        failed = next((item for item in resolved if item.status != "resolved"), None)
+        if failed or len(resolved) != 1 or resolved[0].record is None or resolved[0].record.kind != "face":
+            raise ValueError(failed.diagnostic.message if failed and failed.diagnostic else "profile hole selector is unresolved")
+        if len(faces) != 1:
+            raise ValueError("profile hole extrusion requires exactly one outer sketch region")
+        faces = [session.adapter.face_with_holes(faces[0], [resolved[0].record.value])]
    # 3. 按特征类型生成子实体：
    if node.atomic_id.startswith("extrude_"):
        #   拉伸：先按终止条件（盲孔/贯穿/至面/双侧等）求出位移向量，
@@ -422,10 +555,18 @@ def _shape_from_primary(node: FeaturePlanNode, session: ExecutionSession, *, ske
        #   profile 与目标面非均匀相交时（extent.trim_to 非空）改用裁剪
        #   拉伸：穿透后与目标面求交，只保留可达部分（issue #5）。
        extents = _extent_vectors(node, faces, selected_sketch, session)
+        draft = node.params.get("draft")
+        taper_deg = 0.0
+        if isinstance(draft, dict):
+            taper_deg = float(draft["angle_deg"])
+            if not bool(draft["pull_direction"]):
+                taper_deg = -taper_deg
        solids: list[Any] = []
        for face in faces:
            for extent in extents:
-                if extent.trim_to is None:
+                if draft is not None:
+                    solids.append(session.adapter.extrude_taper(face, extent.vector, taper_deg))
+                elif extent.trim_to is None:
                    solids.append(session.adapter.extrude(face, extent.vector))
                else:
                    solids.append(session.adapter.extrude_trimmed(face, extent.trim_to, extent.vector))
@@ -456,11 +597,106 @@ def _shape_from_primary(node: FeaturePlanNode, session: ExecutionSession, *, ske
        if session.body is None:
            raise ValueError("cut feature has no body")
        body = session.adapter.cut(session.body, tool)
+        members = {node.feature_id: body}
+    elif node.params.get("result_mode") == "new_body":
+        # FeatureScript NEW creates an independent result body even when it
+        # intersects a prior body. Keep both shapes in the exported compound.
+        body = session.adapter.combine(session.body, tool)
+        members = {**session.body_members, node.feature_id: tool}
    else:
        #   添加类特征：将工具体并到当前主体上（fuse），首个特征时 body 为 None 也能直接成立。
        body = session.adapter.fuse(session.body, tool)
+        members = {node.feature_id: body}
    # 6. 登记新主体（更新拓扑、记录重放定义），并返回该特征的结果对象。
-    session.register_body(node.feature_id, body, replay_node=node)
+    session.register_body(node.feature_id, body, replay_node=node, body_members=members)
+    return session.result(node)
+
+
+def _execute_revolve_surface(node: FeaturePlanNode, session: ExecutionSession) -> FeatureResult:
+    # Surface revolve 的 profile 是单一闭合 wire。它只生成独立 shell，不能参与
+    # 当前实体 body 的 fuse/cut，也不能把其结果误报为新的实体 body。
+    sketch = session.sketches.get(str(node.sketch_id))
+    if sketch is None:
+        raise ValueError("surface revolve has no resolved sketch")
+    faces = session.adapter.faces_for_sketch(sketch)
+    if len(faces) != 1 or faces[0].inner_wires():
+        raise ValueError("surface revolve requires exactly one closed profile without holes")
+    axis = _revolve_axis(node, session)
+    _validate_revolve_axis_in_sketch_plane(axis, sketch)
+    angle = float(node.params.get("angle_deg") or 0.0)
+    if angle <= 0:
+        raise ValueError("surface revolve requires angle_deg > 0")
+    if bool(node.params.get("reverse")):
+        angle = -angle
+    surface_id = session.register_surface(
+        node.feature_id,
+        session.adapter.revolve_surface(faces[0].outer_wire(), angle, axis),
+    )
+    return session.result(node, include_body=False, surface_id=surface_id)
+
+
+def _execute_extrude_surface(node: FeaturePlanNode, session: ExecutionSession) -> FeatureResult:
+    # surfaceEntities 的曲面拉伸沿用实体特征已 lower 的距离，但始终独立登记为
+    # shell。它既不改变 active solid，也不以曲面参与实体 fuse/cut。
+    sketch = session.sketches.get(str(node.sketch_id))
+    if sketch is None:
+        raise ValueError("surface extrude has no resolved sketch")
+    direction = vector_unit(_normal_from_sketch(sketch), field_name="sketch normal")
+    if bool(node.params.get("reverse")):
+        direction = vector_scale(direction, -1)
+    distance = float(node.params.get("distance_mm") or 0.0)
+    if distance <= 0:
+        raise ValueError("surface extrude requires distance_mm > 0")
+    wires = session.adapter.surface_wires_for_sketch(sketch)
+    surface = session.adapter.extrude_surface(wires, vector_scale(direction, distance))
+    reverse_distance = float(node.params.get("reverse_distance_mm") or 0.0)
+    if reverse_distance > 0:
+        opposite = session.adapter.extrude_surface(wires, vector_scale(direction, -reverse_distance))
+        surface = session.adapter.combine_surfaces(surface, opposite)
+    surface_id = session.register_surface(node.feature_id, surface)
+    return session.result(node, include_body=False, surface_id=surface_id)
+
+
+def _combine_members(session: ExecutionSession, members: dict[str, Any]) -> Any:
+    body = None
+    for member in members.values():
+        body = session.adapter.combine(body, member)
+    if body is None:
+        raise ValueError("booleanBodies produced no result bodies")
+    return body
+
+
+def _execute_boolean_bodies(node: FeaturePlanNode, session: ExecutionSession) -> FeatureResult:
+    # booleanBodies 总是作用于 source feature 的明确 body 输出，不能回退为
+    # 当前聚合 body。这样相邻独立实体不会意外成为工具或目标。
+    params = node.params
+    target_ids = [str(value) for value in params.get("target_feature_ids") or []]
+    tool_ids = [str(value) for value in params.get("tool_feature_ids") or []]
+    missing = [feature_id for feature_id in target_ids + tool_ids if feature_id not in session.body_members]
+    if missing:
+        raise ValueError("booleanBodies source bodies are unavailable: " + ", ".join(missing))
+    targets = {feature_id: session.body_members[feature_id] for feature_id in target_ids}
+    tools = {feature_id: session.body_members[feature_id] for feature_id in tool_ids}
+    target = _combine_members(session, targets)
+    tool = _combine_members(session, tools)
+    operation = str(params.get("operation") or "")
+    if operation == "union":
+        result = session.adapter.fuse(target, tool)
+    elif operation == "subtract":
+        result = session.adapter.cut(target, tool)
+    elif operation == "intersect":
+        result = session.adapter.intersect(target, tool)
+    else:
+        raise ValueError(f"unsupported booleanBodies operation {operation!r}")
+    members = {
+        feature_id: body
+        for feature_id, body in session.body_members.items()
+        if feature_id not in set(target_ids + tool_ids)
+    }
+    members[node.feature_id] = result
+    if bool(params.get("keep_tools")):
+        members.update(tools)
+    session.register_body(node.feature_id, _combine_members(session, members), body_members=members)
    return session.result(node)


@@ -479,6 +715,79 @@ def _execute_loft_add(node: FeaturePlanNode, session: ExecutionSession) -> Featu
    return session.result(node)


+def _execute_loft_add_with_cap_face(node: FeaturePlanNode, session: ExecutionSession) -> FeatureResult:
+    resolved = [session.resolve(selector) for selector in node.selectors]
+    failed = next((item for item in resolved if item.status != "resolved"), None)
+    if failed or len(resolved) != 1 or resolved[0].record is None or resolved[0].record.kind != "face":
+        raise ValueError(failed.diagnostic.message if failed and failed.diagnostic else "cap-face loft selector is unresolved")
+    profile_ids = node.params.get("profile_sketch_ids") or []
+    profiles: list[dict[str, Any]] = []
+    for sketch_id in profile_ids:
+        sketch = session.sketches.get(str(sketch_id))
+        if sketch is None:
+            raise ValueError(f"loft profile sketch {sketch_id!r} is not resolved")
+        profiles.append(sketch)
+    solid = session.adapter.loft_with_cap_face(resolved[0].record.value, profiles)
+    session.register_body(node.feature_id, session.adapter.fuse(session.body, solid), replay_node=node)
+    return session.result(node)
+
+
+def _sweep_path(node: FeaturePlanNode, session: ExecutionSession) -> Any:
+    # 路径是 self-contained CDSL 数据，避免重放时依赖临时草图或 source id。
+    path = node.params.get("path") or {}
+    if not isinstance(path, dict):
+        raise ValueError("sweep path must be an object")
+    plane = PlaneSpec.from_mapping(path.get("workplane") or {})
+    segment = path.get("segment") or {}
+    if not isinstance(segment, dict):
+        raise ValueError("sweep path segment must be an object")
+    kind = str(segment.get("type") or "")
+    if kind == "line":
+        local_points = [segment.get("start"), segment.get("end")]
+    elif kind == "bspline":
+        local_points = segment.get("points") or []
+    else:
+        raise ValueError(f"unsupported sweep path segment {kind!r}")
+    if len(local_points) < 2 or any(not isinstance(point, list) or len(point) != 2 for point in local_points):
+        raise ValueError("sweep path requires two-dimensional points")
+
+    def point(value: list[float]) -> Vector3:
+        return vector_add(
+            plane.origin_mm,
+            vector_add(vector_scale(plane.x_dir, float(value[0])), vector_scale(plane.y_dir, float(value[1]))),
+        )
+
+    def tangent(value: Any) -> Vector3 | None:
+        if value is None:
+            return None
+        if not isinstance(value, list) or len(value) != 2:
+            raise ValueError("sweep path tangent must contain two coordinates")
+        return vector_add(vector_scale(plane.x_dir, float(value[0])), vector_scale(plane.y_dir, float(value[1])))
+
+    return session.adapter.sweep_path(
+        [point(value) for value in local_points],
+        start_tangent=tangent(segment.get("start_tangent")),
+        end_tangent=tangent(segment.get("end_tangent")),
+        parameters=[float(value) for value in segment.get("parameters") or []] or None,
+    )
+
+
+def _execute_sweep_add(node: FeaturePlanNode, session: ExecutionSession, sketch: dict[str, Any] | None = None) -> FeatureResult:
+    profile = sketch or session.sketches.get(str(node.sketch_id))
+    if profile is None:
+        raise ValueError("sweep has no resolved profile sketch")
+    faces = session.adapter.faces_for_sketch(profile)
+    if len(faces) != 1:
+        raise ValueError("sweep requires exactly one closed profile region")
+    solid = session.adapter.sweep(
+        faces[0], _sweep_path(node, session),
+        is_frenet=bool(node.params.get("is_frenet", False)),
+    )
+    body = session.adapter.combine(session.body, solid) if node.params.get("result_mode") == "new_body" else session.adapter.fuse(session.body, solid)
+    session.register_body(node.feature_id, body, replay_node=node)
+    return session.result(node)
+
+
 def _execute_reference_plane(node: FeaturePlanNode, session: ExecutionSession) -> FeatureResult:
    # 基准面特征（reference_plane）执行入口：从参数解析平面并登记为拓扑上下文。
    
@@ -775,17 +1084,93 @@ def _selector_edges(node: FeaturePlanNode, session: ExecutionSession, *, tangent
    failed = next((item for item in resolved if item.status != "resolved"), None)
    if failed:
        raise ValueError(failed.diagnostic.message if failed.diagnostic else "selector resolution failed")
+
+    def is_body_boundary(edge: Any) -> bool:
+        # 圆柱、圆锥等周期面会带一条仅属于自身的参数 seam。该线不是实体
+        # 边界；FeatureScript 以 FACE 选择倒角时不应将其当作额外的待倒角边，
+        # 否则连续的锥面会被错误切成两段。显式 EDGE selector 仍可表达真正的
+        # 单边选择，所以这里只约束由 FACE 展开的候选边。
+        face_count = sum(
+            1
+            for face in session.body.faces()
+            if any(candidate.is_same(edge) for candidate in face.edges())
+        )
+        return face_count >= 2
+
    edges: list[Any] = []
    for item in resolved:
        if item.record.kind == "edge":
            edges.append(item.record.value)
        elif item.record.kind == "face":
-            edges.extend(item.record.value.edges())
+            edges.extend(edge for edge in item.record.value.edges() if is_body_boundary(edge))
    if not edges:
        raise ValueError("selectors did not resolve any edges")
    return session.adapter.tangent_edges(session.body, edges) if tangent_propagation else edges


+def _shell_target(node: FeaturePlanNode, session: ExecutionSession) -> tuple[Any, list[Any]]:
+    # shell 的 remove-face selector 必须全部属于同一实体。CADFS 允许一个
+    # Compound 中保留多个独立 body，不能将整组 body 交给 OCC 后由内核猜测
+    # 应抽壳的成员。
+    resolved = [session.resolve(selector) for selector in node.selectors]
+    failed = next((item for item in resolved if item.status != "resolved"), None)
+    if failed:
+        raise ValueError(failed.diagnostic.message if failed.diagnostic else "selector resolution failed")
+    records = [item.record for item in resolved if item.record is not None]
+    if not records or any(record.kind != "face" for record in records):
+        raise ValueError("shell selectors must resolve to faces")
+    target_ids = {record.body_id for record in records}
+    if len(target_ids) != 1:
+        raise ValueError("shell faces must belong to one target body")
+    target_id = next(iter(target_ids))
+    members = session.adapter.body_solids(session.body)
+    if len(members) == 1:
+        return members[0], [record.value for record in records]
+    if target_id is None or session.body_id is None:
+        raise ValueError("shell target body is unresolved")
+    prefix = f"{session.body_id}:"
+    if not target_id.startswith(prefix):
+        raise ValueError("shell target body is outside the active body set")
+    try:
+        member_index = int(target_id[len(prefix):])
+    except ValueError as error:
+        raise ValueError("shell target body has an invalid member id") from error
+    if member_index < 0 or member_index >= len(members):
+        raise ValueError("shell target body member is unavailable")
+    return members[member_index], [record.value for record in records]
+
+
+def _replace_shell_target(session: ExecutionSession, target: Any, replacement: Any) -> Any:
+    # 仅替换抽壳目标实体；其他独立实体保持原样和原有相对顺序。
+    members = session.adapter.body_solids(session.body)
+    if len(members) == 1:
+        return replacement
+    replaced = False
+    result = None
+    for member in members:
+        if member.is_same(target):
+            result = session.adapter.combine(result, replacement)
+            replaced = True
+        else:
+            result = session.adapter.combine(result, member)
+    if not replaced or result is None:
+        raise ValueError("shell target solid is no longer part of the active body")
+    return result
+
+
+def _execute_shell(node: FeaturePlanNode, session: ExecutionSession) -> FeatureResult:
+    # 抽壳特征：移除 selector 所指面，并按 CADFS thickness 向实体内部偏置。
+    if session.body is None:
+        raise ValueError("shell has no body")
+    thickness = float(node.params.get("thickness_mm") or 0)
+    if thickness <= 0:
+        raise ValueError("shell thickness_mm must be > 0")
+    target, faces = _shell_target(node, session)
+    result = session.adapter.shell(target, faces, thickness, inward=bool(node.params.get("inward", True)))
+    session.register_body(node.feature_id, _replace_shell_target(session, target, result), replay_node=node)
+    return session.result(node)
+
+
 def _execute_fillet(node: FeaturePlanNode, session: ExecutionSession) -> FeatureResult:
    # 圆角特征（fillet）执行入口：对选中边按半径做圆角，平滑尖角与棱边。

@@ -825,13 +1210,31 @@ def _execute_chamfer(node: FeaturePlanNode, session: ExecutionSession) -> Featur
    if distance_2 is None and angle_rad is not None:
        distance_2 = distance * math.tan(float(angle_rad))
    # 4. 解析目标边（支持相切传播），执行倒角。
-    body = session.adapter.chamfer(
-        session.body, distance, distance_2,
-        _selector_edges(node, session, tangent_propagation=bool(node.params.get("tangent_propagation"))),
-    )
+    edges = _selector_edges(node, session, tangent_propagation=bool(node.params.get("tangent_propagation")))
+    diagnostics: list[RuntimeDiagnostic] = []
+    try:
+        body = session.adapter.chamfer(session.body, distance, distance_2, edges)
+    except ValueError as error:
+        # 显式 surfaceEntities 可以在后续实体上留下曲面分区边界。若标准
+        # OCC 倒角因环域宽度不足而拒绝，只允许在该 shell 给出同轴边界证据
+        # 时按原始距离构造受限倒角；没有证明时仍保留原始内核失败。
+        if distance_2 is not None or not session.surface_members:
+            raise
+        try:
+            body = session.adapter.surface_limited_chamfer(
+                session.body, distance, edges, list(session.surface_members.values()),
+            )
+        except ValueError:
+            raise error
+        diagnostics.append(RuntimeDiagnostic(
+            "chamfer_surface_limited",
+            "Chamfer was limited by an explicit coaxial surface boundary",
+            feature_id=node.feature_id,
+            detail={"distance_mm": distance, "surface_count": len(session.surface_members)},
+        ))
    # 5. 登记新主体并返回结果。
    session.register_body(node.feature_id, body, replay_node=node)
-    return session.result(node)
+    return session.result(node, diagnostics=diagnostics)


 def _translated_sketch(sketch: dict[str, Any], offset: Vector3) -> dict[str, Any]:
@@ -1178,6 +1581,15 @@ def _execute_mirror_pattern(node: FeaturePlanNode, session: ExecutionSession) ->
    resolution = session.resolve(mirror)
    if resolution.status != "resolved" or not isinstance(resolution.record.value, PlaneSpec):
        raise ValueError(resolution.diagnostic.message if resolution.diagnostic else "mirror plane was not resolved")
+    if node.params.get("mirror_current_body"):
+        # CADFS SWEPT_BODY 表示被后续 feature 持续修改的同一实体。这里复制
+        # 当前 B-rep 再镜像并合并，不能重放其初始 additive feature，否则会
+        # 丢失后续 cut/fillet 并生成独立错误实体。
+        if session.body is None:
+            raise ValueError("mirror current body has no active body")
+        mirrored = session.adapter.mirror(session.body, resolution.record.value)
+        session.register_body(node.feature_id, session.adapter.fuse(session.body, mirrored), replay_node=node)
+        return session.result(node)
    sources = session.replay_sources(node.params.get("source_feature_ids") or [])
    if not sources:
        raise ValueError("mirror pattern source features have no replay definitions")
@@ -1277,6 +1689,14 @@ def _rotated_node(node: FeaturePlanNode, instance_id: str, axis: AxisSpec, angle
                    plane[key] = _rotated_point(plane[key], axis, angle_rad)
                else:
                    plane[key] = list(_rotated_vector(tuple(float(v) for v in plane[key]), axis, angle_rad))
+    path = params.get("path")
+    path_plane = path.get("workplane") if isinstance(path, dict) else None
+    if isinstance(path_plane, dict):
+        if path_plane.get("origin_mm"):
+            path_plane["origin_mm"] = _rotated_point(path_plane["origin_mm"], axis, angle_rad)
+        for key in ("x_dir", "y_dir", "normal"):
+            if path_plane.get(key):
+                path_plane[key] = list(_rotated_vector(tuple(float(v) for v in path_plane[key]), axis, angle_rad))
    host = params.get("host_face")
    host_frame = host.get("frame") if isinstance(host, dict) else None
    positions_are_local = isinstance(host_frame, dict) and all(
@@ -1347,6 +1767,25 @@ def _rotated_node(node: FeaturePlanNode, instance_id: str, axis: AxisSpec, angle
    return FeaturePlanNode(instance_id, node.atomic_id, node.name, (), params, node.selectors, node.sketch_id, node.declared_status, node.source_feature)


+def _pattern_operation_node(node: FeaturePlanNode, operation_mode: str) -> FeaturePlanNode:
+    # REMOVE pattern 的实例必须沿用 source 的 profile/extent，但以 cut 而不是
+    # add 写入当前主体。lowering 已将初始 source 同步改写，运行时保留此处以
+    # 支持完整的 CDSL replay contract。
+    if operation_mode != "remove": return node
+    atomic_id = {
+        "extrude_add_blind": "extrude_cut_blind",
+        "extrude_add_two_sided": "extrude_cut_two_sided",
+        "revolve_add": "revolve_cut",
+    }.get(node.atomic_id, node.atomic_id)
+    if atomic_id == node.atomic_id and "cut" not in atomic_id:
+        raise ValueError("REMOVE pattern source is not a replayable cutting feature")
+    params = {key: value for key, value in node.params.items() if key != "result_mode"}
+    return FeaturePlanNode(
+        node.feature_id, atomic_id, node.name, node.depends_on, params,
+        node.selectors, node.sketch_id, node.declared_status, node.source_feature,
+    )
+
+
 def _execute_circular_pattern(node: FeaturePlanNode, session: ExecutionSession, execute: Callable[[FeaturePlanNode, ExecutionSession, dict[str, Any] | None], FeatureResult]) -> FeatureResult:
    # 环形阵列特征（pattern_circular）执行入口：绕显式轴按数量与包角重放源特征
    # 形成环形阵列。源特征整体绕轴旋转（绝对坐标变换），非复制当前主体的近似。
@@ -1359,10 +1798,18 @@ def _execute_circular_pattern(node: FeaturePlanNode, session: ExecutionSession,
    if count < 1:
        raise ValueError("circular pattern pattern_count must be >= 1")
    sweep_angle_deg = float(params.get("sweep_angle_deg") or 360.0)
+    operation_mode = str(params.get("operation_mode") or "add")
+    if operation_mode not in {"add", "remove"}:
+        raise ValueError("circular pattern operation_mode must be add or remove")
+    excluded = {int(value) for value in params.get("excluded_instance_indices") or []}
+    if any(instance < 1 or instance >= count for instance in excluded):
+        raise ValueError("circular pattern excluded instance is outside the generated range")
    sources = session.replay_sources(params.get("source_feature_ids") or [])
    if not sources:
        raise ValueError("circular pattern source features have no replay definitions")
    for instance in range(1, count):
+        if instance in excluded:
+            continue
        # 实例 i 位于包角 sweep_angle_deg 的 i/count 处（i=0 即源特征本身）。
        angle_deg = sweep_angle_deg * instance / count
        angle_rad = math.radians(angle_deg)
@@ -1376,10 +1823,25 @@ def _execute_circular_pattern(node: FeaturePlanNode, session: ExecutionSession,
                    "by multiples of 180 degrees"
                )
            cloned = _rotated_node(source, f"{node.feature_id}.c{instance}.{source.feature_id}", axis, angle_rad, session)
+            cloned = _pattern_operation_node(cloned, operation_mode)
+            # CADFS pattern instances are copies of the source result, not
+            # independent `NEW` operations.  Replay them through normal add
+            # semantics: intersecting or face-sharing instances fuse, while
+            # spatially separate copies remain separate solids in the result.
+            if cloned.params.get("result_mode") == "new_body":
+                cloned = FeaturePlanNode(
+                    cloned.feature_id, cloned.atomic_id, cloned.name, cloned.depends_on,
+                    {key: value for key, value in cloned.params.items() if key != "result_mode"},
+                    cloned.selectors, cloned.sketch_id, cloned.declared_status, cloned.source_feature,
+                )
            sketch = session.sketches.get(str(source.sketch_id))
            execute(cloned, session, _rotated_sketch(sketch, axis, angle_rad) if sketch else None)
-    # 记录本阵列的 replay 定义：后续阵列若选中本阵列，按定义递归重放。
-    session.replay_definitions[node.feature_id] = node
+    # 环形阵列本身是完整 B-rep 结果的 producer。每个 replay 子特征都会更新
+    # active body；循环结束后必须用 pattern feature 重新登记最终快照，否则后续
+    # selector binding 会只保留最后一个实例的 body id，漏掉其它 COPY 实例。
+    if session.body is None:
+        raise ValueError("circular pattern produced no body")
+    session.register_body(node.feature_id, session.body, replay_node=node)
    return session.result(node)


@@ -1418,11 +1880,30 @@ def _primary_executor(node: FeaturePlanNode, session: ExecutionSession, sketch:
    return _shape_from_primary(node, session, sketch=sketch)


+def _revolve_surface_executor(node: FeaturePlanNode, session: ExecutionSession, sketch: dict[str, Any] | None) -> FeatureResult:
+    del sketch
+    return _execute_revolve_surface(node, session)
+
+
+def _extrude_surface_executor(node: FeaturePlanNode, session: ExecutionSession, sketch: dict[str, Any] | None) -> FeatureResult:
+    del sketch
+    return _execute_extrude_surface(node, session)
+
+
 def _loft_executor(node: FeaturePlanNode, session: ExecutionSession, sketch: dict[str, Any] | None) -> FeatureResult:
    del sketch
    return _execute_loft_add(node, session)


+def _loft_cap_face_executor(node: FeaturePlanNode, session: ExecutionSession, sketch: dict[str, Any] | None) -> FeatureResult:
+    del sketch
+    return _execute_loft_add_with_cap_face(node, session)
+
+
+def _sweep_executor(node: FeaturePlanNode, session: ExecutionSession, sketch: dict[str, Any] | None) -> FeatureResult:
+    return _execute_sweep_add(node, session, sketch)
+
+
 def _reference_plane_executor(node: FeaturePlanNode, session: ExecutionSession, sketch: dict[str, Any] | None) -> FeatureResult:
    del sketch
    return _execute_reference_plane(node, session)
@@ -1468,6 +1949,11 @@ def _chamfer_executor(node: FeaturePlanNode, session: ExecutionSession, sketch:
    return _execute_chamfer(node, session)


+def _shell_executor(node: FeaturePlanNode, session: ExecutionSession, sketch: dict[str, Any] | None) -> FeatureResult:
+    del sketch
+    return _execute_shell(node, session)
+
+
 def _linear_pattern_executor(node: FeaturePlanNode, session: ExecutionSession, sketch: dict[str, Any] | None) -> FeatureResult:
    del sketch
    return _execute_linear_pattern(node, session, _execute_node)
@@ -1490,19 +1976,26 @@ EXECUTORS: dict[str, ExecutorFunction] = {
    "gear_add": _gear_executor,
    "rack_add": _rack_executor,
    "extrude_add_blind": _primary_executor,
+    "extrude_add_blind_with_hole": _primary_executor,
    "extrude_add_two_sided": _primary_executor,
    "extrude_cut_blind": _primary_executor,
    "extrude_cut_two_sided": _primary_executor,
    "extrude_cut_through": _primary_executor,
    "loft_add": _loft_executor,
+    "loft_add_with_cap_face": _loft_cap_face_executor,
+    "sweep_add": _sweep_executor,
    "revolve_add": _primary_executor,
    "revolve_cut": _primary_executor,
+    "revolve_surface": _revolve_surface_executor,
+    "extrude_surface": _extrude_surface_executor,
    "hole_blind": _hole_executor,
    "hole_countersink": _hole_executor,
    "hole_counterbore": _hole_executor,
    "hole_wizard": _hole_wizard_executor,
    "fillet": _fillet_executor,
    "chamfer": _chamfer_executor,
+    "shell": _shell_executor,
+    "boolean_bodies": lambda node, session, sketch: _execute_boolean_bodies(node, session),
    "pattern_linear": _linear_pattern_executor,
    "pattern_mirror": _mirror_pattern_executor,
    "pattern_circular": _circular_pattern_executor,
@@ -1567,20 +2060,33 @@ def rebuild_cdsl(cdsl: dict[str, Any], out_step: Path, *, strict: bool = True) -
            diagnostics.append(diagnostic)
            if strict:
                raise RuntimeExecutionError(diagnostic, list(session.selector_resolutions)) from error
-    if session.body is None:
-        raise ValueError("CDSL execution produced no body")
+    output = session.body
+    surface_geometry: dict[str, Any] | None = None
+    if output is None:
+        if not session.surface_members:
+            raise ValueError("CDSL execution produced no body")
+        # 纯曲面文档没有 active solid，但依然是可执行的 CAD 结果。只有在
+        # 没有实体时才将 surface members 作为 STEP 输出，混合模型继续只导出
+        # 实体，避免曲面意外改变既有实体比较和下游消费语义。
+        output = session.adapter.combine_surfaces(*session.surface_members.values())
+        surface_geometry = session.adapter.surface_geometry(output)
    out_step.parent.mkdir(parents=True, exist_ok=True)
-    session.adapter.export(session.body, str(out_step))
-    geometry = session.adapter.body_geometry(session.body)
+    session.adapter.export(output, str(out_step))
+    geometry = session.adapter.body_geometry(session.body) if session.body is not None else surface_geometry
+    if geometry is None:
+        raise ValueError("CDSL execution produced no exportable geometry")
    bbox = geometry["bbox_mm"]
    return {
        "engine": "cdsl_session_runtime",
        "out_step": str(out_step),
-        "volume_mm3": float(geometry["volume_mm3"]),
+        "volume_mm3": float(geometry.get("volume_mm3") or 0.0),
        "bbox_mm": {"min": bbox[:3], "max": bbox[3:]},
        # #7 multi-body：重建结果里的独立实体数（Compound 成员数），
        # 与 batch 验证的 document_truth.geometry.solid_body_count 对齐。
-        "solid_count": len(session.adapter.body_solids(session.body)),
+        "solid_count": len(session.adapter.body_solids(session.body)) if session.body is not None else 0,
+        "surface_count": len(session.surface_members),
+        "surface_face_count": int(surface_geometry["face_count"]) if surface_geometry is not None else 0,
+        "surface_area_mm2": float(surface_geometry["area_mm2"]) if surface_geometry is not None else 0.0,
        "feature_results": [result.as_dict() for result in session.results.values()],
        "runtime_diagnostics": [diagnostic.as_dict() for diagnostic in diagnostics],
        "topology_records": [record.public_dict() for record in session.topology.records()],