simplecadapi 2.0.7__tar.gz → 2.0.8__tar.gz

{simplecadapi-2.0.7 → simplecadapi-2.0.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: simplecadapi
-Version: 2.0.7
+Version: 2.0.8
 Summary: A simplified CAD modeling Python API based on CADQuery
 Project-URL: Homepage, https://github.com/NiJingzhe/SimpleCADAPI
 Project-URL: Repository, https://github.com/NiJingzhe/SimpleCADAPI
@@ -385,7 +385,7 @@ Experimental scripts and temporary modeling examples are not included as formal
 
 ## Package Installation (Python Package Managers)
 
-Current package name: `simplecadapi`, version: `2.0.7` (see `pyproject.toml`).
+Current package name: `simplecadapi`, version: `2.0.8` (see `pyproject.toml`).
 
 ### Method A: Install from package repository with pip
 
@@ -418,7 +418,7 @@ uv add simplecadapi
 The repository already contains example build artifacts (`dist/`):
 
 ```bash
-pip install dist/simplecadapi-2.0.7-py3-none-any.whl
+pip install dist/simplecadapi-2.0.8-py3-none-any.whl
 ```
 
 If you need to rebuild:

{simplecadapi-2.0.7 → simplecadapi-2.0.8}/README.md

@@ -9,7 +9,7 @@ Experimental scripts and temporary modeling examples are not included as formal
 
 ## Package Installation (Python Package Managers)
 
-Current package name: `simplecadapi`, version: `2.0.7` (see `pyproject.toml`).
+Current package name: `simplecadapi`, version: `2.0.8` (see `pyproject.toml`).
 
 ### Method A: Install from package repository with pip
 
@@ -42,7 +42,7 @@ uv add simplecadapi
 The repository already contains example build artifacts (`dist/`):
 
 ```bash
-pip install dist/simplecadapi-2.0.7-py3-none-any.whl
+pip install dist/simplecadapi-2.0.8-py3-none-any.whl
 ```
 
 If you need to rebuild:

{simplecadapi-2.0.7 → simplecadapi-2.0.8}/docs/api/union_rsolidlist.md

@@ -3,7 +3,12 @@
 ## API Definition
 
 ```python
-def union_rsolidlist(*solids: Union[Solid, Sequence[Solid]]) -> List[Solid]
+def union_rsolidlist(
+    *solids: Union[Solid, Sequence[Solid]],
+    clean: bool = True,
+    glue: bool = True,
+    tol: Optional[float] = None,
+) -> List[Solid]
 ```
 
 *Source: operations.py*
@@ -15,13 +20,18 @@ Compute the boolean union of one or more solids.
 All boolean operations (union/cut/intersect) accept a mix of Solid and
 sequences; results are always returned as a list of Solid.
 Keep the list result unless you have explicitly verified `len(result) == 1`.
+SimpleCAD enables glue mode by default and applies a conservative internal fuzzy
+tolerance, so normal modeling code does not need to tune boolean parameters.
+By default this follows CadQuery's union flow: perform one OCC fuse across the
+input solids, then call `clean()` to unify same-domain faces when possible.
 Touching-but-not-intersecting inputs can legitimately return multiple solids.
 If that happens, keep using the list: pass it directly into later union calls,
 or iterate over the solids for later cut/intersect steps.
+When the returned solids are still separated by more than the active tolerance,
+SimpleCAD prints a stdout warning explaining that the objects do not touch and
+that their gap exceeds `tol`.
 If you truly need exactly one merged solid, you must check the list length
-before using `result[0]`. When the length is not 1, do not pick an element
-arbitrarily; instead, adjust part placement so the solids overlap slightly,
-then run the union again.
+before using `result[0]`.
 
 ## Parameters
 
@@ -29,6 +39,18 @@ then run the union again.
 
 - **Description**: One or more Solid objects or sequences of Solid. Nested sequences are flattened before processing.
 
+### clean
+
+- **Description**: Call CadQuery's `clean()` after the union to remove splitter edges and unify same-domain faces when possible.
+
+### glue
+
+- **Description**: Enable OCC glue mode for touching or partially overlapping inputs. Defaults to `True` for SimpleCAD's standard union behavior.
+
+### tol
+
+- **Description**: Optional fuzzy-boolean tolerance passed to the OCC union kernel. When omitted, SimpleCAD derives a conservative scale-aware value automatically.
+
 ## Returns
 
 List[Solid]: Resulting solids after union attempts. Solids that can be fused

{simplecadapi-2.0.7 → simplecadapi-2.0.8}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "simplecadapi"
-version = "2.0.7"
+version = "2.0.8"
 description = "A simplified CAD modeling Python API based on CADQuery"
 readme = "README.md"
 license = { file = "LICENSE" }

{simplecadapi-2.0.7 → simplecadapi-2.0.8}/skills/simplecad-self-evolve/SKILL.md

@@ -5,9 +5,9 @@ license: MIT
 compatibility: Requires Python 3.10+, active virtual environment, and network access for package installation.
 metadata:
   project: simplecadapi
-  version: 2.0.7
+  version: 2.0.8
   runtime-package: simplecadapi
-  runtime-spec: simplecadapi==2.0.7
+  runtime-spec: simplecadapi==2.0.8
   cases-module: simplecad_self_evolve_cases
 ---
 
@@ -53,7 +53,7 @@ metadata:
 ## Install behavior
 - Preferred: run `scripts/install.sh` once when skill is installed/activated.
 - Runtime wrappers auto-install on demand if `simplecadapi` is missing.
-- Package installed by default: `simplecadapi==2.0.7`
+- Package installed by default: `simplecadapi==2.0.8`
 - Wrappers install only into a virtual environment interpreter (set `PYTHON_BIN` when needed).
 
 ## Interpreter selection

{simplecadapi-2.0.7 → simplecadapi-2.0.8}/skills/simplecad-self-evolve/references/PROJECT_OVERVIEW.md

@@ -1,8 +1,8 @@
 # Project Overview
 
 - Project: `simplecadapi`
-- Version: `2.0.7`
-- Runtime package: `simplecadapi==2.0.7`
+- Version: `2.0.8`
+- Runtime package: `simplecadapi==2.0.8`
 - Skill cases module: `simplecad_self_evolve_cases`
 
 ## What this skill bundles

{simplecadapi-2.0.7 → simplecadapi-2.0.8}/skills/simplecad-self-evolve/references/PROJECT_README.md

@@ -9,7 +9,7 @@ Experimental scripts and temporary modeling examples are not included as formal
 
 ## Package Installation (Python Package Managers)
 
-Current package name: `simplecadapi`, version: `2.0.7` (see `pyproject.toml`).
+Current package name: `simplecadapi`, version: `2.0.8` (see `pyproject.toml`).
 
 ### Method A: Install from package repository with pip
 
@@ -42,7 +42,7 @@ uv add simplecadapi
 The repository already contains example build artifacts (`dist/`):
 
 ```bash
-pip install dist/simplecadapi-2.0.7-py3-none-any.whl
+pip install dist/simplecadapi-2.0.8-py3-none-any.whl
 ```
 
 If you need to rebuild:

{simplecadapi-2.0.7 → simplecadapi-2.0.8}/skills/simplecad-self-evolve/references/RUNTIME_INSTALL.md

@@ -6,7 +6,7 @@
 PYTHON_BIN=.venv/bin/python scripts/install.sh
 ```
 
-This installs `simplecadapi==2.0.7` to the active Python environment.
+This installs `simplecadapi==2.0.8` to the active Python environment.
 If `PYTHON_BIN` is not set, wrappers default to `python3` (fallback `python`).
 Installation is intentionally blocked for non-venv/system interpreters.
 

{simplecadapi-2.0.7 → simplecadapi-2.0.8}/skills/simplecad-self-evolve/references/docs/api/union_rsolidlist.md

@@ -3,7 +3,12 @@
 ## API Definition
 
 ```python
-def union_rsolidlist(*solids: Union[Solid, Sequence[Solid]]) -> List[Solid]
+def union_rsolidlist(
+    *solids: Union[Solid, Sequence[Solid]],
+    clean: bool = True,
+    glue: bool = True,
+    tol: Optional[float] = None,
+) -> List[Solid]
 ```
 
 *Source: operations.py*
@@ -15,13 +20,18 @@ Compute the boolean union of one or more solids.
 All boolean operations (union/cut/intersect) accept a mix of Solid and
 sequences; results are always returned as a list of Solid.
 Keep the list result unless you have explicitly verified `len(result) == 1`.
+SimpleCAD enables glue mode by default and applies a conservative internal fuzzy
+tolerance, so normal modeling code does not need to tune boolean parameters.
+By default this follows CadQuery's union flow: perform one OCC fuse across the
+input solids, then call `clean()` to unify same-domain faces when possible.
 Touching-but-not-intersecting inputs can legitimately return multiple solids.
 If that happens, keep using the list: pass it directly into later union calls,
 or iterate over the solids for later cut/intersect steps.
+When the returned solids are still separated by more than the active tolerance,
+SimpleCAD prints a stdout warning explaining that the objects do not touch and
+that their gap exceeds `tol`.
 If you truly need exactly one merged solid, you must check the list length
-before using `result[0]`. When the length is not 1, do not pick an element
-arbitrarily; instead, adjust part placement so the solids overlap slightly,
-then run the union again.
+before using `result[0]`.
 
 ## Parameters
 
@@ -29,6 +39,18 @@ then run the union again.
 
 - **Description**: One or more Solid objects or sequences of Solid. Nested sequences are flattened before processing.
 
+### clean
+
+- **Description**: Call CadQuery's `clean()` after the union to remove splitter edges and unify same-domain faces when possible.
+
+### glue
+
+- **Description**: Enable OCC glue mode for touching or partially overlapping inputs. Defaults to `True` for SimpleCAD's standard union behavior.
+
+### tol
+
+- **Description**: Optional fuzzy-boolean tolerance passed to the OCC union kernel. When omitted, SimpleCAD derives a conservative scale-aware value automatically.
+
 ## Returns
 
 List[Solid]: Resulting solids after union attempts. Solids that can be fused

{simplecadapi-2.0.7 → simplecadapi-2.0.8}/skills/simplecad-self-evolve/scripts/install.sh

@@ -32,7 +32,7 @@ export SIMPLECAD_RUNTIME_PACKAGE="simplecadapi"
 export SIMPLECAD_CASES_ROOT="${SKILL_ROOT}/cases"
 export SIMPLECAD_CASES_MODULE="simplecad_self_evolve_cases"
 
-PACKAGE_SPEC="simplecadapi==2.0.7"
+PACKAGE_SPEC="simplecadapi==2.0.8"
 JUPYTER_DEPS=("jupyterlab>=4.5.5" "ipykernel>=6.29.5")
 INSTALL_JUPYTER=0
 INSTALL_ARGS=()
@@ -85,4 +85,4 @@ print("simplecadapi import OK")
 print(getattr(scad, "__description__", ""))
 PY
 
-echo "Runtime install completed for simplecadapi 2.0.7."
+echo "Runtime install completed for simplecadapi 2.0.8."

{simplecadapi-2.0.7 → simplecadapi-2.0.8}/skills/simplecad-self-evolve/scripts/repl_bootstrap.py

@@ -10,7 +10,7 @@ import sys
 from pathlib import Path
 
 
-PACKAGE_SPEC = "simplecadapi==2.0.7"
+PACKAGE_SPEC = "simplecadapi==2.0.8"
 CASES_MODULE = "simplecad_self_evolve_cases"
 
 

{simplecadapi-2.0.7 → simplecadapi-2.0.8}/src/simplecadapi/auto_tools/skill_pack.py

@@ -565,13 +565,16 @@ class SkillPackager:
             7. Build and validate incrementally. Each step MUST include a small grounding `print`, and grounding MUST use QL where possible.
             8. For inspection/debugging, query geometry with QL and print only the queried facts you need; do not print whole solids, assemblies, or full model objects.
             9. Boolean operations always return `List[Solid]`. You MUST check `len(results)` before using `results[0]`.
-            10. If tangent-only contact leaves multiple solids after `union_rsolidlist(...)`, that is often acceptable. Keep the list and continue operating on the list or iterate over its solids.
-            11. If the design explicitly requires exactly one merged solid and `len(results) != 1`, you MUST NOT silently pick one item. Instead, slightly adjust part placement so the intended bodies overlap/embed, run the union again, and only then unwrap the single result.
-            12. After model construction, ask the user whether the result is satisfactory and whether any modifications are needed. Only after explicit user confirmation may you add the script to evolve cases.
+            10. `union_rsolidlist(...)` already uses SimpleCAD's tuned default boolean settings internally. Do not add manual boolean tuning unless you are debugging a stubborn edge case.
+            11. If tangent-only contact leaves multiple solids after `union_rsolidlist(...)`, that is often acceptable. Keep the list and continue operating on the list or iterate over its solids.
+            12. If the design explicitly requires exactly one merged solid and `len(results) != 1`, you MUST NOT silently pick one item. Instead, slightly adjust part placement so the intended bodies overlap/embed, run the union again, and only then unwrap the single result.
+            13. After model construction, ask the user whether the result is satisfactory and whether any modifications are needed. Only after explicit user confirmation may you add the script to evolve cases.
 
             ## Boolean result discipline
             - `union_rsolidlist(...)`, `cut_rsolidlist(...)`, and `intersect_rsolidlist(...)` accept mixed inputs: standalone `Solid`, lists of `Solid`, and nested sequences.
             - They always return `List[Solid]`.
+            - `union_rsolidlist(...)` already applies the package's default glue mode and a conservative internal tolerance.
+            - If a union still returns multiple solids that remain separated beyond tolerance, the API prints a stdout warning automatically.
             - Default behavior: keep the list result and pass it forward or iterate over it.
             - Only unwrap to a single solid after an explicit `len(results) == 1` check.
             - If a single merged solid is required but a union still returns multiple solids, slightly move the parts so they overlap instead of merely touching, then recompute the union.

{simplecadapi-2.0.7 → simplecadapi-2.0.8}/src/simplecadapi/operations.py

@@ -26,7 +26,83 @@ from .field import (
     intersect_rscalarfield,
 )
 
-from cadquery.occ_impl.shapes import fuse, cut, intersect, revolve
+from cadquery.occ_impl.shapes import cut, intersect, revolve
+
+
+_DEFAULT_UNION_GLUE = True
+_DEFAULT_UNION_TOL_FACTOR = 1e-7
+_DEFAULT_UNION_TOL_MIN = 1e-7
+_DEFAULT_UNION_TOL_MAX = 1e-5
+
+
+def _resolve_union_tol(
+    solids: Sequence[Solid], tol: Optional[float]
+) -> Optional[float]:
+    """Resolve a conservative fuzzy tolerance for boolean union.
+
+    When callers do not specify `tol`, use a scale-aware value that is large enough
+    to absorb small numerical noise but not aggressive enough to close meaningful
+    modeling gaps by default.
+    """
+
+    if tol is not None:
+        return tol
+
+    bbox_min = np.array([np.inf, np.inf, np.inf], dtype=float)
+    bbox_max = np.array([-np.inf, -np.inf, -np.inf], dtype=float)
+
+    for solid in solids:
+        bb = solid.cq_solid.BoundingBox()
+        bbox_min = np.minimum(bbox_min, np.array([bb.xmin, bb.ymin, bb.zmin]))
+        bbox_max = np.maximum(bbox_max, np.array([bb.xmax, bb.ymax, bb.zmax]))
+
+    span = float(np.linalg.norm(bbox_max - bbox_min))
+    if not np.isfinite(span) or span <= 0:
+        return _DEFAULT_UNION_TOL_MIN
+
+    return min(
+        max(span * _DEFAULT_UNION_TOL_FACTOR, _DEFAULT_UNION_TOL_MIN),
+        _DEFAULT_UNION_TOL_MAX,
+    )
+
+
+def _warn_if_union_results_remain_separated(
+    results: Sequence[Solid], tol: Optional[float]
+) -> None:
+    """Print a clear stdout warning when union results remain separated beyond tol."""
+
+    if len(results) < 2:
+        return
+
+    effective_tol = float(tol or 0.0)
+    nearest_gap_above_tol: Optional[float] = None
+
+    for i in range(len(results)):
+        for j in range(i + 1, len(results)):
+            gap = float(results[i].cq_solid.distance(results[j].cq_solid))
+            if gap > effective_tol:
+                if nearest_gap_above_tol is None or gap < nearest_gap_above_tol:
+                    nearest_gap_above_tol = gap
+
+    if nearest_gap_above_tol is None:
+        return
+
+    if len(results) == 2:
+        print(
+            "[WARNING] union_rsolidlist returned 2 separated solids: the two objects do not touch, "
+            f"and the gap between them is about {nearest_gap_above_tol:.6g}, which exceeds tol={effective_tol:.6g}. "
+            "Please check the relationship between the two objects and decide whether to adjust them so they connect, "
+            "or accept them as two separate solids."
+        )
+        return
+
+    print(
+        f"[WARNING] union_rsolidlist returned {len(results)} separated solids: "
+        "at least one pair of objects does not touch, "
+        f"and the smallest detected separation gap is about {nearest_gap_above_tol:.6g}, which exceeds tol={effective_tol:.6g}. "
+        "Please check the relationship between these objects and decide whether to adjust them so they connect, "
+        "or accept them as separate solids."
+    )
 
 
 # =============================================================================
@@ -1239,29 +1315,41 @@ def select_edges_by_tag(shape: Union[Face, Solid], tag: str) -> List[Edge]:
 # =============================================================================
 
 
-def union_rsolidlist(*solids: Union[Solid, Sequence[Solid]]) -> List[Solid]:
+def union_rsolidlist(
+    *solids: Union[Solid, Sequence[Solid]],
+    clean: bool = True,
+    glue: bool = _DEFAULT_UNION_GLUE,
+    tol: Optional[float] = None,
+) -> List[Solid]:
     """Compute the boolean union of one or more solids.
 
     Args:
         solids: One or more Solid objects or sequences of Solid. Nested sequences are
             flattened before processing.
+        clean: Call CadQuery's `clean()` after the union to unify same-domain faces
+            and remove splitter edges when possible.
+        glue: Enable OCC glue mode for touching or partially overlapping inputs.
+            Defaults to True for SimpleCAD's standard union behavior.
+        tol: Optional fuzzy-boolean tolerance used by the OCC union kernel. When
+            omitted, SimpleCAD chooses a conservative scale-aware tolerance.
 
     Returns:
         List[Solid]: Resulting solids after union attempts. Solids that can be fused
-            are merged; disjoint or tangent-only contacts remain separate, so the
-            list may contain multiple solids.
+        are merged; disjoint or tangent-only contacts remain separate, so the
+        list may contain multiple solids.
 
     Usage:
         All boolean operations (union/cut/intersect) accept a mix of Solid and
         sequences; results are always returned as a list of Solid.
         Keep the list result unless you have explicitly verified `len(result) == 1`.
+        SimpleCAD enables glue mode by default and applies a conservative internal
+        fuzzy tolerance so normal code does not need to tune boolean parameters.
         Touching-but-not-intersecting inputs can legitimately return multiple solids.
         If that happens, keep using the list: pass it directly into later union calls,
-        or iterate over the solids for later cut/intersect steps.
-        If you truly need exactly one merged solid, you must check the list length
-        before using `result[0]`. When the length is not 1, do not pick an element
-        arbitrarily; instead, adjust part placement so the solids overlap slightly,
-        then run the union again.
+        or iterate over the solids for later cut/intersect steps. When returned
+        solids remain separated by more than the active tolerance, SimpleCAD prints
+        a stdout warning describing the detected gap. If you truly need exactly one
+        merged solid, you must check the list length before using `result[0]`.
 
     Examples:
         # Rounded-bar style input: end caps only touch the center body.
@@ -1292,33 +1380,6 @@ def union_rsolidlist(*solids: Union[Solid, Sequence[Solid]]) -> List[Solid]:
         final_body = merged[0]
     """
 
-    def _attempt_fuse(base: Solid, candidate: Solid) -> Optional[Solid]:
-        s1 = base.cq_solid
-        s2 = candidate.cq_solid
-
-        if s1.isNull() or s2.isNull():
-            raise ValueError("输入实体无效，无法进行并集运算。")
-
-        fused_shape = fuse(s1, s2)
-        if hasattr(fused_shape, "Solids") and fused_shape.Solids():
-            cq_result = fused_shape.Solids()[0]
-        else:
-            cq_result = fused_shape
-
-        fused_solid = Solid(cq_result)
-        if math.isclose(
-            fused_solid.get_volume(),
-            base.get_volume(),
-            rel_tol=1e-9,
-            abs_tol=1e-12,
-        ):
-            return None
-
-        fused_solid._tags = base._tags.union(candidate._tags)
-        fused_solid._metadata = {**base._metadata, **candidate._metadata}
-
-        return fused_solid
-
     try:
         # 递归展开所有参数：将Solid直接添加，将序列展开
         def _flatten_solids(args):
@@ -1340,30 +1401,49 @@ def union_rsolidlist(*solids: Union[Solid, Sequence[Solid]]) -> List[Solid]:
         for solid in remaining:
             if not isinstance(solid, Solid):
                 raise ValueError("union_rsolidlist函数只接受Solid类型的对象")
+            if solid.cq_solid.isNull():
+                raise ValueError("输入实体无效，无法进行并集运算。")
 
-        result: List[Solid] = []
+        if len(remaining) == 1 and not clean:
+            return [remaining[0]]
 
-        while remaining:
-            base = remaining.pop(0)
-            merged = True
-
-            while merged:
-                merged = False
-                idx = 0
-                while idx < len(remaining):
-                    candidate = remaining[idx]
-                    fused = _attempt_fuse(base, candidate)
-                    if fused is None:
-                        idx += 1
-                        continue
+        effective_tol = _resolve_union_tol(remaining, tol)
+        cq_shapes = [solid.cq_solid for solid in remaining]
+
+        if len(cq_shapes) == 1:
+            fused_shape = cq_shapes[0]
+        else:
+            fused_shape = cq_shapes[0].fuse(
+                *cq_shapes[1:], glue=glue, tol=effective_tol
+            )
+
+        if clean:
+            fused_shape = fused_shape.clean()
 
-                    base = fused
-                    remaining.pop(idx)
-                    merged = True
+        if hasattr(fused_shape, "Solids"):
+            cq_results = list(fused_shape.Solids())
+        elif hasattr(fused_shape, "ShapeType") and fused_shape.ShapeType() == "Solid":
+            cq_results = [fused_shape]
+        else:
+            cq_results = []
+
+        if not cq_results:
+            raise ValueError("并集结果中未找到有效实体。")
 
-                # 如果在本轮中没有融合发生，则跳出内循环
+        all_tags = set()
+        all_metadata = {}
+        for solid in remaining:
+            all_tags.update(solid._tags)
+            all_metadata.update(solid._metadata)
+
+        result: List[Solid] = []
+        for cq_result in cq_results:
+            fused_solid = Solid(cq_result)
+            fused_solid._tags = all_tags.copy()
+            fused_solid._metadata = all_metadata.copy()
+            result.append(fused_solid)
 
-            result.append(base)
+        _warn_if_union_results_remain_separated(result, effective_tol)
 
         return result
     except Exception as e:

{simplecadapi-2.0.7 → simplecadapi-2.0.8}/test/test_all_features.py

@@ -2,10 +2,12 @@
 
 import sys
 import os
+import io
 import unittest
 import numpy as np
 import tempfile
 import shutil
+from contextlib import redirect_stdout
 
 # 添加项目路径到Python路径
 sys.path.insert(0, os.path.join(os.path.dirname(__file__), "src"))
@@ -271,12 +273,49 @@ class TestBooleanOperations(unittest.TestCase):
         box_far_3 = scad.make_box_rsolid(1.0, 1.0, 1.0, bottom_face_center=(0, 5, 0))
 
         solids = [box_far_1, box_far_2, box_far_3]
-        results = scad.union_rsolidlist(solids)
+        stdout_buffer = io.StringIO()
+        with redirect_stdout(stdout_buffer):
+            results = scad.union_rsolidlist(solids)
+        warning_text = stdout_buffer.getvalue()
 
         self.assertIsInstance(results, list)
         self.assertEqual(len(results), len(solids))
         for solid in results:
             self.assertIsInstance(solid, scad.Solid)
+        self.assertIn("[WARNING]", warning_text)
+        self.assertIn("does not touch", warning_text)
+        self.assertIn("exceeds tol", warning_text)
+
+    def test_union_touching_boxes_cleans_splitter_faces(self):
+        """Test union of face-touching boxes follows CadQuery-style clean behavior."""
+
+        box_left = scad.make_box_rsolid(1.0, 1.0, 1.0, bottom_face_center=(0, 0, 0))
+        box_right = scad.make_box_rsolid(1.0, 1.0, 1.0, bottom_face_center=(1.0, 0, 0))
+
+        stdout_buffer = io.StringIO()
+        with redirect_stdout(stdout_buffer):
+            results = scad.union_rsolidlist(box_left, box_right)
+
+        self.assertEqual(len(results), 1)
+        self.assertAlmostEqual(results[0].get_volume(), 2.0, places=6)
+        self.assertEqual(len(results[0].get_faces()), 6)
+        self.assertEqual(stdout_buffer.getvalue(), "")
+
+    def test_union_supports_fuzzy_tolerance(self):
+        """Test union forwards CadQuery fuzzy tolerance to the OCC kernel."""
+
+        box_left = scad.make_box_rsolid(1.0, 1.0, 1.0, bottom_face_center=(0, 0, 0))
+        box_right = scad.make_box_rsolid(
+            1.0, 1.0, 1.0, bottom_face_center=(1.001, 0, 0)
+        )
+
+        without_tol = scad.union_rsolidlist(box_left, box_right)
+        with_tol = scad.union_rsolidlist(box_left, box_right, tol=1e-3)
+
+        self.assertEqual(len(without_tol), 2)
+        self.assertEqual(len(with_tol), 1)
+        self.assertGreater(with_tol[0].get_volume(), 2.0)
+        self.assertLess(with_tol[0].get_volume(), 2.01)
 
     def test_cut(self):
         """Test cut."""
@@ -609,7 +648,7 @@ class TestComplexExamples(unittest.TestCase):
         gear_base = gear_base_list[0]
 
         # 创建齿（简化版本）
-        tooth_profile = scad.make_rectangle_rface(0.5, 0.3, center=(4.5, 0, 0))
+        tooth_profile = scad.make_rectangle_rface(0.5, 0.3, center=(5.0, 0, 0))
         tooth = scad.extrude_rsolid(tooth_profile, (0, 0, 1), 1.2)
 
         # 合并一个齿到基础上

{simplecadapi-2.0.7 → simplecadapi-2.0.8}/uv.lock

@@ -3546,7 +3546,7 @@ wheels = [
 
 [[package]]
 name = "simplecadapi"
-version = "2.0.7"
+version = "2.0.8"
 source = { editable = "." }
 dependencies = [
     { name = "cadquery" },