first commit

SimpleCADAPI-master/docs/api/Assembly.md

@@ -0,0 +1,17 @@
+# Assembly
+
+## Class Definition
+
+```python
+class Assembly(assembly_id: str, name: Optional[str] = None, components: Tuple[Component, ...] = (), connectors: Tuple[Connector, ...] = (), constraints: Tuple[Constraint, ...] = (), grounded_component_ids: Tuple[str, ...] = ())
+```
+
+*Source: product.py*
+
+## Import Surface
+
+- top-level: `from simplecadapi import Assembly`
+
+## Description
+
+Product structure containing placed Part or subassembly components.

SimpleCADAPI-master/docs/api/BSplineFitResult.md

@@ -0,0 +1,21 @@
+# BSplineFitResult
+
+## Class Definition
+
+```python
+class BSplineFitResult(degree: int, control_points: Tuple[PointTuple, ...], knots: Tuple[float, ...], sample_parameters: Tuple[float, ...], max_error: float, rms_error: float, tolerance: float, fairing: float, iterations: int, converged: bool)
+```
+
+*Source: math.py*
+
+## Import Surface
+
+- top-level: `from simplecadapi import BSplineFitResult`
+
+## Description
+
+Result from fitting a cubic B-spline to sampled curve points.
+
+The result stores a complete, normalized B-spline definition suitable for
+passing into the exact B-spline edge/wire APIs: cubic degree, control
+points, and a full clamped knot vector.

SimpleCADAPI-master/docs/api/Component.md

@@ -0,0 +1,17 @@
+# Component
+
+## Class Definition
+
+```python
+class Component(component_id: str, item: AssemblyItem, placement: Placement, name: Optional[str] = None)
+```
+
+*Source: product.py*
+
+## Import Surface
+
+- top-level: `from simplecadapi import Component`
+
+## Description
+
+Assembly-local instance of a Part or subassembly.

SimpleCADAPI-master/docs/api/Connector.md

@@ -0,0 +1,22 @@
+# Connector
+
+## Class Definition
+
+```python
+class Connector(connector_id: str, geometry_ref: Optional[GeometryRef] = None, name: Optional[str] = None, anchor: Optional[ConnectorAnchor] = None)
+```
+
+*Source: product.py*
+
+## Import Surface
+
+- top-level: `from simplecadapi import Connector`
+
+## Description
+
+Semantic datum frame anchored by geometry, placement, or forwarding.
+
+Geometry connectors derive placement from a selected BREP sub-shape.
+Placement connectors store an explicit local datum frame. Forwarded
+connectors expose a component connector as an assembly-level public
+interface.

SimpleCADAPI-master/docs/api/ConnectorAnchor.md

@@ -0,0 +1,19 @@
+# ConnectorAnchor
+
+## Class Definition
+
+```python
+class ConnectorAnchor(anchor_kind: str, geometry_ref: Optional[GeometryRef] = None, placement: Optional[Placement] = None, source_component_id: Optional[str] = None, source_connector_id: Optional[str] = None, offset: Optional[Placement] = None)
+```
+
+*Source: product.py*
+
+## Import Surface
+
+- top-level: `from simplecadapi import ConnectorAnchor`
+
+## Description
+
+Serializable source for a connector datum frame.
+
+Supported `anchor_kind` values are `geometry`, `placement`, and `forwarded`.

SimpleCADAPI-master/docs/api/ConnectorRef.md

@@ -0,0 +1,17 @@
+# ConnectorRef
+
+## Class Definition
+
+```python
+class ConnectorRef(component_id: str, connector_id: str)
+```
+
+*Source: product.py*
+
+## Import Surface
+
+- top-level: `from simplecadapi import ConnectorRef`
+
+## Description
+
+Reference to a connector through a component instance.

SimpleCADAPI-master/docs/api/Const.md

@@ -0,0 +1,17 @@
+# Const
+
+## Class Definition
+
+```python
+class Const(value: float, expr_id: str = field(default_factory=lambda : _make_expr_id('const')))
+```
+
+*Source: expr.py*
+
+## Import Surface
+
+- top-level: `from simplecadapi import Const`
+
+## Description
+
+Immutable constant node used in the v2 expression graph.

SimpleCADAPI-master/docs/api/Constraint.md

@@ -0,0 +1,17 @@
+# Constraint
+
+## Class Definition
+
+```python
+class Constraint(constraint_id: str, constraint_kind: ConstraintKind, connector_a: ConnectorRef, connector_b: ConnectorRef, drive_distance: Optional[float] = None, distance_limit: Optional[ScalarLimit] = None, drive_angle_degrees: Optional[float] = None, angle_limit: Optional[ScalarLimit] = None, pitch_radius_a: Optional[float] = None, pitch_radius_b: Optional[float] = None, pulley_radius_a: Optional[float] = None, pulley_radius_b: Optional[float] = None, pitch_radius: Optional[float] = None, phase_offset: Optional[float] = None, name: Optional[str] = None)
+```
+
+*Source: product.py*
+
+## Import Surface
+
+- top-level: `from simplecadapi import Constraint`
+
+## Description
+
+Connector-to-connector assembly constraint.

SimpleCADAPI-master/docs/api/ConstraintReport.md

@@ -0,0 +1,17 @@
+# ConstraintReport
+
+## Class Definition
+
+```python
+class ConstraintReport(solved: bool, grounded_component_ids: Tuple[str, ...], solved_component_ids: Tuple[str, ...], unsolved_component_ids: Tuple[str, ...], residuals: Tuple[ConstraintResidual, ...])
+```
+
+*Source: product.py*
+
+## Import Surface
+
+- top-level: `from simplecadapi import ConstraintReport`
+
+## Description
+
+Assembly constraint inspection report.

SimpleCADAPI-master/docs/api/ConstraintResidual.md

@@ -0,0 +1,17 @@
+# ConstraintResidual
+
+## Class Definition
+
+```python
+class ConstraintResidual(constraint_id: str, translation_error: float, angular_error_degrees: float, within_tolerance: bool)
+```
+
+*Source: product.py*
+
+## Import Surface
+
+- top-level: `from simplecadapi import ConstraintResidual`
+
+## Description
+
+Residual for a single assembly constraint.

SimpleCADAPI-master/docs/api/Expr.md

@@ -0,0 +1,17 @@
+# Expr
+
+## Class Definition
+
+```python
+class Expr(op: str, args: Tuple[ScalarExpr, ...], expr_id: str = field(default_factory=lambda : _make_expr_id('expr')))
+```
+
+*Source: expr.py*
+
+## Import Surface
+
+- top-level: `from simplecadapi import Expr`
+
+## Description
+
+Derived scalar expression node built from one or more operands.

SimpleCADAPI-master/docs/api/ExpressionGraph.md

@@ -0,0 +1,17 @@
+# ExpressionGraph
+
+## Class Definition
+
+```python
+class ExpressionGraph()
+```
+
+*Source: expr.py*
+
+## Import Surface
+
+- top-level: `from simplecadapi import ExpressionGraph`
+
+## Description
+
+A lightweight registry of expression DAG nodes.

SimpleCADAPI-master/docs/api/FreeCADScriptTranslator.md

@@ -0,0 +1,30 @@
+# FreeCADScriptTranslator
+
+## Class Definition
+
+```python
+class FreeCADScriptTranslator(document_name: str = 'SimpleCADModel')
+```
+
+*Source: translator/freecad_translator/script_translator.py*
+
+## Import Surface
+
+- translator backend: `from simplecadapi.translator.freecad_translator import FreeCADScriptTranslator`
+
+## Description
+
+Compile a SimpleCAD model payload into a FreeCAD Python script.
+
+Current design goals:
+
+- Translate only from the canonical low-level `graph` IR
+- Preserve node metadata and graph lineage as FreeCAD custom properties
+- Preserve `expression_graph` as explicit translator metadata
+- Preserve exported assembly constraints as document metadata objects
+- Keep assembly metadata from the full model payload alongside the IR-driven
+geometry translation
+
+The generated script focuses on `Part`-workbench-style objects and shape
+construction, which is a better first target for the current canonical graph
+than a full `Sketcher/PartDesign` mapping.

SimpleCADAPI-master/docs/api/GeometryRef.md

@@ -0,0 +1,22 @@
+# GeometryRef
+
+## Class Definition
+
+```python
+class GeometryRef(kind: str, source_node_id: Optional[str], geo_selector: Dict[str, Any], flip: bool = False)
+```
+
+*Source: product.py*
+
+## Import Surface
+
+- top-level: `from simplecadapi import GeometryRef`
+
+## Description
+
+Serializable reference to a sub-shape selected via QL.
+
+Wraps the geo_selector fingerprint + source graph node id so the
+exact sub-element (Face/Edge/Vertex) can be re-resolved at translation
+time or during constraint solving. When flip is True, the derived
+placement Z axis is negated.

SimpleCADAPI-master/docs/api/GraphSession.md

@@ -0,0 +1,31 @@
+# GraphSession
+
+## Class Definition
+
+```python
+class GraphSession(graph_id: Optional[str] = None)
+```
+
+*Source: graph.py*
+
+## Import Surface
+
+- top-level: `from simplecadapi import GraphSession`
+
+## Description
+
+Context manager that records CAD operations into a DAG.
+
+with GraphSession() as session:
+n1 = record_operation(
+"make_line_redge", {"start": (0, 0, 0), "end": (1, 0, 0)}
+)
+n2 = record_operation(
+"make_line_redge", {"start": (1, 0, 0), "end": (1, 1, 0)}
+)
+record_operation(
+"make_wire_from_edges_rwire", {"edge_count": 2}, inputs=[n1, n2]
+)
+
+# Access the graph after the session
+print(session.graph.topological_order())

SimpleCADAPI-master/docs/api/Material.md

@@ -0,0 +1,17 @@
+# Material
+
+## Class Definition
+
+```python
+class Material(material_id: str, name: Optional[str] = None, density: Optional[float] = None, density_unit: Optional[str] = None, color: Optional[Vec3] = None)
+```
+
+*Source: product.py*
+
+## Import Surface
+
+- top-level: `from simplecadapi import Material`
+
+## Description
+
+Material definition assigned to a Part through `assign_material_rpart`.

SimpleCADAPI-master/docs/api/Part.md

@@ -0,0 +1,17 @@
+# Part
+
+## Class Definition
+
+```python
+class Part(part_id: str, body: Solid, name: Optional[str] = None, material: Optional[Material] = None, connectors: Tuple[Connector, ...] = ())
+```
+
+*Source: product.py*
+
+## Import Surface
+
+- top-level: `from simplecadapi import Part`
+
+## Description
+
+Single-body product item wrapping exactly one Solid.

SimpleCADAPI-master/docs/api/Placement.md

@@ -0,0 +1,17 @@
+# Placement
+
+## Class Definition
+
+```python
+class Placement(origin: Vec3, x_axis: Vec3 = (1.0, 0.0, 0.0), y_axis: Vec3 = (0.0, 1.0, 0.0), z_axis: Vec3 = (0.0, 0.0, 1.0))
+```
+
+*Source: product.py*
+
+## Import Surface
+
+- top-level: `from simplecadapi import Placement`
+
+## Description
+
+Right-handed placement mapping child-local coordinates to parent coordinates.

SimpleCADAPI-master/docs/api/README.md

@@ -0,0 +1,217 @@
+# SimpleCAD API Index
+
+This index includes generated docs for the public SimpleCAD API surface, including geometry operations, graph/model JSON workflows, expressions, QL, and export helpers.
+
+## Import Surfaces
+
+- Entries marked `top-level` are exported from `simplecadapi` and can be imported with `from simplecadapi import <name>`.
+- Entries marked `submodule` are public through the listed submodule, such as `simplecadapi.ql`.
+- Entries marked `translator backend` are public only through `simplecadapi.translator.<backend>`.
+
+## Basic Creation
+
+- [make_2d_cut_rface](make_2d_cut_rface.md) *(from operations.py)* `top-level`
+- [make_2d_intersect_rface](make_2d_intersect_rface.md) *(from operations.py)* `top-level`
+- [make_2d_union_rface](make_2d_union_rface.md) *(from operations.py)* `top-level`
+- [make_angle_arc_redge](make_angle_arc_redge.md) *(from operations.py)* `top-level`
+- [make_angle_arc_rwire](make_angle_arc_rwire.md) *(from operations.py)* `top-level`
+- [make_assembly_rassembly](make_assembly_rassembly.md) *(from operations.py)* `top-level`
+- [make_box_rsolid](make_box_rsolid.md) *(from operations.py)* `top-level`
+- [make_circle_redge](make_circle_redge.md) *(from operations.py)* `top-level`
+- [make_circle_rface](make_circle_rface.md) *(from operations.py)* `top-level`
+- [make_circle_rwire](make_circle_rwire.md) *(from operations.py)* `top-level`
+- [make_compound_from_assembly_rcompound](make_compound_from_assembly_rcompound.md) *(from operations.py)* `top-level`
+- [make_cone_rsolid](make_cone_rsolid.md) *(from operations.py)* `top-level`
+- [make_connector_ref_rconnectorref](make_connector_ref_rconnectorref.md) *(from operations.py)* `top-level`
+- [make_cylinder_rsolid](make_cylinder_rsolid.md) *(from operations.py)* `top-level`
+- [make_edge_connector_rconnector](make_edge_connector_rconnector.md) *(from operations.py)* `top-level`
+- [make_face_connector_rconnector](make_face_connector_rconnector.md) *(from operations.py)* `top-level`
+- [make_face_from_sketch_rface](make_face_from_sketch_rface.md) *(from operations.py)* `top-level`
+- [make_face_from_wire_rface](make_face_from_wire_rface.md) *(from operations.py)* `top-level`
+- [make_face_from_wires_rface](make_face_from_wires_rface.md) *(from operations.py)* `top-level`
+- [make_helix_redge](make_helix_redge.md) *(from operations.py)* `top-level`
+- [make_helix_rwire](make_helix_rwire.md) *(from operations.py)* `top-level`
+- [make_line_redge](make_line_redge.md) *(from operations.py)* `top-level`
+- [make_material_rmaterial](make_material_rmaterial.md) *(from operations.py)* `top-level`
+- [make_part_rpart](make_part_rpart.md) *(from operations.py)* `top-level`
+- [make_placement_connector_rconnector](make_placement_connector_rconnector.md) *(from operations.py)* `top-level`
+- [make_placement_rplacement](make_placement_rplacement.md) *(from operations.py)* `top-level`
+- [make_point_rvertex](make_point_rvertex.md) *(from operations.py)* `top-level`
+- [make_polyline_rwire](make_polyline_rwire.md) *(from operations.py)* `top-level`
+- [make_rectangle_rface](make_rectangle_rface.md) *(from operations.py)* `top-level`
+- [make_rectangle_rwire](make_rectangle_rwire.md) *(from operations.py)* `top-level`
+- [make_scalar_limit_rscalarlimit](make_scalar_limit_rscalarlimit.md) *(from operations.py)* `top-level`
+- [make_segment_redge](make_segment_redge.md) *(from operations.py)* `top-level`
+- [make_segment_rwire](make_segment_rwire.md) *(from operations.py)* `top-level`
+- [make_sketch_rsketch](make_sketch_rsketch.md) *(from operations.py)* `top-level`
+- [make_sphere_rsolid](make_sphere_rsolid.md) *(from operations.py)* `top-level`
+- [make_spline_redge](make_spline_redge.md) *(from operations.py)* `top-level`
+- [make_spline_rwire](make_spline_rwire.md) *(from operations.py)* `top-level`
+- [make_three_point_arc_redge](make_three_point_arc_redge.md) *(from operations.py)* `top-level`
+- [make_three_point_arc_rwire](make_three_point_arc_rwire.md) *(from operations.py)* `top-level`
+- [make_vertex_connector_rconnector](make_vertex_connector_rconnector.md) *(from operations.py)* `top-level`
+- [make_wire_from_edges_rwire](make_wire_from_edges_rwire.md) *(from operations.py)* `top-level`
+- [make_wire_from_sketch_rwire](make_wire_from_sketch_rwire.md) *(from operations.py)* `top-level`
+
+## Transforms
+
+- [mirror_shape](mirror_shape.md) *(from operations.py)* `top-level`
+- [rotate_shape](rotate_shape.md) *(from operations.py)* `top-level`
+- [translate_shape](translate_shape.md) *(from operations.py)* `top-level`
+
+## 3D Operations
+
+- [extrude_rsolid](extrude_rsolid.md) *(from operations.py)* `top-level`
+- [loft_rsolid](loft_rsolid.md) *(from operations.py)* `top-level`
+- [revolve_rsolid](revolve_rsolid.md) *(from operations.py)* `top-level`
+- [sweep_rsolid](sweep_rsolid.md) *(from operations.py)* `top-level`
+
+## Tagging and Selection
+
+- [apply_tag](apply_tag.md) *(from operations.py)* `top-level`
+- [list_tags](list_tags.md) *(from operations.py)* `top-level`
+- [select_edges_by_tag](select_edges_by_tag.md) *(from operations.py)* `top-level`
+- [select_faces_by_tag](select_faces_by_tag.md) *(from operations.py)* `top-level`
+
+## Boolean Operations
+
+- [cut_rsolid](cut_rsolid.md) *(from operations.py)* `top-level`
+- [intersect_rsolid](intersect_rsolid.md) *(from operations.py)* `top-level`
+- [union_rsolid](union_rsolid.md) *(from operations.py)* `top-level`
+
+## Export
+
+- [export_step](export_step.md) *(from operations.py)* `top-level`
+- [export_stl](export_stl.md) *(from operations.py)* `top-level`
+
+## FreeCAD Translation
+
+- [FreeCADScriptTranslator](FreeCADScriptTranslator.md) *(from translator/freecad_translator/script_translator.py)* `translator backend`
+- [translate_model_json_to_fcstd](translate_model_json_to_fcstd.md) *(from translator/freecad_translator/api.py)* `translator backend`
+- [translate_model_json_to_freecad_script](translate_model_json_to_freecad_script.md) *(from translator/freecad_translator/api.py)* `translator backend`
+
+## Math Helpers
+
+- [BSplineFitResult](BSplineFitResult.md) *(from math.py)* `top-level`
+- [fit_cubic_bspline_control_points](fit_cubic_bspline_control_points.md) *(from math.py)* `top-level`
+
+## Modeling Graph and Replay
+
+- [GraphSession](GraphSession.md) *(from graph.py)* `top-level`
+- [export_graph_json](export_graph_json.md) *(from serializer.py)* `top-level`
+- [export_model_json](export_model_json.md) *(from serializer.py)* `top-level`
+- [export_session_json](export_session_json.md) *(from serializer.py)* `top-level`
+- [import_graph_json](import_graph_json.md) *(from serializer.py)* `top-level`
+- [import_model_json](import_model_json.md) *(from serializer.py)* `top-level`
+- [import_session_json](import_session_json.md) *(from serializer.py)* `top-level`
+- [replay_graph](replay_graph.md) *(from serializer.py)* `top-level`
+- [replay_model_json](replay_model_json.md) *(from serializer.py)* `top-level`
+- [suspend_graph_recording](suspend_graph_recording.md) *(from graph.py)* `top-level`
+
+## Expressions and Parameters
+
+- [Const](Const.md) *(from expr.py)* `top-level`
+- [Expr](Expr.md) *(from expr.py)* `top-level`
+- [ExpressionGraph](ExpressionGraph.md) *(from expr.py)* `top-level`
+- [Var](Var.md) *(from expr.py)* `top-level`
+- [const](const_function.md) *(from expr.py)* `top-level`
+- [var](var_function.md) *(from expr.py)* `top-level`
+
+## Types and Errors
+
+- [SimpleCADError](SimpleCADError.md) *(from errors.py)* `top-level`
+- [Sketch](Sketch.md) *(from sketch.py)* `top-level`
+- [SketchConstraint](SketchConstraint.md) *(from sketch.py)* `top-level`
+- [SketchConstraintDiagnostic](SketchConstraintDiagnostic.md) *(from sketch.py)* `top-level`
+- [SketchRef](SketchRef.md) *(from sketch.py)* `top-level`
+- [SketchSolveResult](SketchSolveResult.md) *(from sketch.py)* `top-level`
+
+## Advanced Features
+
+- [chamfer_rsolid](chamfer_rsolid.md) *(from operations.py)* `top-level`
+- [fillet_rsolid](fillet_rsolid.md) *(from operations.py)* `top-level`
+- [helical_sweep_rsolid](helical_sweep_rsolid.md) *(from operations.py)* `top-level`
+- [shell_rsolid](shell_rsolid.md) *(from operations.py)* `top-level`
+
+## Evolve
+
+- [make_n_hole_flange_rsolid](make_n_hole_flange_rsolid.md) *(from evolve.py)* `top-level`
+- [make_naca_propeller_blade_rsolid](make_naca_propeller_blade_rsolid.md) *(from evolve.py)* `top-level`
+- [make_threaded_rod_rsolid](make_threaded_rod_rsolid.md) *(from evolve.py)* `top-level`
+
+## Other
+
+- [Assembly](Assembly.md) *(from product.py)* `top-level`
+- [Component](Component.md) *(from product.py)* `top-level`
+- [Connector](Connector.md) *(from product.py)* `top-level`
+- [ConnectorAnchor](ConnectorAnchor.md) *(from product.py)* `top-level`
+- [ConnectorRef](ConnectorRef.md) *(from product.py)* `top-level`
+- [Constraint](Constraint.md) *(from product.py)* `top-level`
+- [ConstraintReport](ConstraintReport.md) *(from product.py)* `top-level`
+- [ConstraintResidual](ConstraintResidual.md) *(from product.py)* `top-level`
+- [GeometryRef](GeometryRef.md) *(from product.py)* `top-level`
+- [Material](Material.md) *(from product.py)* `top-level`
+- [Part](Part.md) *(from product.py)* `top-level`
+- [Placement](Placement.md) *(from product.py)* `top-level`
+- [ScalarLimit](ScalarLimit.md) *(from product.py)* `top-level`
+- [SemanticDelta](SemanticDelta.md) *(from topology.py)* `top-level`
+- [SemanticRef](SemanticRef.md) *(from topology.py)* `top-level`
+- [add_arc_rsketch](add_arc_rsketch.md) *(from operations.py)* `top-level`
+- [add_belt_constraint_rassembly](add_belt_constraint_rassembly.md) *(from operations.py)* `top-level`
+- [add_bspline_rsketch](add_bspline_rsketch.md) *(from operations.py)* `top-level`
+- [add_circle_rsketch](add_circle_rsketch.md) *(from operations.py)* `top-level`
+- [add_component_rassembly](add_component_rassembly.md) *(from operations.py)* `top-level`
+- [add_connector_rassembly](add_connector_rassembly.md) *(from operations.py)* `top-level`
+- [add_connector_rpart](add_connector_rpart.md) *(from operations.py)* `top-level`
+- [add_fixed_constraint_rassembly](add_fixed_constraint_rassembly.md) *(from operations.py)* `top-level`
+- [add_gear_constraint_rassembly](add_gear_constraint_rassembly.md) *(from operations.py)* `top-level`
+- [add_line_rsketch](add_line_rsketch.md) *(from operations.py)* `top-level`
+- [add_point_rsketch](add_point_rsketch.md) *(from operations.py)* `top-level`
+- [add_prismatic_constraint_rassembly](add_prismatic_constraint_rassembly.md) *(from operations.py)* `top-level`
+- [add_rack_pinion_constraint_rassembly](add_rack_pinion_constraint_rassembly.md) *(from operations.py)* `top-level`
+- [add_revolute_constraint_rassembly](add_revolute_constraint_rassembly.md) *(from operations.py)* `top-level`
+- [and_](and_.md) *(from ql.py)* `submodule:ql`
+- [assign_material_rpart](assign_material_rpart.md) *(from operations.py)* `top-level`
+- [constrain_angle_rsketch](constrain_angle_rsketch.md) *(from operations.py)* `top-level`
+- [constrain_coincident_rsketch](constrain_coincident_rsketch.md) *(from operations.py)* `top-level`
+- [constrain_collinear_rsketch](constrain_collinear_rsketch.md) *(from operations.py)* `top-level`
+- [constrain_concentric_rsketch](constrain_concentric_rsketch.md) *(from operations.py)* `top-level`
+- [constrain_connect_rsketch](constrain_connect_rsketch.md) *(from operations.py)* `top-level`
+- [constrain_diameter_rsketch](constrain_diameter_rsketch.md) *(from operations.py)* `top-level`
+- [constrain_distance_rsketch](constrain_distance_rsketch.md) *(from operations.py)* `top-level`
+- [constrain_distance_x_rsketch](constrain_distance_x_rsketch.md) *(from operations.py)* `top-level`
+- [constrain_distance_y_rsketch](constrain_distance_y_rsketch.md) *(from operations.py)* `top-level`
+- [constrain_equal_length_rsketch](constrain_equal_length_rsketch.md) *(from operations.py)* `top-level`
+- [constrain_equal_radius_rsketch](constrain_equal_radius_rsketch.md) *(from operations.py)* `top-level`
+- [constrain_fix_rsketch](constrain_fix_rsketch.md) *(from operations.py)* `top-level`
+- [constrain_horizontal_rsketch](constrain_horizontal_rsketch.md) *(from operations.py)* `top-level`
+- [constrain_length_rsketch](constrain_length_rsketch.md) *(from operations.py)* `top-level`
+- [constrain_midpoint_rsketch](constrain_midpoint_rsketch.md) *(from operations.py)* `top-level`
+- [constrain_parallel_rsketch](constrain_parallel_rsketch.md) *(from operations.py)* `top-level`
+- [constrain_perpendicular_rsketch](constrain_perpendicular_rsketch.md) *(from operations.py)* `top-level`
+- [constrain_point_on_rsketch](constrain_point_on_rsketch.md) *(from operations.py)* `top-level`
+- [constrain_radius_rsketch](constrain_radius_rsketch.md) *(from operations.py)* `top-level`
+- [constrain_symmetric_rsketch](constrain_symmetric_rsketch.md) *(from operations.py)* `top-level`
+- [constrain_tangent_rsketch](constrain_tangent_rsketch.md) *(from operations.py)* `top-level`
+- [constrain_vertical_rsketch](constrain_vertical_rsketch.md) *(from operations.py)* `top-level`
+- [forward_connector_rassembly](forward_connector_rassembly.md) *(from operations.py)* `top-level`
+- [geo](geo.md) *(from ql.py)* `submodule:ql`
+- [get_sketch_entity_rsketchref](get_sketch_entity_rsketchref.md) *(from operations.py)* `top-level`
+- [get_sketch_point_rsketchref](get_sketch_point_rsketchref.md) *(from operations.py)* `top-level`
+- [ground_component_rassembly](ground_component_rassembly.md) *(from operations.py)* `top-level`
+- [identity_placement_rplacement](identity_placement_rplacement.md) *(from operations.py)* `top-level`
+- [inspect_assembly_constraints_rconstraintreport](inspect_assembly_constraints_rconstraintreport.md) *(from operations.py)* `top-level`
+- [inspect_sketch_rsketchresult](inspect_sketch_rsketchresult.md) *(from operations.py)* `top-level`
+- [linear_pattern_rsolidlist](linear_pattern_rsolidlist.md) *(from operations.py)* `top-level`
+- [measure_constraint_residual_rconstraintresidual](measure_constraint_residual_rconstraintresidual.md) *(from operations.py)* `top-level`
+- [meta](meta.md) *(from ql.py)* `submodule:ql`
+- [not_](not_.md) *(from ql.py)* `submodule:ql`
+- [or_](or_.md) *(from ql.py)* `submodule:ql`
+- [place_component_rassembly](place_component_rassembly.md) *(from operations.py)* `top-level`
+- [radial_pattern_rsolidlist](radial_pattern_rsolidlist.md) *(from operations.py)* `top-level`
+- [render_screenshot_rpath](render_screenshot_rpath.md) *(from operations.py)* `top-level`
+- [select](select.md) *(from ql.py)* `submodule:ql`
+- [solve_assembly_constraints_rassembly](solve_assembly_constraints_rassembly.md) *(from operations.py)* `top-level`
+- [tag](tag.md) *(from ql.py)* `submodule:ql`
+- [unground_component_rassembly](unground_component_rassembly.md) *(from operations.py)* `top-level`
+- [value](value.md) *(from ql.py)* `submodule:ql`

SimpleCADAPI-master/docs/api/ScalarLimit.md

@@ -0,0 +1,17 @@
+# ScalarLimit
+
+## Class Definition
+
+```python
+class ScalarLimit(lower_value: float, upper_value: float)
+```
+
+*Source: product.py*
+
+## Import Surface
+
+- top-level: `from simplecadapi import ScalarLimit`
+
+## Description
+
+Closed scalar range for a constraint drive coordinate.

SimpleCADAPI-master/docs/api/SemanticDelta.md

@@ -0,0 +1,17 @@
+# SemanticDelta
+
+## Class Definition
+
+```python
+class SemanticDelta(created: Tuple[SemanticRef, ...] = (), modified: Tuple[SemanticRef, ...] = (), deleted: Tuple[SemanticRef, ...] = (), metadata: Dict[str, Any] = field(default_factory=dict))
+```
+
+*Source: topology.py*
+
+## Import Surface
+
+- top-level: `from simplecadapi import SemanticDelta`
+
+## Description
+
+Semantic entity change set attached to a single recorded operation.

SimpleCADAPI-master/docs/api/SemanticRef.md

@@ -0,0 +1,17 @@
+# SemanticRef
+
+## Class Definition
+
+```python
+class SemanticRef(graph_id: str, node_id: str, entity_type: str, entity_id: str)
+```
+
+*Source: topology.py*
+
+## Import Surface
+
+- top-level: `from simplecadapi import SemanticRef`
+
+## Description
+
+Stable reference to a semantic model entity in the recorded graph.

SimpleCADAPI-master/docs/api/SimpleCADError.md

@@ -0,0 +1,17 @@
+# SimpleCADError
+
+## Class Definition
+
+```python
+class SimpleCADError(operation: str, guidance: ErrorGuidance)
+```
+
+*Source: errors.py*
+
+## Import Surface
+
+- top-level: `from simplecadapi import SimpleCADError`
+
+## Description
+
+Structured ValueError variant for LLM-oriented repair guidance.

SimpleCADAPI-master/docs/api/Sketch.md

@@ -0,0 +1,24 @@
+# Sketch
+
+## Class Definition
+
+```python
+class Sketch(curves: Iterable[Edge | Wire] | None = None, *, name: Optional[str] = None, plane: Any = 'XY', sketch_id: Optional[str] = None)
+```
+
+*Source: sketch.py*
+
+## Import Surface
+
+- top-level: `from simplecadapi import Sketch`
+
+## Description
+
+Declarative constrained sketch container.
+
+Use `make_sketch_rsketch(...)`, `add_point_rsketch(...)`,
+`add_line_rsketch(...)`, `add_circle_rsketch(...)`, and
+`constrain_*_rsketch(...)` as the canonical API for building sketch
+profiles. Public sketch construction APIs are functional and return an
+updated `Sketch` document. The legacy `curves` constructor remains only for
+reading already-built wire/edge containers.

SimpleCADAPI-master/docs/api/SketchConstraint.md

@@ -0,0 +1,17 @@
+# SketchConstraint
+
+## Class Definition
+
+```python
+class SketchConstraint(constraint_id: str, kind: str, targets: Tuple[Dict[str, Any], ...], value: Any = None, driving: bool = True, metadata: Dict[str, Any] = field(default_factory=dict))
+```
+
+*Source: sketch.py*
+
+## Import Surface
+
+- top-level: `from simplecadapi import SketchConstraint`
+
+## Description
+
+Serializable constraint inside a declarative sketch.

SimpleCADAPI-master/docs/api/SketchConstraintDiagnostic.md

@@ -0,0 +1,17 @@
+# SketchConstraintDiagnostic
+
+## Class Definition
+
+```python
+class SketchConstraintDiagnostic(constraint_id: Optional[str], severity: str, code: str, message: str, residual: Optional[float] = None)
+```
+
+*Source: sketch.py*
+
+## Import Surface
+
+- top-level: `from simplecadapi import SketchConstraintDiagnostic`
+
+## Description
+
+Diagnostic emitted by the sketch solver.

SimpleCADAPI-master/docs/api/SketchRef.md

@@ -0,0 +1,17 @@
+# SketchRef
+
+## Class Definition
+
+```python
+class SketchRef(sketch_id: str, entity_id: str, *, kind: str, subentity: str = 'geometry')
+```
+
+*Source: sketch.py*
+
+## Import Surface
+
+- top-level: `from simplecadapi import SketchRef`
+
+## Description
+
+Stable reference to a sketch entity or subentity.

SimpleCADAPI-master/docs/api/SketchSolveResult.md

@@ -0,0 +1,17 @@
+# SketchSolveResult
+
+## Class Definition
+
+```python
+class SketchSolveResult(sketch_id: str, status: str, dof: int, residual_norm: float, iterations: int, solved_points: Dict[str, Tuple[float, float]], solved_scalars: Dict[str, float], diagnostics: Tuple[SketchConstraintDiagnostic, ...] = ())
+```
+
+*Source: sketch.py*
+
+## Import Surface
+
+- top-level: `from simplecadapi import SketchSolveResult`
+
+## Description
+
+Result of solving a declarative sketch.

SimpleCADAPI-master/docs/api/Var.md

@@ -0,0 +1,17 @@
+# Var
+
+## Class Definition
+
+```python
+class Var(name: str, default: float, comment: str | None = None, expr_id: str = field(default_factory=lambda : _make_expr_id('var')))
+```
+
+*Source: expr.py*
+
+## Import Surface
+
+- top-level: `from simplecadapi import Var`
+
+## Description
+
+Named scalar parameter with a default fallback value.

SimpleCADAPI-master/docs/api/add_arc_rsketch.md

@@ -0,0 +1,17 @@
+# add_arc_rsketch
+
+## API Definition
+
+```python
+def add_arc_rsketch(sketch: Sketch, entity_id: str, start: Union[SketchRef, str], end: Union[SketchRef, str], center: Union[SketchRef, str], *, construction: bool = False) -> Sketch
+```
+
+*Source: operations.py*
+
+## Import Surface
+
+- top-level: `from simplecadapi import add_arc_rsketch`
+
+## Description
+
+Add an arc entity to a sketch.

SimpleCADAPI-master/docs/api/add_belt_constraint_rassembly.md

@@ -0,0 +1,17 @@
+# add_belt_constraint_rassembly
+
+## API Definition
+
+```python
+def add_belt_constraint_rassembly(assembly: Assembly, constraint_id: str, connector_a: ConnectorRef, connector_b: ConnectorRef, pulley_radius_a: float, pulley_radius_b: float, phase_offset: Optional[float] = None, name: Optional[str] = None) -> Assembly
+```
+
+*Source: operations.py*
+
+## Import Surface
+
+- top-level: `from simplecadapi import add_belt_constraint_rassembly`
+
+## Description
+
+Couple two revolute axes as belt-linked pulleys with same-direction rotation.

SimpleCADAPI-master/docs/api/add_bspline_rsketch.md

@@ -0,0 +1,20 @@
+# add_bspline_rsketch
+
+## API Definition
+
+```python
+def add_bspline_rsketch(sketch: Sketch, entity_id: str, start: Union[SketchRef, str], end: Union[SketchRef, str], control_points: Sequence[Sequence[float]], degree: int = 3, knots: Optional[Sequence[float]] = None, multiplicities: Optional[Sequence[int]] = None, weights: Optional[Sequence[float]] = None, periodic: bool = False, *, construction: bool = False) -> Sketch
+```
+
+*Source: operations.py*
+
+## Import Surface
+
+- top-level: `from simplecadapi import add_bspline_rsketch`
+
+## Description
+
+Add a B-spline curve entity to a sketch.
+
+The start/end point refs link the B-spline into a closed profile
+loop.  Control points are stored as literal 2-D coordinates.

SimpleCADAPI-master/docs/api/add_circle_rsketch.md

@@ -0,0 +1,17 @@
+# add_circle_rsketch
+
+## API Definition
+
+```python
+def add_circle_rsketch(sketch: Sketch, entity_id: str, center: Union[SketchRef, str], radius: ScalarLike, *, construction: bool = False) -> Sketch
+```
+
+*Source: operations.py*
+
+## Import Surface
+
+- top-level: `from simplecadapi import add_circle_rsketch`
+
+## Description
+
+Add a named circle entity and return an updated sketch document.

SimpleCADAPI-master/docs/api/add_component_rassembly.md

@@ -0,0 +1,17 @@
+# add_component_rassembly
+
+## API Definition
+
+```python
+def add_component_rassembly(assembly: Assembly, item: Union[Part, Assembly], component_id: str, placement: Placement, name: Optional[str] = None) -> Assembly
+```
+
+*Source: operations.py*
+
+## Import Surface
+
+- top-level: `from simplecadapi import add_component_rassembly`
+
+## Description
+
+Add a placed Part or subassembly component instance to an Assembly.

SimpleCADAPI-master/docs/api/add_connector_rassembly.md

@@ -0,0 +1,17 @@
+# add_connector_rassembly
+
+## API Definition
+
+```python
+def add_connector_rassembly(assembly: Assembly, connector: Connector) -> Assembly
+```
+
+*Source: operations.py*
+
+## Import Surface
+
+- top-level: `from simplecadapi import add_connector_rassembly`
+
+## Description
+
+Attach a connector datum frame to an Assembly definition.

SimpleCADAPI-master/docs/api/add_connector_rpart.md

@@ -0,0 +1,17 @@
+# add_connector_rpart
+
+## API Definition
+
+```python
+def add_connector_rpart(part: Part, connector: Connector) -> Part
+```
+
+*Source: operations.py*
+
+## Import Surface
+
+- top-level: `from simplecadapi import add_connector_rpart`
+
+## Description
+
+Attach a connector datum frame to a Part definition.

SimpleCADAPI-master/docs/api/add_fixed_constraint_rassembly.md

@@ -0,0 +1,17 @@
+# add_fixed_constraint_rassembly
+
+## API Definition
+
+```python
+def add_fixed_constraint_rassembly(assembly: Assembly, constraint_id: str, connector_a: ConnectorRef, connector_b: ConnectorRef, name: Optional[str] = None) -> Assembly
+```
+
+*Source: operations.py*
+
+## Import Surface
+
+- top-level: `from simplecadapi import add_fixed_constraint_rassembly`
+
+## Description
+
+Constrain two component connectors to the same frame.

SimpleCADAPI-master/docs/api/add_gear_constraint_rassembly.md

@@ -0,0 +1,17 @@
+# add_gear_constraint_rassembly
+
+## API Definition
+
+```python
+def add_gear_constraint_rassembly(assembly: Assembly, constraint_id: str, connector_a: ConnectorRef, connector_b: ConnectorRef, pitch_radius_a: float, pitch_radius_b: float, phase_offset: Optional[float] = None, name: Optional[str] = None) -> Assembly
+```
+
+*Source: operations.py*
+
+## Import Surface
+
+- top-level: `from simplecadapi import add_gear_constraint_rassembly`
+
+## Description
+
+Couple two revolute axes as meshing gears with inverse rotation.

SimpleCADAPI-master/docs/api/add_line_rsketch.md

@@ -0,0 +1,17 @@
+# add_line_rsketch
+
+## API Definition
+
+```python
+def add_line_rsketch(sketch: Sketch, entity_id: str, start: Union[SketchRef, str], end: Union[SketchRef, str], *, construction: bool = False) -> Sketch
+```
+
+*Source: operations.py*
+
+## Import Surface
+
+- top-level: `from simplecadapi import add_line_rsketch`
+
+## Description
+
+Add a named line entity and return an updated sketch document.

SimpleCADAPI-master/docs/api/add_point_rsketch.md

@@ -0,0 +1,17 @@
+# add_point_rsketch
+
+## API Definition
+
+```python
+def add_point_rsketch(sketch: Sketch, point_id: str, x: ScalarLike, y: ScalarLike) -> Sketch
+```
+
+*Source: operations.py*
+
+## Import Surface
+
+- top-level: `from simplecadapi import add_point_rsketch`
+
+## Description
+
+Add a named point entity and return an updated sketch document.

SimpleCADAPI-master/docs/api/add_prismatic_constraint_rassembly.md

@@ -0,0 +1,17 @@
+# add_prismatic_constraint_rassembly
+
+## API Definition
+
+```python
+def add_prismatic_constraint_rassembly(assembly: Assembly, constraint_id: str, connector_a: ConnectorRef, connector_b: ConnectorRef, drive_distance: Optional[float] = None, distance_limit: Optional[ScalarLimit] = None, name: Optional[str] = None) -> Assembly
+```
+
+*Source: operations.py*
+
+## Import Surface
+
+- top-level: `from simplecadapi import add_prismatic_constraint_rassembly`
+
+## Description
+
+Constrain two connectors as a prismatic slider pair.

SimpleCADAPI-master/docs/api/add_rack_pinion_constraint_rassembly.md

@@ -0,0 +1,17 @@
+# add_rack_pinion_constraint_rassembly
+
+## API Definition
+
+```python
+def add_rack_pinion_constraint_rassembly(assembly: Assembly, constraint_id: str, rack_connector: ConnectorRef, pinion_connector: ConnectorRef, pitch_radius: float, phase_offset: Optional[float] = None, name: Optional[str] = None) -> Assembly
+```
+
+*Source: operations.py*
+
+## Import Surface
+
+- top-level: `from simplecadapi import add_rack_pinion_constraint_rassembly`
+
+## Description
+
+Couple a prismatic rack axis to a revolute pinion axis.

SimpleCADAPI-master/docs/api/add_revolute_constraint_rassembly.md

@@ -0,0 +1,17 @@
+# add_revolute_constraint_rassembly
+
+## API Definition
+
+```python
+def add_revolute_constraint_rassembly(assembly: Assembly, constraint_id: str, connector_a: ConnectorRef, connector_b: ConnectorRef, drive_angle_degrees: Optional[float] = None, angle_limit: Optional[ScalarLimit] = None, name: Optional[str] = None) -> Assembly
+```
+
+*Source: operations.py*
+
+## Import Surface
+
+- top-level: `from simplecadapi import add_revolute_constraint_rassembly`
+
+## Description
+
+Constrain two connectors as a revolute axis pair.

SimpleCADAPI-master/docs/api/and_.md

@@ -0,0 +1,17 @@
+# and_
+
+## API Definition
+
+```python
+def and_(*predicates: Predicate) -> Predicate
+```
+
+*Source: ql.py*
+
+## Import Surface
+
+- submodule: `from simplecadapi.ql import and_` or `simplecadapi.ql.and_`
+
+## Description
+
+Combine predicates so all of them must match.

SimpleCADAPI-master/docs/api/apply_tag.md

@@ -0,0 +1,23 @@
+# apply_tag
+
+## API Definition
+
+```python
+def apply_tag(shape: AnyShape, tag: str) -> AnyShape
+```
+
+*Source: operations.py*
+
+## Import Surface
+
+- top-level: `from simplecadapi import apply_tag`
+
+## Description
+
+Attach a normalized tag to a shape using the standard propagation policy.
+
+Tags must already be normalized lowercase tokens such as
+``role.mounting_surface`` or ``group.fasteners``. Propagation is intentionally
+not configurable from the public API; the default tag policy propagates
+semantic role/anchor/group tags downward and keeps topology-specific tags
+local.

SimpleCADAPI-master/docs/api/assign_material_rpart.md

@@ -0,0 +1,17 @@
+# assign_material_rpart
+
+## API Definition
+
+```python
+def assign_material_rpart(part: Part, material: Material) -> Part
+```
+
+*Source: operations.py*
+
+## Import Surface
+
+- top-level: `from simplecadapi import assign_material_rpart`
+
+## Description
+
+Assign a Material to a Part and return the updated Part.

SimpleCADAPI-master/docs/api/chamfer_rsolid.md

@@ -0,0 +1,17 @@
+# chamfer_rsolid
+
+## API Definition
+
+```python
+def chamfer_rsolid(solid: Solid, edges: Union[Sequence[Edge], ShapeSelector], distance: ScalarLike) -> Solid
+```
+
+*Source: operations.py*
+
+## Import Surface
+
+- top-level: `from simplecadapi import chamfer_rsolid`
+
+## Description
+
+Apply chamfers to selected solid edges.

SimpleCADAPI-master/docs/api/const_function.md

@@ -0,0 +1,17 @@
+# const
+
+## API Definition
+
+```python
+def const(value: int | float) -> Const
+```
+
+*Source: expr.py*
+
+## Import Surface
+
+- top-level: `from simplecadapi import const`
+
+## Description
+
+Create a constant scalar node for parameterized modeling.

SimpleCADAPI-master/docs/api/constrain_angle_rsketch.md

@@ -0,0 +1,17 @@
+# constrain_angle_rsketch
+
+## API Definition
+
+```python
+def constrain_angle_rsketch(sketch: Sketch, a: Union[SketchRef, str], b: Union[SketchRef, str], value: ScalarLike, *, constraint_id: Optional[str] = None, driving: bool = True) -> Sketch
+```
+
+*Source: operations.py*
+
+## Import Surface
+
+- top-level: `from simplecadapi import constrain_angle_rsketch`
+
+## Description
+
+Add a driving angle constraint between two sketch lines.

SimpleCADAPI-master/docs/api/constrain_coincident_rsketch.md

@@ -0,0 +1,17 @@
+# constrain_coincident_rsketch
+
+## API Definition
+
+```python
+def constrain_coincident_rsketch(sketch: Sketch, a: Union[SketchRef, str], b: Union[SketchRef, str], *, constraint_id: Optional[str] = None) -> Sketch
+```
+
+*Source: operations.py*
+
+## Import Surface
+
+- top-level: `from simplecadapi import constrain_coincident_rsketch`
+
+## Description
+
+Constrain two sketch points to be coincident.

SimpleCADAPI-master/docs/api/constrain_collinear_rsketch.md

@@ -0,0 +1,17 @@
+# constrain_collinear_rsketch
+
+## API Definition
+
+```python
+def constrain_collinear_rsketch(sketch: Sketch, a: Union[SketchRef, str], b: Union[SketchRef, str], *, constraint_id: Optional[str] = None) -> Sketch
+```
+
+*Source: operations.py*
+
+## Import Surface
+
+- top-level: `from simplecadapi import constrain_collinear_rsketch`
+
+## Description
+
+Constrain two sketch lines to lie on the same infinite line.

SimpleCADAPI-master/docs/api/constrain_concentric_rsketch.md

@@ -0,0 +1,17 @@
+# constrain_concentric_rsketch
+
+## API Definition
+
+```python
+def constrain_concentric_rsketch(sketch: Sketch, a: Union[SketchRef, str], b: Union[SketchRef, str], *, constraint_id: Optional[str] = None) -> Sketch
+```
+
+*Source: operations.py*
+
+## Import Surface
+
+- top-level: `from simplecadapi import constrain_concentric_rsketch`
+
+## Description
+
+Constrain two sketch circles to share a center.

SimpleCADAPI-master/docs/api/constrain_connect_rsketch.md

@@ -0,0 +1,17 @@
+# constrain_connect_rsketch
+
+## API Definition
+
+```python
+def constrain_connect_rsketch(sketch: Sketch, a: Union[SketchRef, str], b: Union[SketchRef, str], *, constraint_id: Optional[str] = None) -> Sketch
+```
+
+*Source: operations.py*
+
+## Import Surface
+
+- top-level: `from simplecadapi import constrain_connect_rsketch`
+
+## Description
+
+Alias for `constrain_coincident_rsketch` using connection wording.

SimpleCADAPI-master/docs/api/constrain_diameter_rsketch.md

@@ -0,0 +1,17 @@
+# constrain_diameter_rsketch
+
+## API Definition
+
+```python
+def constrain_diameter_rsketch(sketch: Sketch, circle: Union[SketchRef, str], value: ScalarLike, *, constraint_id: Optional[str] = None, driving: bool = True) -> Sketch
+```
+
+*Source: operations.py*
+
+## Import Surface
+
+- top-level: `from simplecadapi import constrain_diameter_rsketch`
+
+## Description
+
+Add a driving circle diameter constraint.

SimpleCADAPI-master/docs/api/constrain_distance_rsketch.md

@@ -0,0 +1,17 @@
+# constrain_distance_rsketch
+
+## API Definition
+
+```python
+def constrain_distance_rsketch(sketch: Sketch, a: Union[SketchRef, str], b: Union[SketchRef, str], value: ScalarLike, *, constraint_id: Optional[str] = None, driving: bool = True) -> Sketch
+```
+
+*Source: operations.py*
+
+## Import Surface
+
+- top-level: `from simplecadapi import constrain_distance_rsketch`
+
+## Description
+
+Add a driving point-to-point distance constraint.

SimpleCADAPI-master/docs/api/constrain_distance_x_rsketch.md

@@ -0,0 +1,17 @@
+# constrain_distance_x_rsketch
+
+## API Definition
+
+```python
+def constrain_distance_x_rsketch(sketch: Sketch, a: Union[SketchRef, str], b: Union[SketchRef, str], value: ScalarLike, *, constraint_id: Optional[str] = None, driving: bool = True) -> Sketch
+```
+
+*Source: operations.py*
+
+## Import Surface
+
+- top-level: `from simplecadapi import constrain_distance_x_rsketch`
+
+## Description
+
+Add a driving horizontal distance constraint.

SimpleCADAPI-master/docs/api/constrain_distance_y_rsketch.md

@@ -0,0 +1,17 @@
+# constrain_distance_y_rsketch
+
+## API Definition
+
+```python
+def constrain_distance_y_rsketch(sketch: Sketch, a: Union[SketchRef, str], b: Union[SketchRef, str], value: ScalarLike, *, constraint_id: Optional[str] = None, driving: bool = True) -> Sketch
+```
+
+*Source: operations.py*
+
+## Import Surface
+
+- top-level: `from simplecadapi import constrain_distance_y_rsketch`
+
+## Description
+
+Add a driving vertical distance constraint.

SimpleCADAPI-master/docs/api/constrain_equal_length_rsketch.md

@@ -0,0 +1,17 @@
+# constrain_equal_length_rsketch
+
+## API Definition
+
+```python
+def constrain_equal_length_rsketch(sketch: Sketch, a: Union[SketchRef, str], b: Union[SketchRef, str], *, constraint_id: Optional[str] = None) -> Sketch
+```
+
+*Source: operations.py*
+
+## Import Surface
+
+- top-level: `from simplecadapi import constrain_equal_length_rsketch`
+
+## Description
+
+Constrain two sketch lines to have equal length.

SimpleCADAPI-master/docs/api/constrain_equal_radius_rsketch.md

@@ -0,0 +1,17 @@
+# constrain_equal_radius_rsketch
+
+## API Definition
+
+```python
+def constrain_equal_radius_rsketch(sketch: Sketch, a: Union[SketchRef, str], b: Union[SketchRef, str], *, constraint_id: Optional[str] = None) -> Sketch
+```
+
+*Source: operations.py*
+
+## Import Surface
+
+- top-level: `from simplecadapi import constrain_equal_radius_rsketch`
+
+## Description
+
+Constrain two sketch circles to have equal radius.

SimpleCADAPI-master/docs/api/constrain_fix_rsketch.md

@@ -0,0 +1,17 @@
+# constrain_fix_rsketch
+
+## API Definition
+
+```python
+def constrain_fix_rsketch(sketch: Sketch, target: Union[SketchRef, str], *, constraint_id: Optional[str] = None) -> Sketch
+```
+
+*Source: operations.py*
+
+## Import Surface
+
+- top-level: `from simplecadapi import constrain_fix_rsketch`
+
+## Description
+
+Fix a sketch point or entity to its initial coordinates.

SimpleCADAPI-master/docs/api/constrain_horizontal_rsketch.md

@@ -0,0 +1,17 @@
+# constrain_horizontal_rsketch
+
+## API Definition
+
+```python
+def constrain_horizontal_rsketch(sketch: Sketch, line: Union[SketchRef, str], *, constraint_id: Optional[str] = None) -> Sketch
+```
+
+*Source: operations.py*
+
+## Import Surface
+
+- top-level: `from simplecadapi import constrain_horizontal_rsketch`
+
+## Description
+
+Constrain a sketch line to be horizontal.

SimpleCADAPI-master/docs/api/constrain_length_rsketch.md

@@ -0,0 +1,17 @@
+# constrain_length_rsketch
+
+## API Definition
+
+```python
+def constrain_length_rsketch(sketch: Sketch, line: Union[SketchRef, str], value: ScalarLike, *, constraint_id: Optional[str] = None, driving: bool = True) -> Sketch
+```
+
+*Source: operations.py*
+
+## Import Surface
+
+- top-level: `from simplecadapi import constrain_length_rsketch`
+
+## Description
+
+Add a driving line length constraint.

SimpleCADAPI-master/docs/api/constrain_midpoint_rsketch.md

@@ -0,0 +1,17 @@
+# constrain_midpoint_rsketch
+
+## API Definition
+
+```python
+def constrain_midpoint_rsketch(sketch: Sketch, point: Union[SketchRef, str], line: Union[SketchRef, str], *, constraint_id: Optional[str] = None) -> Sketch
+```
+
+*Source: operations.py*
+
+## Import Surface
+
+- top-level: `from simplecadapi import constrain_midpoint_rsketch`
+
+## Description
+
+Constrain a sketch point to the midpoint of a line.

SimpleCADAPI-master/docs/api/constrain_parallel_rsketch.md

@@ -0,0 +1,17 @@
+# constrain_parallel_rsketch
+
+## API Definition
+
+```python
+def constrain_parallel_rsketch(sketch: Sketch, a: Union[SketchRef, str], b: Union[SketchRef, str], *, constraint_id: Optional[str] = None) -> Sketch
+```
+
+*Source: operations.py*
+
+## Import Surface
+
+- top-level: `from simplecadapi import constrain_parallel_rsketch`
+
+## Description
+
+Constrain two sketch lines to be parallel.

SimpleCADAPI-master/docs/api/constrain_perpendicular_rsketch.md

@@ -0,0 +1,17 @@
+# constrain_perpendicular_rsketch
+
+## API Definition
+
+```python
+def constrain_perpendicular_rsketch(sketch: Sketch, a: Union[SketchRef, str], b: Union[SketchRef, str], *, constraint_id: Optional[str] = None) -> Sketch
+```
+
+*Source: operations.py*
+
+## Import Surface
+
+- top-level: `from simplecadapi import constrain_perpendicular_rsketch`
+
+## Description
+
+Constrain two sketch lines to be perpendicular.

SimpleCADAPI-master/docs/api/constrain_point_on_rsketch.md

@@ -0,0 +1,17 @@
+# constrain_point_on_rsketch
+
+## API Definition
+
+```python
+def constrain_point_on_rsketch(sketch: Sketch, point: Union[SketchRef, str], entity: Union[SketchRef, str], *, constraint_id: Optional[str] = None) -> Sketch
+```
+
+*Source: operations.py*
+
+## Import Surface
+
+- top-level: `from simplecadapi import constrain_point_on_rsketch`
+
+## Description
+
+Constrain a sketch point to lie on a line or circle.

SimpleCADAPI-master/docs/api/constrain_radius_rsketch.md

@@ -0,0 +1,17 @@
+# constrain_radius_rsketch
+
+## API Definition
+
+```python
+def constrain_radius_rsketch(sketch: Sketch, circle: Union[SketchRef, str], value: ScalarLike, *, constraint_id: Optional[str] = None, driving: bool = True) -> Sketch
+```
+
+*Source: operations.py*
+
+## Import Surface
+
+- top-level: `from simplecadapi import constrain_radius_rsketch`
+
+## Description
+
+Add a driving circle radius constraint.

SimpleCADAPI-master/docs/api/constrain_symmetric_rsketch.md

@@ -0,0 +1,17 @@
+# constrain_symmetric_rsketch
+
+## API Definition
+
+```python
+def constrain_symmetric_rsketch(sketch: Sketch, a: Union[SketchRef, str], b: Union[SketchRef, str], axis: Union[SketchRef, str], *, constraint_id: Optional[str] = None) -> Sketch
+```
+
+*Source: operations.py*
+
+## Import Surface
+
+- top-level: `from simplecadapi import constrain_symmetric_rsketch`
+
+## Description
+
+Constrain two sketch points to be symmetric about a line axis.

SimpleCADAPI-master/docs/api/constrain_tangent_rsketch.md

@@ -0,0 +1,17 @@
+# constrain_tangent_rsketch
+
+## API Definition
+
+```python
+def constrain_tangent_rsketch(sketch: Sketch, a: Union[SketchRef, str], b: Union[SketchRef, str], *, constraint_id: Optional[str] = None) -> Sketch
+```
+
+*Source: operations.py*
+
+## Import Surface
+
+- top-level: `from simplecadapi import constrain_tangent_rsketch`
+
+## Description
+
+Constrain supported sketch curves to be tangent.

SimpleCADAPI-master/docs/api/constrain_vertical_rsketch.md

@@ -0,0 +1,17 @@
+# constrain_vertical_rsketch
+
+## API Definition
+
+```python
+def constrain_vertical_rsketch(sketch: Sketch, line: Union[SketchRef, str], *, constraint_id: Optional[str] = None) -> Sketch
+```
+
+*Source: operations.py*
+
+## Import Surface
+
+- top-level: `from simplecadapi import constrain_vertical_rsketch`
+
+## Description
+
+Constrain a sketch line to be vertical.

SimpleCADAPI-master/docs/api/cut_rsolid.md

@@ -0,0 +1,34 @@
+# cut_rsolid
+
+## API Definition
+
+```python
+def cut_rsolid(*solids: Union[Solid, Sequence[Solid]], skip_non_intersecting: bool = True) -> Solid
+```
+
+*Source: operations.py*
+
+## Import Surface
+
+- top-level: `from simplecadapi import cut_rsolid`
+
+## Description
+
+Compute the boolean difference of solids.
+
+Accepts a base solid followed by one or more tool solids, including nested
+sequences, and returns a single `Solid`.
+
+## Parameters
+
+### solids
+
+- **Description**: One or more Solid objects or sequences of Solid. Nested sequences are flattened before processing; the first solid is the base, the rest are subtracted in order.
+
+### skip_non_intersecting
+
+- **Description**: When True, tools with no meaningful intersection are ignored for interactive convenience. Graph replay records this flag and should use False for strict diagnostic workflows.
+
+## Returns
+
+Solid: The cut result solid.

SimpleCADAPI-master/docs/api/export_graph_json.md

@@ -0,0 +1,31 @@
+# export_graph_json
+
+## API Definition
+
+```python
+def export_graph_json(graph: OperationGraph, indent: int = 2) -> str
+```
+
+*Source: serializer.py*
+
+## Import Surface
+
+- top-level: `from simplecadapi import export_graph_json`
+
+## Description
+
+Export an OperationGraph to a JSON string.
+
+## Parameters
+
+### graph
+
+- **Description**: The graph to export.
+
+### indent
+
+- **Description**: JSON indentation level.
+
+## Returns
+
+JSON string representation.

SimpleCADAPI-master/docs/api/export_model_json.md

@@ -0,0 +1,22 @@
+# export_model_json
+
+## API Definition
+
+```python
+def export_model_json(session: 'GraphSession', indent: int = 2) -> str
+```
+
+*Source: serializer.py*
+
+## Import Surface
+
+- top-level: `from simplecadapi import export_model_json`
+
+## Description
+
+Export the canonical 2.0 model seed JSON.
+
+Current Phase 1 scope uses the active session as the container of:
+- operation graph
+- expression graph
+- capabilities/schema metadata

SimpleCADAPI-master/docs/api/export_session_json.md

@@ -0,0 +1,17 @@
+# export_session_json
+
+## API Definition
+
+```python
+def export_session_json(session: 'GraphSession', indent: int = 2) -> str
+```
+
+*Source: serializer.py*
+
+## Import Surface
+
+- top-level: `from simplecadapi import export_session_json`
+
+## Description
+
+Export a graph session including its expression graph.

SimpleCADAPI-master/docs/api/export_step.md

@@ -0,0 +1,50 @@
+# export_step
+
+## API Definition
+
+```python
+def export_step(shapes: Union[AnyShape, Sequence[AnyShape]], filename: str) -> None
+```
+
+*Source: operations.py*
+
+## Import Surface
+
+- top-level: `from simplecadapi import export_step`
+
+## Description
+
+Export shapes to STEP.
+
+Use this function when you want to export one shape or many shapes into the
+same STEP file. Passing `List[Solid]` is valid for pattern outputs or
+explicit shape collections. Boolean operations return a single `Solid`.
+
+## Parameters
+
+### shapes
+
+- **Description**: A single exportable shape or any nested sequence of exportable shapes. Lists of Solid are supported directly, including pattern or explicitly collected multi-shape results.
+
+### filename
+
+- **Description**: Output STEP file path.
+
+## Returns
+
+None: Writes the provided shapes into one STEP file.
+
+## Examples
+
+### Example 1
+```python
+main_body = make_box_rsolid(10, 4, 4, bottom_face_center=(0, 0, 0))
+left_cap = make_sphere_rsolid(2.0, center=(-2.0, 2.0, 2.0))
+right_cap = make_sphere_rsolid(2.0, center=(12.0, 2.0, 2.0))
+body = union_rsolid(main_body, [left_cap, right_cap])
+```
+
+### Example 2
+```python
+export_step(body, "rounded_bar.step")
+```

SimpleCADAPI-master/docs/api/export_stl.md

@@ -0,0 +1,50 @@
+# export_stl
+
+## API Definition
+
+```python
+def export_stl(shapes: Union[AnyShape, Sequence[AnyShape]], filename: str) -> None
+```
+
+*Source: operations.py*
+
+## Import Surface
+
+- top-level: `from simplecadapi import export_stl`
+
+## Description
+
+Export shapes to STL.
+
+Use this function when you want to export one compound, solid, or face into
+the same STL file. Passing `List[Solid]` is valid for pattern outputs or
+explicit shape collections. Boolean operations return a single `Solid`.
+
+## Parameters
+
+### shapes
+
+- **Description**: A single Compound, Solid, or Face, or any nested sequence of those. Lists of Solid are supported directly, including pattern or explicitly collected multi-shape results.
+
+### filename
+
+- **Description**: Output STL file path.
+
+## Returns
+
+None: Writes the provided shapes into one STL file.
+
+## Examples
+
+### Example 1
+```python
+main_body = make_box_rsolid(10, 4, 4, bottom_face_center=(0, 0, 0))
+left_cap = make_sphere_rsolid(2.0, center=(-2.0, 2.0, 2.0))
+right_cap = make_sphere_rsolid(2.0, center=(12.0, 2.0, 2.0))
+body = union_rsolid(main_body, [left_cap, right_cap])
+```
+
+### Example 2
+```python
+export_stl(body, "rounded_bar.stl")
+```

SimpleCADAPI-master/docs/api/extrude_rsolid.md

@@ -0,0 +1,17 @@
+# extrude_rsolid
+
+## API Definition
+
+```python
+def extrude_rsolid(profile: Union[Wire, Face], direction: Tuple[float, float, float], distance: ScalarLike) -> Solid
+```
+
+*Source: operations.py*
+
+## Import Surface
+
+- top-level: `from simplecadapi import extrude_rsolid`
+
+## Description
+
+Create a solid by extruding a profile.

SimpleCADAPI-master/docs/api/fillet_rsolid.md

@@ -0,0 +1,17 @@
+# fillet_rsolid
+
+## API Definition
+
+```python
+def fillet_rsolid(solid: Solid, edges: Union[Sequence[Edge], ShapeSelector], radius: ScalarLike) -> Solid
+```
+
+*Source: operations.py*
+
+## Import Surface
+
+- top-level: `from simplecadapi import fillet_rsolid`
+
+## Description
+
+Apply fillets to selected solid edges.

SimpleCADAPI-master/docs/api/fit_cubic_bspline_control_points.md

@@ -0,0 +1,79 @@
+# fit_cubic_bspline_control_points
+
+## API Definition
+
+```python
+def fit_cubic_bspline_control_points(sample_points: Sequence[Sequence[float]], *, tolerance: float = 0.001, max_control_points: Optional[int] = None, fairing: float = 1e-06, duplicate_tolerance: float = 1e-12, knot_tolerance: float = 1e-09, raise_on_failure: bool = True) -> BSplineFitResult
+```
+
+*Source: math.py*
+
+## Import Surface
+
+- top-level: `from simplecadapi import fit_cubic_bspline_control_points`
+
+## Description
+
+Fit a minimal cubic B-spline control polygon to sampled curve points.
+
+Uses chord-length parameterization, cubic clamped B-spline least squares,
+second-difference fairing regularization, and adaptive simple knot insertion
+until the maximum sample error is within `tolerance`. Only simple interior
+knots are inserted, so a cubic result remains C2-continuous at every interior
+knot.
+
+## Parameters
+
+### sample_points
+
+- **Description**: Ordered 2D or 3D points sampled along the intended curve. Consecutive duplicate points within `duplicate_tolerance` are ignored.
+
+### tolerance
+
+- **Description**: Maximum allowed Euclidean fitting error at the input samples.
+
+### max_control_points
+
+- **Description**: Upper bound for fitted control points. Defaults to the cleaned sample count, with a cubic minimum of four controls.
+
+### fairing
+
+- **Description**: Non-negative second-difference regularization weight. Larger values prefer smoother control polygons while still respecting the error tolerance when possible.
+
+### duplicate_tolerance
+
+- **Description**: Distance threshold for removing consecutive duplicate sample points before chord-length parameterization.
+
+### knot_tolerance
+
+- **Description**: Normalized parameter spacing threshold used to avoid duplicate or near-boundary interior knots.
+
+### raise_on_failure
+
+- **Description**: Raise `ValueError` when the tolerance cannot be reached within `max_control_points`. If false, return the best non-converged result instead.
+
+## Returns
+
+`BSplineFitResult` containing cubic degree, control points, a full clamped
+knot vector, knot multiplicities, sample parameters, and fitting error.
+
+## Raises
+
+- **ValueError**: If inputs are invalid, or if the tolerance cannot be met and `raise_on_failure=True`.
+
+## Examples
+
+### Example 1
+```python
+```python
+from simplecadapi.math import fit_cubic_bspline_control_points
+```
+
+### Example 2
+```python
+samples = [(0.0, 0.0, 0.0), (1.0, 0.4, 0.0), (2.0, 0.0, 0.0)]
+fit = fit_cubic_bspline_control_points(samples, tolerance=0.01)
+print(fit.control_points)
+print(fit.knots, fit.multiplicities)
+```
+```

SimpleCADAPI-master/docs/api/forward_connector_rassembly.md

@@ -0,0 +1,22 @@
+# forward_connector_rassembly
+
+## API Definition
+
+```python
+def forward_connector_rassembly(assembly: Assembly, connector_id: str, source_component_id: str, source_connector_id: str, name: Optional[str] = None, offset: Optional[Placement] = None) -> Assembly
+```
+
+*Source: operations.py*
+
+## Import Surface
+
+- top-level: `from simplecadapi import forward_connector_rassembly`
+
+## Description
+
+Expose an internal component connector as an assembly-level connector.
+
+The forwarded connector resolves to `source_component.placement *
+source_connector.placement`, followed by the optional `offset` placement.
+Parent assemblies can constrain to the subassembly's public connector
+without depending on its private component structure.

SimpleCADAPI-master/docs/api/geo.md

@@ -0,0 +1,17 @@
+# geo
+
+## API Definition
+
+```python
+def geo(field: str, default: Any = None) -> SerializableKey
+```
+
+*Source: ql.py*
+
+## Import Surface
+
+- submodule: `from simplecadapi.ql import geo` or `simplecadapi.ql.geo`
+
+## Description
+
+Shortcut for reading `geom.*` fields inside QL queries.

SimpleCADAPI-master/docs/api/get_sketch_entity_rsketchref.md

@@ -0,0 +1,17 @@
+# get_sketch_entity_rsketchref
+
+## API Definition
+
+```python
+def get_sketch_entity_rsketchref(sketch: Sketch, entity_id: str) -> SketchRef
+```
+
+*Source: operations.py*
+
+## Import Surface
+
+- top-level: `from simplecadapi import get_sketch_entity_rsketchref`
+
+## Description
+
+Return a stable ref for a named sketch entity.

SimpleCADAPI-master/docs/api/get_sketch_point_rsketchref.md

@@ -0,0 +1,17 @@
+# get_sketch_point_rsketchref
+
+## API Definition
+
+```python
+def get_sketch_point_rsketchref(sketch: Sketch, point_path: str) -> SketchRef
+```
+
+*Source: operations.py*
+
+## Import Surface
+
+- top-level: `from simplecadapi import get_sketch_point_rsketchref`
+
+## Description
+
+Return a stable ref for a sketch point or endpoint path.

SimpleCADAPI-master/docs/api/ground_component_rassembly.md

@@ -0,0 +1,17 @@
+# ground_component_rassembly
+
+## API Definition
+
+```python
+def ground_component_rassembly(assembly: Assembly, component_id: str) -> Assembly
+```
+
+*Source: operations.py*
+
+## Import Surface
+
+- top-level: `from simplecadapi import ground_component_rassembly`
+
+## Description
+
+Ground a component at its current authored placement.

SimpleCADAPI-master/docs/api/helical_sweep_rsolid.md

@@ -0,0 +1,17 @@
+# helical_sweep_rsolid
+
+## API Definition
+
+```python
+def helical_sweep_rsolid(profile: Wire, pitch: float, height: float, radius: float, center: Tuple[float, float, float] = (0, 0, 0), dir: Tuple[float, float, float] = (0, 0, 1)) -> Solid
+```
+
+*Source: operations.py*
+
+## Import Surface
+
+- top-level: `from simplecadapi import helical_sweep_rsolid`
+
+## Description
+
+Create a solid by sweeping a profile along a helical path.

SimpleCADAPI-master/docs/api/identity_placement_rplacement.md

@@ -0,0 +1,17 @@
+# identity_placement_rplacement
+
+## API Definition
+
+```python
+def identity_placement_rplacement() -> Placement
+```
+
+*Source: operations.py*
+
+## Import Surface
+
+- top-level: `from simplecadapi import identity_placement_rplacement`
+
+## Description
+
+Create an identity placement.

SimpleCADAPI-master/docs/api/import_graph_json.md

@@ -0,0 +1,27 @@
+# import_graph_json
+
+## API Definition
+
+```python
+def import_graph_json(json_str: str) -> OperationGraph
+```
+
+*Source: serializer.py*
+
+## Import Surface
+
+- top-level: `from simplecadapi import import_graph_json`
+
+## Description
+
+Import an OperationGraph from a JSON string.
+
+## Parameters
+
+### json_str
+
+- **Description**: JSON string to parse.
+
+## Returns
+
+Reconstructed OperationGraph.

SimpleCADAPI-master/docs/api/import_model_json.md

@@ -0,0 +1,17 @@
+# import_model_json
+
+## API Definition
+
+```python
+def import_model_json(json_str: str) -> Dict[str, Any]
+```
+
+*Source: serializer.py*
+
+## Import Surface
+
+- top-level: `from simplecadapi import import_model_json`
+
+## Description
+
+Import canonical 2.0 model seed JSON.

SimpleCADAPI-master/docs/api/import_session_json.md

@@ -0,0 +1,17 @@
+# import_session_json
+
+## API Definition
+
+```python
+def import_session_json(json_str: str) -> Dict[str, Any]
+```
+
+*Source: serializer.py*
+
+## Import Surface
+
+- top-level: `from simplecadapi import import_session_json`
+
+## Description
+
+Import session payload containing graph and expression graph.

SimpleCADAPI-master/docs/api/inspect_assembly_constraints_rconstraintreport.md

@@ -0,0 +1,17 @@
+# inspect_assembly_constraints_rconstraintreport
+
+## API Definition
+
+```python
+def inspect_assembly_constraints_rconstraintreport(assembly: Assembly) -> ConstraintReport
+```
+
+*Source: operations.py*
+
+## Import Surface
+
+- top-level: `from simplecadapi import inspect_assembly_constraints_rconstraintreport`
+
+## Description
+
+Inspect all assembly constraint residuals without mutating the assembly.

SimpleCADAPI-master/docs/api/inspect_sketch_rsketchresult.md

@@ -0,0 +1,17 @@
+# inspect_sketch_rsketchresult
+
+## API Definition
+
+```python
+def inspect_sketch_rsketchresult(sketch: Sketch, *, require_fully_constrained: bool = False, strict: bool = True, tolerance: float = 1e-07, max_iterations: int = 80) -> SketchSolveResult
+```
+
+*Source: operations.py*
+
+## Import Surface
+
+- top-level: `from simplecadapi import inspect_sketch_rsketchresult`
+
+## Description
+
+Inspect sketch constraints by running the solver without recording graph nodes.

SimpleCADAPI-master/docs/api/intersect_rsolid.md

@@ -0,0 +1,31 @@
+# intersect_rsolid
+
+## API Definition
+
+```python
+def intersect_rsolid(*solids: Union[Solid, Sequence[Solid]]) -> Solid
+```
+
+*Source: operations.py*
+
+## Import Surface
+
+- top-level: `from simplecadapi import intersect_rsolid`
+
+## Description
+
+Compute the boolean intersection of solids.
+
+Accepts one or more solids, including nested sequences, and returns a single
+`Solid`. If the inputs do not overlap meaningfully, the API raises a clear
+error instead of returning an empty list.
+
+## Parameters
+
+### solids
+
+- **Description**: One or more Solid objects or sequences of Solid. Nested sequences are flattened before processing.
+
+## Returns
+
+Solid: The overlap region as a single solid.

SimpleCADAPI-master/docs/api/linear_pattern_rsolidlist.md

@@ -0,0 +1,17 @@
+# linear_pattern_rsolidlist
+
+## API Definition
+
+```python
+def linear_pattern_rsolidlist(shape: AnyShape, direction: Tuple[float, float, float], count: int, spacing: float) -> List[Solid]
+```
+
+*Source: operations.py*
+
+## Import Surface
+
+- top-level: `from simplecadapi import linear_pattern_rsolidlist`
+
+## Description
+
+Create a linear pattern of solids.

SimpleCADAPI-master/docs/api/list_tags.md

@@ -0,0 +1,17 @@
+# list_tags
+
+## API Definition
+
+```python
+def list_tags(shape: AnyShape) -> List[str]
+```
+
+*Source: operations.py*
+
+## Import Surface
+
+- top-level: `from simplecadapi import list_tags`
+
+## Description
+
+Return shape tags in deterministic sorted order.

SimpleCADAPI-master/docs/api/loft_rsolid.md

@@ -0,0 +1,17 @@
+# loft_rsolid
+
+## API Definition
+
+```python
+def loft_rsolid(profiles: List[Wire], ruled: bool = False) -> Solid
+```
+
+*Source: operations.py*
+
+## Import Surface
+
+- top-level: `from simplecadapi import loft_rsolid`
+
+## Description
+
+Create a solid by lofting multiple profiles.

SimpleCADAPI-master/docs/api/make_2d_cut_rface.md

@@ -0,0 +1,36 @@
+# make_2d_cut_rface
+
+## API Definition
+
+```python
+def make_2d_cut_rface(body: Face, tool: Face) -> Face
+```
+
+*Source: operations.py*
+
+## Import Surface
+
+- top-level: `from simplecadapi import make_2d_cut_rface`
+
+## Description
+
+Subtract one 2D face from another (2D boolean difference).
+
+## Parameters
+
+### body
+
+- **Type**: `Face`
+- **Description**: The face to subtract from.
+
+### tool
+
+- **Type**: `Face`
+- **Description**: The face to subtract (the cutter).
+
+## Returns
+
+-------
+Face
+The resulting face after subtraction.  The result may contain
+inner wires (holes) if the tool was fully inside the body.

SimpleCADAPI-master/docs/api/make_2d_intersect_rface.md

@@ -0,0 +1,35 @@
+# make_2d_intersect_rface
+
+## API Definition
+
+```python
+def make_2d_intersect_rface(face_a: Face, face_b: Face) -> Face
+```
+
+*Source: operations.py*
+
+## Import Surface
+
+- top-level: `from simplecadapi import make_2d_intersect_rface`
+
+## Description
+
+Compute the boolean intersection of two 2D faces.
+
+## Parameters
+
+### face_a
+
+- **Type**: `Face`
+- **Description**: First face.
+
+### face_b
+
+- **Type**: `Face`
+- **Description**: Second face.
+
+## Returns
+
+-------
+Face
+The overlapping region of the two faces.

SimpleCADAPI-master/docs/api/make_2d_union_rface.md

@@ -0,0 +1,36 @@
+# make_2d_union_rface
+
+## API Definition
+
+```python
+def make_2d_union_rface(face_a: Face, face_b: Face) -> Face
+```
+
+*Source: operations.py*
+
+## Import Surface
+
+- top-level: `from simplecadapi import make_2d_union_rface`
+
+## Description
+
+Compute the boolean union of two 2D faces.
+
+## Parameters
+
+### face_a
+
+- **Type**: `Face`
+- **Description**: First face.
+
+### face_b
+
+- **Type**: `Face`
+- **Description**: Second face.
+
+## Returns
+
+-------
+Face
+The merged face.  Both inputs must overlap or touch so that the
+result is a single connected face.

SimpleCADAPI-master/docs/api/make_angle_arc_redge.md

@@ -0,0 +1,17 @@
+# make_angle_arc_redge
+
+## API Definition
+
+```python
+def make_angle_arc_redge(center: Tuple[float, float, float], radius: ScalarLike, start_angle: ScalarLike, end_angle: ScalarLike, normal: Tuple[float, float, float] = (0, 0, 1)) -> Edge
+```
+
+*Source: operations.py*
+
+## Import Surface
+
+- top-level: `from simplecadapi import make_angle_arc_redge`
+
+## Description
+
+Create an arc edge from a center, radius, and angle range.

SimpleCADAPI-master/docs/api/make_angle_arc_rwire.md

@@ -0,0 +1,17 @@
+# make_angle_arc_rwire
+
+## API Definition
+
+```python
+def make_angle_arc_rwire(center: Tuple[float, float, float], radius: float, start_angle: float, end_angle: float, normal: Tuple[float, float, float] = (0, 0, 1)) -> Wire
+```
+
+*Source: operations.py*
+
+## Import Surface
+
+- top-level: `from simplecadapi import make_angle_arc_rwire`
+
+## Description
+
+Create a wire containing an arc defined by a center, radius, and angle range.