Returns the new object IDs in row-major (x outer, y inner) order. The
    source is preserved; when ``skip_origin`` is True the (0,0) cell is
    left untouched and the source itself fills it.
    

    Architectural shortcut for "stack this slab N floors high". The source
    sits at level 0; copies populate levels 1 .. floor_count.
    

    The boundary is interpreted in world XY; Z is taken from
    ``boundary_min.z``. Use ``seed`` for deterministic output.
    

    With ``align_to_tangent`` (default), each copy is reoriented so that
    the world-X direction maps to the curve tangent at its sample point.
    ``include_endpoints`` controls whether the first/last samples land on
    the curve's start/end points.
    

    ``angle_deg`` rotates the arrow clockwise from world +Y so callers can
    adapt to a site whose true north differs from grid north.
    

    Bar is drawn in document units; the label reports the represented
    real-world distance based on ``scale_denominator``.
    

    Bridge-only: rhino3dm exposes ``material_index`` on the layer but the
    in-document material table is read-only. Use ``rhino_material_create``
    first to define the material.
    

    Filter fields combine with AND semantics. ``object_ids`` short-circuits
    the other filters when provided. Standalone mode marks matches with the
    ``rhino_mcp_selected`` user-string (since rhino3dm has no selection
    state); bridge mode delegates to Rhino's native selection.
    

    Returns the full catalogue (or a single category subset) so the LLM
    can pick a known-good name before calling ``rhino_material_preset_create``.
    

    With ``as_base64=True`` the response includes ``image_base64`` so
    the LLM can inspect the render inline. The PNG is also written to
    ``path`` regardless, for the user to save/share.
    

    Spotlights ``selection_ids`` and/or objects on ``layers``; everything
    else is either ghosted (default) or hidden during the capture and
    restored afterwards. Useful for multi-step LLM verification flows
    where only the recently added objects need to be visualised. Bridge
    only.
    

    Returns ``hits`` sorted by distance from the ray origin. Bridge-only —
    rhino3dm has no ray-shoot primitive.
    

    Returns up to ``limit`` objects starting at ``offset`` (after filters).
    The response carries a ``pagination`` block — ``{total, offset, limit,
    returned, has_more}`` — so the caller can iterate without guessing.

    Async so concurrent ``rhino_*`` queries don't block FastMCP's event
    loop while the bridge round-trip is in flight.
    

    ``mode='reference'`` stores the point as metadata only — useful for
    geo-referencing without disturbing existing geometry. ``mode='translate'``
    shifts every object so the supplied point becomes the new (0,0,0).
    

    Standalone surfaces ``IsValid``/``IsSolid``/``IsManifold``/edge+face
    counts and the rhino3dm validation log. Bridge mode adds a list of
    naked-edge identifiers and lengths via RhinoCommon.
    

    Standalone rhino3dm cannot enumerate naked edges. In bridge mode this
    forwards to ``Rhino.Geometry.Brep.GetNakedEdges`` and returns
    ``[{edge_index, length}, ...]`` plus the gap count.
    

    The rectangle's corners define the sheet bounds; user_text holds the
    sheet name, paper size (mm), and scale denominator so subsequent
    view-placement / title-block / export tools can re-derive it.
    

    Returns ``rows`` (one entry per layer) plus a ``totals`` block.
    

    Useful for BIM-style schedules: ``group_key='assembly_type'`` produces a
    wall/window schedule, ``group_key='material'`` produces a material BOM.
    

    Standalone treats ``MaterialIndex == -1`` (default material) as
    'Default'. Bridge mode resolves each object's effective material via
    Rhino's render content lookup.
    

    Standalone uses ``rhino3dm.InstanceDefinitionGeometry`` to register
    the geometry under ``name``. Bridge mode mirrors that and additionally
    replaces the source objects with a single instance at the base point
    when ``replace_objects=True``.
    

    Standalone constructs a ``rhino3dm.InstanceReferenceGeometry`` and
    applies the transform to it. Bridge mode forwards to RhinoCommon's
    ``Doc.Objects.AddInstanceObject`` which honours the active layer
    and links the instance to the definition.
    

    Standalone draws into the active rhino3dm document; bridge mode
    forwards so the path is visible in Rhino's viewport.
    

    Standalone produces a coarse 4-corner shadow polygon per object
    (suitable for sketch-grade studies). Bridge mode emits accurate
    wireframe-projection shadow polygons.
    

    DF = (W * theta * tau * M) / (A_total * (1 - R^2)) (% as decimal).
    For early-stage architectural studies; for radiance-grade accuracy
    use ladybug-tools or DAYSIM.
    

    Standalone writes ``Pset_RhinoMcp::<key>`` user_text on each object;
    bridge mode does the same and additionally pushes into Rhino's IFC
    property-set table so a subsequent IFC export carries them across.
    

    Bridge mode reads from the live RhinoCommon UserString table; standalone
    mode reads from rhino3dm UserStrings on the saved 3dm document. The
    result groups properties by PropertySet name (``psets`` field).
    

    Returns a ``job_id`` immediately while frames are captured on a
    background worker. Use ``rhino_render_queue_status`` to poll
    progress and ``rhino_render_queue_cancel`` to interrupt. The v0.5
    backend captures viewport frames (``_-ViewCaptureToFile``); true
    photo-realistic engine integration is on the roadmap.
    

    - Standalone: chains ``CreateRuledSurface`` between adjacent section
      pairs and returns the list of surface IDs; the caller can join them
      downstream if needed.
    - Bridge: emits a single Brep loft via ``Brep.CreateFromLoft``.
    

    Standalone supports ``axis='u'`` and ``axis='v'`` (surface isocurves).
    World-axis slicing (``axis='x'/'y'/'z'``) requires bridge mode.
    

    ``output='mesh'`` writes a single quad mesh (one face per panel) to
    the doc; ``'curves'`` writes count_u+count_v isocurves; ``'corners'``
    only returns the (count_u+1) x (count_v+1) sample points without
    writing geometry.
    

    Each cell's planarity error = distance of the 4th corner from the
    plane fitted through the first three. Cells whose error > tolerance
    are flagged. The returned ``stats`` block summarises max / mean /
    non-planar count for high-level reporting.
    

    Standalone uses a 4-corner normal heuristic (no full Gaussian K).
    Bridge mode reports true Gaussian + mean curvature per cell.
    

    ``u`` and ``v`` are 0..1 ratios over the surface's domain; the
    actual parameters are computed internally so the LLM doesn't need
    to know the domain bounds.
    

    Samples a (sample_u+1) x (sample_v+1) grid of normals; for each
    interior 2x2 block computes the maximum angle (in radians) between
    adjacent normals. Reports max / mean / RMS over the whole sheet
    plus a 0..1 normalised score (0 = perfectly developable,
    1 = π/2 normal swing within a single cell).

    A truly developable surface (cone, cylinder, plane) returns ~0;
    a sphere section returns a positive value proportional to the
    spanned solid angle.
    

    Positive ``strength`` pulls toward the attractor; negative pushes
    away. The attractor is either a fixed point (``attractor_point``)
    or a curve (``attractor_curve_id``); for curves each point's
    attractor is the closest sample on the curve.

    Returns the *new* point IDs (the originals are deleted; this is a
    form-finding move, not a duplicating one).
    

    Each iteration replaces every interior point P_i with
    ``(1 - factor) * P_i + factor * (P_{i-1} + P_{i+1}) / 2``.
    With ``pin_endpoints=True`` the first and last points are held.
    Returns the new curve's object_id (the input is replaced).
    

    Use this BEFORE writing any RhinoScript Python code to find correct
    function names and signatures.  Returns matching functions sorted by
    relevance.

    Example queries: "loft surface", "boolean union", "rotate object",
    "create curve", "extrude".
    

    CRITICAL: You MUST call this tool before using rhino_execute_python.
    Returns full signatures, parameter descriptions, return values, and
    optional code examples for the most relevant functions.
    

    Use rhino_list_rhinoscript_modules() first to see available modules,
    then call this to browse a module's full API.
    

    Returns one row per running Rhino on this host. Each row carries
    ``pid``, ``host``, ``port``, ``doc_path``, ``doc_title``, version, and
    an ``alive`` flag derived from a cheap TCP probe.
    

    Exactly one selector among ``pid``, ``port``, ``doc_path_contains``,
    and ``index`` should be set. The active bridge client is closed; the
    next tool call goes through lazy promotion against the new endpoint.
    

    CRITICAL — BEFORE USING THIS TOOL:
    1. Call rhino_get_rhinoscript_docs(topic) to find correct signatures.
    2. Read the documentation carefully — note exact parameter types.
    3. Write code using ONLY the documented signatures.
    4. Call this tool with the code.

    Code requirements:
    - Import rhinoscriptsyntax: ``import rhinoscriptsyntax as rs``
    - Use ``print()`` to return output/results to the caller.
    - Handle ``None`` returns from functions that might fail.

    Changes are wrapped in an undo record and will be reverted on failure.

    Returns ``success``, ``output`` (print capture), and ``message``
    (error details on failure).
    

    SAFETY: This tool runs arbitrary code with full RhinoCommon access.
    It is gated behind ``RHINO_MCP_ALLOW_CSHARP=1`` so it cannot fire
    accidentally. Set the env var only in trusted sessions.

    Globals available to the script:
    - ``doc``: the active ``RhinoDoc``
    - ``output``: a ``StringBuilder`` — call ``output.AppendLine("...")``
      to return text to the caller.

    Pre-imported namespaces: System, System.Collections.Generic,
    System.Linq, System.Text, Rhino, Rhino.Geometry, Rhino.DocObjects,
    Rhino.Commands. Pass ``references`` to load extra assemblies (e.g.
    ``Grasshopper``).

    Example — create a sphere::

        var sphere = new Sphere(Point3d.Origin, 5.0);
        doc.Objects.AddBrep(sphere.ToBrep());
        doc.Views.Redraw();
        output.AppendLine("Created sphere");

    Changes are wrapped in an undo record. ``timeout_s`` caps total
    execution time (default 30s); on timeout the call returns
    ``success: false`` and the script is best-effort cancelled.
    

    Each spec can include any combination of: translation, rotation,
    scale, colour, layer, visibility, and name.  All changes are wrapped
    in one undo record — ``rhino_undo(steps=1)`` reverts the entire batch.

    When ``apply_to_all`` is ``True``, the modifications from the first
    spec are applied to every object in the document.
    

    IMPORTANT: ``steps[].method`` is a **bridge dispatcher route**, not
    an MCP tool name. The MCP tool ``rhino_layer_create`` maps to the
    dispatcher route ``rhino.layer.create``; ``rhino_document_summary``
    maps to ``rhino.query.document_summary`` (NOT ``rhino.document.summary``).
    Standalone-only tools (``rhino_set_user_text`` etc. that have no
    ``bridge_call`` path) cannot be batched. A wrong route name returns
    an ``error`` row with ``HandlerError``; the batch aborts when
    ``on_error='stop'``.

    Measured impact (v0.6.x, localhost): direct sequential layer.create
    ~580ms/op vs batched ~340ms/op — N x ~240ms saved per batch (the
    MCP↔bridge round-trip cost paid once instead of N times). Effective
    for any workflow that issues >5 bridge calls back-to-back.

    Returns ``{summary: {total, ok, failed, on_error}, results: [...]}``
    where each ``results`` entry has ``index``, ``method``, ``status``
    (``"ok"`` | ``"error"``), and either ``result`` or ``error``.
    

    Lightweight alternative to ``rhino_render_to_file`` — no render engine
    is invoked, just a viewport bitmap dump. Use 0 for ``width``/``height``
    to inherit the on-screen viewport size.
    

    Returns a per-row ``results`` array so partial failures are visible
    (each row carries ``status`` and, on error, ``error``).
    

    Returns one entry per ``GH_AssemblyInfo`` library: id, name, author,
    version, description, and the on-disk path. Useful for the LLM to
    discover whether the user has LunchBox / Ladybug / Kangaroo etc.
    installed before attempting to drop in a custom component.
    

    Returns ``rows`` of ``{guid, name, nickname, category, subcategory,
    description, plugin}`` and a ``summary`` block with match counts.
    Use this to find the GUID needed by ``gh_add_component`` before
    dropping a component on the canvas.
    

    Returns the new ``component_id`` so subsequent ``gh_connect_components``
    or ``gh_set_slider`` calls can target it.
    

    With ``defer_solve=True`` (default) the GH document is paused while
    the assignments are applied and recomputed exactly once at the end —
    critical for parameter sweeps where N independent ``set`` calls
    would otherwise trigger N solver runs.
    

    ``available=False`` means the .gh binary has not been shipped yet —
    the contract is described in the manifest but loading it will fail
    until the binary is placed alongside the manifest.
    

    Launch Rhino and wait for it to become ready.
    
    Args:
    controller: RhinoController instance.
    wait_seconds: Seconds to wait for Rhino to start (default 12).
    
    Returns:
    Dict with launch result.
    

    Manage named views: list, save, restore, or delete.
    
    Args:
    controller: RhinoController instance.
    action: One of 'list', 'save', 'restore', 'delete'.
    view_name: Name of the view (required for save/restore/delete).
    
    Returns:
    Dict with command result or list of named views.
    

    Redo one or more operations.
    
    Args:
    controller: RhinoController instance.
    steps: Number of redo steps (default 1).
    
    Returns:
    Dict with the result of the last redo command.
    

    Set the construction plane origin for the specified viewport.
    
    Args:
    controller: RhinoController instance.
    view: Viewport name (Perspective, Top, Front, Right, etc.).
    origin_x: X coordinate of the new CPlane origin.
    origin_y: Y coordinate of the new CPlane origin.
    origin_z: Z coordinate of the new CPlane origin.
    
    Returns:
    Dict with command result.
    

    Configure viewport grid settings.
    
    Args:
    controller: RhinoController instance.
    grid_snap: Snap spacing size (default 1.0).
    minor_gridlines: Number of minor grid lines (default 10).
    major_gridlines: Number of major grid lines per minor (default 10).
    
    Returns:
    Dict with command result.
    

    Set active object snap modes.
    
    Args:
    controller: RhinoController instance.
    modes: List of osnap mode names to enable, e.g.
    ['End', 'Mid', 'Cen', 'Int', 'Near', 'Point'].
    Pass an empty list to disable all.
    Defaults to ['End', 'Mid', 'Cen', 'Int', 'Near'].
    
    Returns:
    Dict with command result.
    

    Enable or disable grid snap and set snap spacing.
    
    Args:
    controller: RhinoController instance.
    enabled: True to enable snap, False to disable.
    snap_size: The snap grid size (default 1.0).
    
    Returns:
    Dict with command result.
    

    Set the document unit system.
    
    Args:
    controller: RhinoController instance.
    unit_system: One of Millimeters, Meters, Centimeters, Inches, Feet, etc.
    
    Returns:
    Dict with command result.
    

    Return the current Rhino connection status plus the default files directory.
    
    Args:
    controller: RhinoController instance.
    
    Returns:
    Dict containing status info and rhino_files_dir.
    

    Retrieve Rhino system information.
    
    Args:
    controller: RhinoController instance.
    
    Returns:
    Dict with system info output.
    

    Undo one or more operations.
    
    Args:
    controller: RhinoController instance.
    steps: Number of undo steps (default 1).
    
    Returns:
    Dict with the result of the last undo command.
    

    Open the Document Properties dialog.
    
    Args:
    controller: RhinoController instance.
    
    Returns:
    Dict with command result.
    

    Select all geometry and export to a file.
    
    The export format is inferred from the file extension; ``export_type``
    is used as the extension if ``file_name`` has none.
    
    Args:
    controller: RhinoController instance.
    file_name: Output filename (e.g. 'model.stl') or full path.
    folder: Optional folder override.
    export_type: File extension / format if not included in file_name
    (default 'stl').
    
    Returns:
    Dict with command result.
    

    Import geometry from an external file into the current document.
    
    Args:
    controller: RhinoController instance.
    file_path: Absolute path to the file to import.
    
    Returns:
    Dict with command result.
    

    List all files in the default RhinoFiles directory (D:/RhinoFiles).
    
    Args:
    controller: RhinoController instance.
    
    Returns:
    Dict with 'files' key containing list of file info dicts,
    and 'directory' key with the scanned path.
    

    Create a new Rhino document, optionally from a template.
    
    Args:
    controller: RhinoController instance.
    template: Path to a .3dm template file. If empty, opens a blank document.
    
    Returns:
    Dict with command result.
    

    Open an existing Rhino file.
    
    Args:
    controller: RhinoController instance.
    file_path: Absolute path to the .3dm file to open.
    
    Returns:
    Dict with command result.
    

    Purge unused document objects to reduce file size.
    
    Args:
    controller: RhinoController instance.
    purge_unused_layers: Remove layers with no geometry (default True).
    purge_unused_blocks: Remove unreferenced block definitions (default True).
    purge_unused_materials: Remove unreferenced materials (default True).
    
    Returns:
    Dict with command result.
    

    Revert the current document to its last saved state.
    
    Args:
    controller: RhinoController instance.
    
    Returns:
    Dict with command result.
    

    Save the current document to its existing file path.
    
    Args:
    controller: RhinoController instance.
    
    Returns:
    Dict with command result.
    

    Save the current document under a new name/location.
    
    If ``file_name`` is not an absolute path it is resolved relative to
    D:/RhinoFiles (or ``folder`` if provided).
    
    Args:
    controller: RhinoController instance.
    file_name: Desired filename (e.g. 'mymodel.3dm') or full path.
    folder: Optional folder override.
    
    Returns:
    Dict with command result.
    

    Save a copy of the current document without changing the active file path.
    
    Args:
    controller: RhinoController instance.
    file_name: Desired filename or full path for the copy.
    folder: Optional folder override.
    
    Returns:
    Dict with command result.
    

    Create a box (rectangular cuboid) in Rhino.
    
    The box is defined by its bottom-left-front corner (x, y, z) and its
    opposite corner derived from length/width, then extruded to *height*.
    
    Args:
    controller: RhinoController instance.
    x, y, z:   World-space origin of the box base corner.
    length:     Size along the X axis.
    width:      Size along the Y axis.
    height:     Extrusion height along the Z axis.
    
    Returns:
    Dict with 'status' and 'command' keys.
    

    Create a cone in Rhino.
    
    Args:
    controller: RhinoController instance.
    x, y, z:   Center of the base circle.
    radius:     Base radius.
    height:     Height of the cone (apex above base).
    
    Returns:
    Dict with 'status' and 'command' keys.
    

    Create a closed cylinder in Rhino.
    
    Args:
    controller: RhinoController instance.
    x, y, z:   Center of the base circle.
    radius:     Base radius.
    height:     Height of the cylinder.
    
    Returns:
    Dict with 'status' and 'command' keys.
    

    Create an ellipsoid in Rhino.
    
    Rhino prompts: center -> end of first axis -> end of second axis ->
    end of third axis.  We supply the three semi-axis end-points along
    the world X, Y, Z directions respectively.
    
    Args:
    controller: RhinoController instance.
    x, y, z:   Center of the ellipsoid.
    rx:         Semi-axis length along X.
    ry:         Semi-axis length along Y.
    rz:         Semi-axis length along Z.
    
    Returns:
    Dict with 'status' and 'command' keys.
    

    Create a paraboloid surface in Rhino using the Paraboloid command.
    
    Rhino prompts: focus/apex point -> radius at base -> height.
    
    Args:
    controller: RhinoController instance.
    x, y, z:   Apex (tip) of the paraboloid.
    radius:     Radius of the open base circle.
    height:     Height from apex to base.
    
    Returns:
    Dict with 'status' and 'command' keys.
    

    Create a pipe solid around a previously created (or selected) curve.
    
    The function first runs *curve_select_cmd* to select the rail curve,
    then runs the Pipe command with the given radius and cap style.
    
    Args:
    controller:         RhinoController instance.
    curve_select_cmd:   Rhino command used to select the curve before
    piping (default: '_SelLast' selects the most
    recently created object).
    radius:             Pipe outer radius.
    cap:                If True, caps the pipe ends (solid); otherwise
    leaves them open.
    
    Returns:
    Dict with 'status' and 'command' keys.
    

    Create a flat rectangular NURBS surface in Rhino.
    
    Args:
    controller: RhinoController instance.
    x, y, z:   First corner of the surface.
    length:     Size along the X axis.
    width:      Size along the Y axis.
    
    Returns:
    Dict with 'status' and 'command' keys.
    

    Create a regular pyramid in Rhino.
    
    Args:
    controller: RhinoController instance.
    x, y, z:   Center of the base polygon.
    sides:      Number of sides for the base polygon (>= 3).
    radius:     Circumradius of the base polygon.
    height:     Height of the pyramid apex above the base.
    
    Returns:
    Dict with 'status' and 'command' keys.
    

    Create a sphere in Rhino.
    
    Args:
    controller: RhinoController instance.
    x, y, z:   World-space center point.
    radius:     Sphere radius.
    
    Returns:
    Dict with 'status' and 'command' keys.
    

    Create a torus in Rhino.
    
    Args:
    controller:    RhinoController instance.
    x, y, z:       World-space center of the torus.
    major_radius:  Distance from the torus center to the tube center.
    minor_radius:  Radius of the tube cross-section.
    
    Returns:
    Dict with 'status' and 'command' keys.
    

    Create a truncated cone (frustum) in Rhino using the TruncatedCone command.
    
    Rhino prompts: base center -> base radius -> height -> top radius.
    
    Args:
    controller:     RhinoController instance.
    x, y, z:        Center of the base circle.
    bottom_radius:  Radius of the base (larger) circle.
    top_radius:     Radius of the top (smaller) circle.
    height:         Height between the two circles.
    
    Returns:
    Dict with 'status' and 'command' keys.
    

    Create a hollow cylindrical tube in Rhino.
    
    Args:
    controller:   RhinoController instance.
    x, y, z:      Center of the base annulus.
    outer_radius: Outer radius of the tube.
    thickness:    Wall thickness (inner_radius = outer_radius - thickness).
    height:       Height of the tube.
    
    Returns:
    Dict with 'status' and 'command' keys.
    

    Draw an arc by center, radius, and angular span.
    
    Rhino's Arc command (center mode) prompts:
    center -> radius -> start angle -> end angle.
    
    Args:
    controller:   RhinoController instance.
    cx, cy, cz:   Center of the arc circle.
    radius:       Arc radius.
    start_angle:  Starting angle in degrees (measured from +X axis).
    end_angle:    Ending angle in degrees.
    
    Returns:
    Dict with 'status' and 'command' keys.
    

    Draw a circle by center and radius.
    
    Args:
    controller: RhinoController instance.
    cx, cy, cz: World-space center of the circle.
    radius:     Circle radius.
    
    Returns:
    Dict with 'status' and 'command' keys.
    

    Draw an ellipse by center, X semi-axis, and Y semi-axis.
    
    Args:
    controller: RhinoController instance.
    cx, cy, cz: Center of the ellipse.
    rx:         Semi-axis radius along X.
    ry:         Semi-axis radius along Y.
    
    Returns:
    Dict with 'status' and 'command' keys.
    

    Extend the selected curve by a fixed length from one or both ends.
    
    The curve must be pre-selected before calling this function.
    
    Args:
    controller: RhinoController instance.
    length:     Extension length.
    
    Returns:
    Dict with 'status' and 'command' keys.
    

    Fair (smooth) the selected curve using Rhino's FairCrv command.
    
    The curve must be pre-selected before calling this function.
    
    Args:
    controller: RhinoController instance.
    
    Returns:
    Dict with 'status' and 'command' keys.
    

    Create a control-point (freeform) NURBS spline.
    
    The curve is defined by its control polygon; it does NOT pass through
    interior points (only through the first and last control point when the
    degree allows).
    
    Args:
    controller: RhinoController instance.
    points:     Control polygon vertices as (x, y, z) tuples.
    degree:     Polynomial degree (default 3 = cubic B-spline).
    
    Returns:
    Dict with 'status' and 'command' keys.
    

    Create a cylindrical helix curve in Rhino.
    
    This is a special case of rhino_spiral where start_radius == end_radius.
    
    Args:
    controller: RhinoController instance.
    x, y, z:   Base point (axis start).
    pitch:      Vertical distance per full turn.
    turns:      Number of full turns.
    radius:     Constant radius of the helix.
    
    Returns:
    Dict with 'status' and 'command' keys.
    

    Create an interpolated NURBS curve that passes through all given points.
    
    Args:
    controller: RhinoController instance.
    points:     Ordered list of (x, y, z) tuples (>= 2).
    degree:     Polynomial degree of the resulting curve (default 3 = cubic).
    
    Returns:
    Dict with 'status' and 'command' keys.
    

    Draw a straight line between two world-space points.
    
    Args:
    controller:       RhinoController instance.
    x1, y1, z1:      Start point.
    x2, y2, z2:      End point.
    
    Returns:
    Dict with 'status' and 'command' keys.
    

    Offset the currently selected curve by a specified distance.
    
    The curve must be pre-selected before calling this function.
    
    Args:
    controller:    RhinoController instance.
    distance:      Perpendicular offset distance.
    through_point: Optional 'x,y,z' string to offset through a point
    instead of using *distance*.
    
    Returns:
    Dict with 'status' and 'command' keys.
    

    Draw a regular polygon by center and circumradius.
    
    Args:
    controller: RhinoController instance.
    cx, cy, cz: Center of the polygon.
    sides:      Number of sides (>= 3).
    radius:     Circumradius (vertex distance from center).
    inscribed:  If True, polygon is inscribed in a circle of *radius*;
    if False, polygon is circumscribed around that circle.
    
    Returns:
    Dict with 'status' and 'command' keys.
    

    Draw an open polyline through a list of 3-D points.
    
    Args:
    controller: RhinoController instance.
    points:     Ordered list of (x, y, z) tuples (>= 2 required).
    
    Returns:
    Dict with 'status' and 'command' keys.
    

    Rebuild the selected curve with a specified number of control points and degree.
    
    The curve must be pre-selected before calling this function.
    
    Args:
    controller:   RhinoController instance.
    point_count:  Target number of control points.
    degree:       Target polynomial degree.
    
    Returns:
    Dict with 'status' and 'command' keys.
    

    Draw a planar rectangle defined by two corner points.
    
    Args:
    controller: RhinoController instance.
    x, y, z:   First corner of the rectangle.
    width:      Size along the X axis.
    height:     Size along the Y axis.
    
    Returns:
    Dict with 'status' and 'command' keys.
    

    Create a spiral (conical helix) curve in Rhino.
    
    Rhino Spiral prompts: axis start -> axis end -> start radius -> end radius.
    We place the axis start at (x, y, z) and axis end at (x, y, z + pitch*turns).
    
    Args:
    controller:    RhinoController instance.
    x, y, z:       Base point (axis start).
    pitch:         Vertical distance per turn.
    turns:         Number of full turns.
    start_radius:  Radius at the base of the spiral.
    end_radius:    Radius at the top of the spiral.
    
    Returns:
    Dict with 'status' and 'command' keys.
    

    Create a blend surface between two surface edges.
    
    Pre-select the two naked edges before calling.
    
    Args:
    controller: RhinoController instance.
    
    Returns:
    Dict with 'status' and 'command' keys.
    

    Build a surface from 2, 3, or 4 edge/curve inputs.
    
    Pre-select the bounding edges (2-4) before calling.
    
    Args:
    controller: RhinoController instance.
    num_edges:  Number of edge curves (2, 3, or 4).
    
    Returns:
    Dict with 'status' and 'command' keys.
    

    Loft through a set of profile curves.
    
    The curves are first selected using *curve_selection*, then the Loft
    command is run with the requested style.
    
    Args:
    controller:       RhinoController instance.
    curve_selection:  Rhino command to select the profile curves
    (default '_SelLast').
    style:            Loft style keyword: Normal | Loose | Tight |
    Straight | Developable | Uniform.
    closed:           If True, adds '_Closed=_Yes' to create a
    closed (periodic) loft.
    
    Returns:
    Dict with 'status' and 'command' keys.
    

    Match the edge of one surface to another for G0/G1/G2 continuity.
    
    Pre-select the edge to adjust before calling.
    
    Args:
    controller:   RhinoController instance.
    continuity:   Continuity type: 'Position', 'Tangency', or 'Curvature'.
    
    Returns:
    Dict with 'status' and 'command' keys.
    

    Build a surface through a network of intersecting curves.
    
    Pre-select the network curves before calling.
    
    Args:
    controller: RhinoController instance.
    
    Returns:
    Dict with 'status' and 'command' keys.
    

    Offset a surface by a specified distance, optionally creating a solid.
    
    Pre-select the surface before calling.
    
    Args:
    controller: RhinoController instance.
    distance:   Offset distance (positive = outward along normals).
    solid:      If True, caps the sides to create a closed solid.
    
    Returns:
    Dict with 'status' and 'command' keys.
    

    Fit a patch surface to the selected curves or point objects.
    
    Args:
    controller: RhinoController instance.
    u_spans:    Number of surface spans in the U direction.
    v_spans:    Number of surface spans in the V direction.
    
    Returns:
    Dict with 'status' and 'command' keys.
    

    Fill planar closed curves with a planar surface.
    
    Pre-select the boundary curves before calling.
    
    Args:
    controller: RhinoController instance.
    
    Returns:
    Dict with 'status' and 'command' keys.
    

    Rail-revolve: revolve a profile along a rail path curve.
    
    Pre-select the profile curve and rail curve before calling.
    
    Args:
    controller: RhinoController instance.
    
    Returns:
    Dict with 'status' and 'command' keys.
    

    Revolve the selected profile curve around the World Z axis.
    
    The profile curve and axis start/end points must be pre-selected or
    implied by the current selection.  The axis is assumed to run along
    the world Z axis through the origin (0,0,0) -> (0,0,1).
    
    Args:
    controller:   RhinoController instance.
    angle:        Total revolution angle in degrees (360 = full solid).
    start_angle:  Starting angle in degrees (0 = +X direction).
    
    Returns:
    Dict with 'status' and 'command' keys.
    

    Shrink the underlying surface to its trim boundary.
    
    Pre-select the trimmed surface before calling.
    
    Args:
    controller: RhinoController instance.
    
    Returns:
    Dict with 'status' and 'command' keys.
    

    Create a surface from 3 or 4 corner points.
    
    Args:
    controller: RhinoController instance.
    pts:        List of 3 or 4 points; each element is an (x, y, z) tuple
    or a 'x,y,z' string.
    
    Returns:
    Dict with 'status' and 'command' keys.
    

    Sweep a profile curve along a single rail curve.
    
    Typical workflow:
    1. Select the rail curve with *rail_select*.
    2. Select the profile curve(s) with *profile_select*.
    3. Run Sweep1 and accept defaults.
    
    Args:
    controller:      RhinoController instance.
    rail_select:     Rhino command to select the rail curve.
    profile_select:  Rhino command to select the profile curve(s).
    closed:          If True, produces a closed sweep.
    
    Returns:
    Dict with 'status' and 'command' keys.
    

    Sweep a profile along two rail curves.
    
    Pre-select the two rail curves and at least one profile curve before
    calling this function.
    
    Args:
    controller: RhinoController instance.
    
    Returns:
    Dict with 'status' and 'command' keys.
    

    Generate tween (morphed intermediate) surfaces between two surfaces.
    
    Pre-select the two source surfaces before calling.
    
    Args:
    controller: RhinoController instance.
    count:      Number of intermediate tween surfaces to generate.
    
    Returns:
    Dict with 'status' and 'command' keys.
    

    Create a variable-radius blend surface between two surface edges.
    
    Pre-select the two naked edges before calling.
    
    Args:
    controller: RhinoController instance.
    
    Returns:
    Dict with 'status' and 'command' keys.
    

    Boolean difference: subtract selected cutters from base objects.
    
    Args:
    controller: RhinoController instance.
    delete_input: Delete input cutter objects after the operation.
    

    Boolean intersection of selected closed polysurfaces / solids.
    
    Args:
    controller: RhinoController instance.
    

    Boolean split: split objects with cutting surfaces / polysurfaces.
    
    Args:
    controller: RhinoController instance.
    

    Boolean union of selected closed polysurfaces / solids.
    
    Args:
    controller: RhinoController instance.
    

    Cap planar holes in open polysurfaces to create closed solids.
    
    Args:
    controller: RhinoController instance.
    

    Close (cap) a planar hole in an open polysurface or mesh.
    
    Args:
    controller: RhinoController instance.
    

    Explode selected polysurfaces, blocks, or groups into component parts.
    
    Args:
    controller: RhinoController instance.
    

    Extrude selected curve(s) to create a solid or surface.
    
    Args:
    controller: RhinoController instance.
    distance: Extrusion distance.
    both_sides: Extrude in both directions symmetrically.
    solid: Create a closed solid (cap ends).
    delete_input: Delete the input curve after extrusion.
    

    Extrude selected surface(s) by a given distance.
    
    Args:
    controller: RhinoController instance.
    distance: Extrusion distance.
    both_sides: Extrude in both directions symmetrically.
    solid: Create a closed solid.
    

    Join selected surfaces, curves, or polysurfaces into a single object.
    
    Args:
    controller: RhinoController instance.
    

    Merge all coplanar adjacent faces in selected polysurfaces.
    
    Args:
    controller: RhinoController instance.
    

    Create a multi-pipe from selected curves.
    
    Args:
    controller: RhinoController instance.
    radius: Pipe radius at each curve.
    

    Push or pull a selected sub-face of a solid by a given distance.
    
    Args:
    controller: RhinoController instance.
    distance: Push/pull distance (positive = outward, negative = inward).
    

    Create a rib feature on a solid from selected curves.
    
    Args:
    controller: RhinoController instance.
    width: Rib width.
    thickness: Rib thickness.
    

    Shell selected solid, removing one or more faces and offsetting the rest.
    
    Args:
    controller: RhinoController instance.
    thickness: Shell wall thickness.
    

    Create a slab (extruded planar surface with thickness) from curves.
    
    Args:
    controller: RhinoController instance.
    thickness: Slab thickness.
    

    Enable solid point editing for selected polysurfaces.
    
    Args:
    controller: RhinoController instance.
    

    Cut a solid with a wire (curve) extruded through the object.
    
    Args:
    controller: RhinoController instance.
    depth: Cut depth (extrusion distance of the wire).
    

    Align mesh vertices that are within the given tolerance of each other.
    
    Args:
    controller: RhinoController instance.
    tolerance: Distance tolerance for vertex alignment.
    

    Flip the normals of selected mesh faces.
    
    Args:
    controller: RhinoController instance.
    

    Boolean difference of selected closed meshes.
    
    Args:
    controller: RhinoController instance.
    

    Boolean intersection of selected closed meshes.
    
    Args:
    controller: RhinoController instance.
    

    Boolean union of selected closed meshes.
    
    Args:
    controller: RhinoController instance.
    

    Convert selected NURBS surfaces / polysurfaces to a render mesh.
    
    Args:
    controller: RhinoController instance.
    max_angle: Maximum angle between mesh normals (degrees).
    max_aspect: Maximum aspect ratio of mesh faces (0 = ignore).
    max_distance: Maximum distance from mesh edge to surface.
    max_edge: Maximum mesh edge length (0 = ignore).
    min_edge: Minimum mesh edge length.
    min_initial_grid: Minimum initial grid quads per surface.
    refine: Refine the mesh for better quality.
    jagged_seams: Allow jagged seams between surfaces.
    

    Launch the MeshRepair wizard for selected meshes.
    
    Args:
    controller: RhinoController instance.
    

    Split a mesh with another mesh or surface.
    
    Args:
    controller: RhinoController instance.
    

    Convert selected mesh objects to NURBS surfaces.
    
    Args:
    controller: RhinoController instance.
    

    Trim a mesh with a cutting curve or surface.
    
    Args:
    controller: RhinoController instance.
    

    Offset selected mesh faces by a given distance.
    
    Args:
    controller: RhinoController instance.
    distance: Offset distance (along face normals).
    

    Remesh selected objects into a uniform quad mesh.
    
    Args:
    controller: RhinoController instance.
    target_quad_count: Target number of quad faces.
    adaptive_size: Adaptive size percentage (0–100).
    detect_hard_edges: Preserve hard edges during remeshing.
    

    Convert triangular faces in selected meshes to quads where possible.
    
    Args:
    controller: RhinoController instance.
    

    Rebuild selected meshes to clean up topology.
    
    Args:
    controller: RhinoController instance.
    

    Reduce the polygon count of selected meshes.
    
    Args:
    controller: RhinoController instance.
    polygon_percentage: Target polygon count as a percentage of original.
    allow_distortion: Allow some geometric distortion to achieve target count.
    

    Shrink-wrap selected geometry into a watertight mesh.
    
    Args:
    controller: RhinoController instance.
    resolution: Target voxel resolution for the wrap.
    

    Convert all quad faces in selected meshes to triangles.
    
    Args:
    controller: RhinoController instance.
    

    Unify the normals of selected mesh faces to all point outward.
    
    Args:
    controller: RhinoController instance.
    

    Unweld mesh vertices where the edge angle exceeds the tolerance.
    
    Args:
    controller: RhinoController instance.
    angle: Minimum angle (degrees) to unweld at.
    

    Weld mesh vertices within the given angle tolerance.
    
    Args:
    controller: RhinoController instance.
    angle_tolerance: Maximum angle (degrees) between faces to weld vertices.
    

    Offset a SubD object by a given distance, optionally creating a solid.
    
    Args:
    controller: RhinoController instance.
    distance: Offset distance.
    solid: Create a solid (closed) offset.
    

    Remove the crease from selected SubD edges (smooth them).
    
    Args:
    controller: RhinoController instance.
    

    Repair selected SubD objects to fix topology issues.
    
    Args:
    controller: RhinoController instance.
    

    Create a SubD box primitive.
    
    Args:
    controller: RhinoController instance.
    x: X coordinate of base corner.
    y: Y coordinate of base corner.
    z: Z coordinate of base corner.
    length: Box length along X.
    width: Box width along Y.
    height: Box height along Z.
    face_x: Number of faces along X.
    face_y: Number of faces along Y.
    face_z: Number of faces along Z.
    

    Create a SubD cone primitive.
    
    Args:
    controller: RhinoController instance.
    x: X coordinate of base center.
    y: Y coordinate of base center.
    z: Z coordinate of base center.
    radius: Cone base radius.
    height: Cone height.
    

    Add a crease to selected SubD edges, making them sharp.
    
    Args:
    controller: RhinoController instance.
    

    Create a SubD cylinder primitive.
    
    Args:
    controller: RhinoController instance.
    x: X coordinate of base center.
    y: Y coordinate of base center.
    z: Z coordinate of base center.
    radius: Cylinder radius.
    height: Cylinder height.
    

    Toggle SubD display between smooth and box (control polygon) modes.
    
    Args:
    controller: RhinoController instance.
    

    Expand selected SubD edges outward by a given distance.
    
    Args:
    controller: RhinoController instance.
    distance: Expansion distance.
    

    Create a SubD loft surface through selected curves.
    
    Args:
    controller: RhinoController instance.
    closed: Create a closed (periodic) loft.
    

    Create a SubD plane primitive.
    
    Args:
    controller: RhinoController instance.
    x: X coordinate of start corner.
    y: Y coordinate of start corner.
    z: Z coordinate of start corner.
    length: Plane length along U.
    width: Plane width along V.
    count_u: Number of faces along U.
    count_v: Number of faces along V.
    

    Create a SubD sphere primitive.
    
    Args:
    controller: RhinoController instance.
    x: X coordinate of center.
    y: Y coordinate of center.
    z: Z coordinate of center.
    radius: Sphere radius.
    subdivisions: Number of subdivision levels.
    

    Create a SubD sweep along one rail curve.
    
    Args:
    controller: RhinoController instance.
    

    Create a SubD sweep along two rail curves.
    
    Args:
    controller: RhinoController instance.
    

    Create a SubD torus primitive.
    
    Args:
    controller: RhinoController instance.
    x: X coordinate of center.
    y: Y coordinate of center.
    z: Z coordinate of center.
    major_radius: Torus major (outer) radius.
    minor_radius: Torus minor (tube) radius.
    

    Subdivide selected SubD objects a given number of times.
    
    Args:
    controller: RhinoController instance.
    count: Number of subdivision iterations.
    

    Convert selected SubD objects to NURBS surfaces.
    
    Args:
    controller: RhinoController instance.
    

    Convert selected NURBS or mesh objects to SubD.
    
    Args:
    controller: RhinoController instance.
    method: Conversion method (e.g., 'FromNURBS', 'FromMesh').
    

    Align selected objects in a given direction.
    
    Valid directions: Left, Right, Top, Bottom, Vertical, Horizontal,
    Center, Middle.
    
    Args:
    controller: RhinoController instance.
    direction: Alignment direction keyword.
    
    Returns:
    Dict with command result.
    

    Create a rectangular/linear array of selected objects.
    
    Args:
    controller: RhinoController instance.
    count_x: Number of items in X direction.
    count_y: Number of items in Y direction.
    count_z: Number of items in Z direction.
    spacing_x: Spacing between items in X.
    spacing_y: Spacing between items in Y.
    spacing_z: Spacing between items in Z.
    
    Returns:
    Dict with command result.
    

    Array selected objects along a curve.
    
    The curve must be selected after the objects (interactive).
    
    Args:
    controller: RhinoController instance.
    count: Number of copies along the curve.
    
    Returns:
    Dict with command result.
    

    Create a polar array of selected objects around a center point.
    
    Args:
    controller: RhinoController instance.
    count: Total number of items (including original).
    angle: Total angle to fill in degrees.
    cx: X coordinate of the array center.
    cy: Y coordinate of the array center.
    cz: Z coordinate of the array center.
    
    Returns:
    Dict with command result.
    

    Apply a bend deformation to selected objects.
    
    Args:
    controller: RhinoController instance.
    angle: Bend angle in degrees.
    symmetric: If True, bend is symmetric about the midpoint.
    
    Returns:
    Dict with command result.
    

    Distribute selected objects evenly along a direction.
    
    Uses rhinoscriptsyntax to compute bounding-box centres and re-space them.
    
    Args:
    controller: RhinoController instance.
    direction: 'Horizontal' (X), 'Vertical' (Y), or 'Depth' (Z).
    
    Returns:
    Dict with command result.
    

    Flow (morph) selected objects along a curve.
    
    Requires an existing base curve and a target curve to be selected
    interactively.
    
    Args:
    controller: RhinoController instance.
    preserve_structure: If True, the original NURBS structure is preserved.
    
    Returns:
    Dict with command result.
    

    Mirror selected objects about a named world plane.
    
    Supported planes: 'WorldXY', 'WorldYZ', 'WorldXZ'.
    
    Args:
    controller: RhinoController instance.
    plane: Mirror plane identifier.
    
    Returns:
    Dict with command result.
    

    Move selected objects by a displacement vector (dx, dy, dz).
    
    Uses a Python script via rhinoscriptsyntax so that the displacement can be
    applied programmatically to every currently-selected object.
    
    Args:
    controller: RhinoController instance.
    dx: Displacement along X axis.
    dy: Displacement along Y axis.
    dz: Displacement along Z axis.
    
    Returns:
    Dict with command result.
    

    Orient selected objects using three reference points (interactive).
    
    Args:
    controller: RhinoController instance.
    
    Returns:
    Dict with command result.
    

    Orient selected objects along a curve (interactive).
    
    Args:
    controller: RhinoController instance.
    
    Returns:
    Dict with command result.
    

    Orient selected objects on a surface (interactive).
    
    Args:
    controller: RhinoController instance.
    
    Returns:
    Dict with command result.
    

    Project selected objects onto the active construction plane.
    
    Original objects are not kept.
    
    Args:
    controller: RhinoController instance.
    
    Returns:
    Dict with command result.
    

    Rotate selected objects around a center point in the active construction plane.
    
    For a true 3-D axis rotation use :func:`rhino_rotate_3d` instead.
    
    Args:
    controller: RhinoController instance.
    cx: X coordinate of the rotation center.
    cy: Y coordinate of the rotation center.
    cz: Z coordinate of the rotation center (ignored for planar rotate).
    angle: Rotation angle in degrees.
    axis: Axis hint ('x', 'y', 'z') – kept for API symmetry; planar Rotate
    always rotates about the CPlane normal.
    
    Returns:
    Dict with command result.
    

    Rotate selected objects around an arbitrary 3-D axis.
    
    Args:
    controller: RhinoController instance.
    axis_start: Start point of the rotation axis.
    axis_end: End point of the rotation axis.
    angle: Rotation angle in degrees.
    
    Returns:
    Dict with command result.
    

    Uniformly scale selected objects about a center point.
    
    Args:
    controller: RhinoController instance.
    cx: X coordinate of the scale origin.
    cy: Y coordinate of the scale origin.
    cz: Z coordinate of the scale origin.
    factor: Scale factor (>1 enlarges, <1 shrinks).
    
    Returns:
    Dict with command result.
    

    Scale selected objects in one direction (1-D scale).
    
    The user must pick the origin and scale direction interactively.
    
    Args:
    controller: RhinoController instance.
    factor: Scale factor.
    
    Returns:
    Dict with command result.
    

    Scale selected objects in two directions simultaneously (2-D scale).
    
    Args:
    controller: RhinoController instance.
    factor: Scale factor applied to both directions.
    
    Returns:
    Dict with command result.
    

    Scale selected objects non-uniformly along X, Y, Z.
    
    Args:
    controller: RhinoController instance.
    x_factor: Scale factor in X.
    y_factor: Scale factor in Y.
    z_factor: Scale factor in Z.
    
    Returns:
    Dict with command result.
    

    Apply a taper deformation to selected objects.
    
    The taper axis and extent are picked interactively after the command starts.
    
    Args:
    controller: RhinoController instance.
    angle: Taper angle in degrees.
    
    Returns:
    Dict with command result.
    

    Apply a twist deformation to selected objects.
    
    The twist axis is picked interactively.
    
    Args:
    controller: RhinoController instance.
    angle: Total twist angle in degrees.
    
    Returns:
    Dict with command result.
    

    Chamfer the selected edges of a polysurface or solid.
    
    Args:
    controller: RhinoController instance.
    distance: Chamfer distance.
    
    Returns:
    Dict with command result.
    

    Create a chamfer surface between two selected surfaces.
    
    Args:
    controller: RhinoController instance.
    distance: Chamfer distance.
    
    Returns:
    Dict with command result.
    

    Extend a surface edge by a specified distance.
    
    The edge to extend is selected interactively.
    
    Args:
    controller: RhinoController instance.
    distance: Extension distance.
    
    Returns:
    Dict with command result.
    

    Fillet the selected edges of a polysurface or solid.
    
    Args:
    controller: RhinoController instance.
    radius: Fillet radius.
    
    Returns:
    Dict with command result.
    

    Create a fillet surface between two selected surfaces.
    
    Args:
    controller: RhinoController instance.
    radius: Fillet radius.
    
    Returns:
    Dict with command result.
    

    Flip the normal direction of selected surfaces.
    
    Args:
    controller: RhinoController instance.
    
    Returns:
    Dict with command result.
    

    Merge all coplanar faces of selected polysurfaces into single faces.
    
    Args:
    controller: RhinoController instance.
    
    Returns:
    Dict with command result.
    

    Merge selected adjacent edges of a surface.
    
    Args:
    controller: RhinoController instance.
    
    Returns:
    Dict with command result.
    

    Offset a selected curve by a given distance.
    
    Args:
    controller: RhinoController instance.
    distance: Offset distance.
    both_sides: If True, offset to both sides of the curve.
    cap: If True, add end caps (for open curves with BothSides=Yes).
    
    Returns:
    Dict with command result.
    

    Offset a selected surface or polysurface.
    
    Args:
    controller: RhinoController instance.
    distance: Offset distance.
    solid: If True, create a solid (shelled) offset.
    
    Returns:
    Dict with command result.
    

    Rebuild selected curves or surfaces with specified point count and degree.
    
    Args:
    controller: RhinoController instance.
    point_count: Number of control points.
    degree: NURBS degree.
    
    Returns:
    Dict with command result.
    

    Rebuild a surface in U and V directions independently.
    
    Args:
    controller: RhinoController instance.
    u_count: Control-point count in U direction.
    v_count: Control-point count in V direction.
    
    Returns:
    Dict with command result.
    

    Refit the trim curves of selected surfaces.
    
    Args:
    controller: RhinoController instance.
    
    Returns:
    Dict with command result.
    

    Reparameterize selected curves or surfaces to natural parameterization.
    
    Args:
    controller: RhinoController instance.
    
    Returns:
    Dict with command result.
    

    Adjust the seam location of a closed surface (interactive).
    
    Args:
    controller: RhinoController instance.
    
    Returns:
    Dict with command result.
    

    Smooth selected objects by averaging control-point positions.
    
    Args:
    controller: RhinoController instance.
    strength: Smoothing strength (0–1).
    iterations: Number of smoothing passes.
    
    Returns:
    Dict with command result.
    

    Split selected objects with cutting objects (interactive).
    
    Args:
    controller: RhinoController instance.
    
    Returns:
    Dict with command result.
    

    Stitch selected surface edges together within a tolerance.
    
    Args:
    controller: RhinoController instance.
    tolerance: Stitching tolerance.
    
    Returns:
    Dict with command result.
    

    Trim objects using selected cutting objects (interactive).
    
    Args:
    controller: RhinoController instance.
    
    Returns:
    Dict with command result.
    

    Un-join selected edges from a polysurface.
    
    Args:
    controller: RhinoController instance.
    
    Returns:
    Dict with command result.
    

    Remove trim boundaries from selected surfaces.
    
    Args:
    controller: RhinoController instance.
    
    Returns:
    Dict with command result.
    

    Create a variable-radius fillet surface between two surfaces.
    
    The start/end radii are passed as option overrides; edge selection
    is performed interactively.
    
    Args:
    controller: RhinoController instance.
    start_radius: Fillet radius at the start of the edge.
    end_radius: Fillet radius at the end of the edge.
    
    Returns:
    Dict with command result.
    

    Measure the angle between two lines (interactive).
    
    Args:
    controller: RhinoController instance.
    
    Returns:
    Dict with command result.
    

    Calculate the area of selected closed curves, hatches, or surfaces.
    
    Args:
    controller: RhinoController instance.
    
    Returns:
    Dict with command result containing area information.
    

    Calculate the area centroid (centre of mass) of selected surfaces.
    
    Args:
    controller: RhinoController instance.
    
    Returns:
    Dict with command result containing centroid coordinates.
    

    Return the world-axis-aligned bounding box of selected objects.
    
    Uses rhinoscriptsyntax so that the result can be parsed programmatically.
    
    Args:
    controller: RhinoController instance.
    
    Returns:
    Dict with command result containing bounding-box corner points.
    

    Check selected objects for validity and report solid status.
    
    Uses rhinoscriptsyntax to inspect each selected object and report
    whether it is valid/solid or has issues.
    
    Args:
    controller: RhinoController instance.
    
    Returns:
    Dict with command result containing validity report.
    

    Create contour curves on selected surfaces or meshes.
    
    The contour base point and direction are picked interactively.
    
    Args:
    controller: RhinoController instance.
    spacing: Distance between contour planes.
    
    Returns:
    Dict with command result.
    

    Display curvature analysis on selected surfaces.
    
    Valid styles: Gaussian, Mean, MinRadius, MaxRadius.
    
    Args:
    controller: RhinoController instance.
    style: Type of curvature analysis to display.
    
    Returns:
    Dict with command result.
    

    Display a curvature graph on selected curves.
    
    Args:
    controller: RhinoController instance.
    density: Number of hair samples along the curve.
    scale: Scale of the curvature hairs.
    
    Returns:
    Dict with command result.
    

    Measure the distance between two points.
    
    If pt1/pt2 are provided they should be formatted as "x,y,z" strings.
    Otherwise the command runs interactively.
    
    Args:
    controller: RhinoController instance.
    pt1: Optional first point as "x,y,z".
    pt2: Optional second point as "x,y,z".
    
    Returns:
    Dict with command result.
    

    Display draft-angle analysis on selected surfaces.
    
    Args:
    controller: RhinoController instance.
    draft_angle: Reference draft angle in degrees.
    
    Returns:
    Dict with command result.
    

    Measure the length of selected curves.
    
    Args:
    controller: RhinoController instance.
    
    Returns:
    Dict with command result containing curve length.
    

    Analyse the deviation between point clouds and a reference surface.
    
    Objects must be selected before calling; the command runs interactively.
    
    Args:
    controller: RhinoController instance.
    
    Returns:
    Dict with command result.
    

    Measure the radius of a selected arc or circle (interactive).
    
    Args:
    controller: RhinoController instance.
    
    Returns:
    Dict with command result.
    

    Create a cross-section curve through selected surfaces at a plane.
    
    The plane origin and normal are set interactively in Rhino.
    
    Args:
    controller: RhinoController instance.
    plane: Named plane hint ('WorldXY', 'WorldYZ', 'WorldXZ').
    
    Returns:
    Dict with command result.
    

    Show the normal and/or curve direction of selected objects.
    
    Args:
    controller: RhinoController instance.
    
    Returns:
    Dict with command result.
    

    Highlight edges of selected surfaces by type.
    
    Valid modes: Naked, Non-manifold, All.
    
    Args:
    controller: RhinoController instance.
    mode: Edge type to display.
    
    Returns:
    Dict with command result.
    

    Extract silhouette curves from selected surfaces or meshes.
    
    Args:
    controller: RhinoController instance.
    
    Returns:
    Dict with command result.
    

    Display a thickness analysis on selected closed polysurfaces.
    
    Args:
    controller: RhinoController instance.
    max_thickness: Maximum thickness value for the colour scale.
    
    Returns:
    Dict with command result.
    

    Calculate the volume of selected closed polysurfaces or meshes.
    
    Args:
    controller: RhinoController instance.
    
    Returns:
    Dict with command result containing volume information.
    

    Calculate the volume centroid of selected closed solids.
    
    Args:
    controller: RhinoController instance.
    
    Returns:
    Dict with command result containing centroid coordinates.
    

    Display detailed properties of selected objects.
    
    Args:
    controller: RhinoController instance.
    
    Returns:
    Dict with command result containing object information.
    

    Display zebra stripe analysis on selected surfaces.
    
    Args:
    controller: RhinoController instance.
    stripe_direction: 'Horizontal' or 'Vertical'.
    stripe_size: Size of the zebra stripes.
    
    Returns:
    Dict with command result.
    

    Group the currently selected objects.
    
    Args:
    name: Optional name for the group. If None, Rhino auto-assigns a name.
    

    Select objects by display color.
    
    Args:
    color_rgb: Comma-separated RGB string, e.g. '255,0,0' for red.
    

    Select objects by type.
    
    Supported types:
    'curve', 'surface', 'mesh', 'subd', 'point', 'polysurface',
    'all_curves', 'line', 'polyline', 'arc', 'circle', 'ellipse',
    'solid', 'extrusion', 'annotation', 'block', 'light', 'hatch'
    

    Select objects smaller than the given tolerance.
    
    Args:
    tolerance: Maximum bounding box size threshold.
    

    Set a layer's display color.
    
    Args:
    name: Layer name.
    r, g, b: RGB color components (0-255).
    

    Create a new layer.
    
    Args:
    name: Layer name (supports :: for sub-layers, e.g. 'Parent::Child').
    color_rgb: Optional comma-separated RGB string, e.g. '255,0,0'.
    parent: Optional parent layer name.
    

    Delete a layer and all its objects.
    
    Args:
    name: Name of the layer to delete.
    

    Isolate a layer by hiding all other layers.
    
    Args:
    name: Layer to keep visible.
    

    Lock or unlock a layer.
    
    Args:
    name: Layer name.
    locked: True to lock, False to unlock.
    

    Rename an existing layer.
    
    Args:
    old_name: Current layer name.
    new_name: New layer name.
    

    Set the active (current) layer.
    
    Args:
    name: Name of the layer to make current.
    

    Show or hide a layer.
    
    Args:
    name: Layer name.
    visible: True to show, False to hide.
    

    Move currently selected objects to the specified layer.
    
    Args:
    layer_name: Target layer name.
    

    Toggle display of surface/mesh edges.
    
    Args:
    show: True to show edges, False to hide.
    

    Pan the active viewport.
    
    Args:
    dx: Horizontal pan amount.
    dy: Vertical pan amount.
    

    Set the perspective viewport camera lens angle.
    
    Args:
    angle: Lens angle in degrees (e.g. 45, 60).
    

    Set the viewport background color via a Python script.
    
    Args:
    r, g, b: RGB color components (0-255).
    

    Set the active viewport display mode.
    
    Args:
    mode: One of Wireframe, Shaded, Rendered, Ghosted, Raytraced,
    ArtisticRendering, Pen, Technical.
    

    Set the active viewport to a standard view.
    
    Args:
    view_name: One of Top, Front, Right, Perspective, Back, Left, Bottom, Isometric.
    viewport: Optional viewport name to target.
    

    Toggle display of curve endpoints.
    
    Args:
    show: True to show endpoints, False to hide.
    

    Animate the viewport in turntable rotation.
    
    Args:
    frames: Number of animation frames.
    pause: Pause duration between frames in seconds.
    

    Capture the active viewport to the clipboard.
    
    Args:
    width: Image width in pixels.
    height: Image height in pixels.
    

    Capture the active viewport to a PNG file.
    
    Args:
    file_name: Output filename (saved to D:/RhinoFiles/).
    width: Image width in pixels.
    height: Image height in pixels.
    

    Zoom to the extents of all geometry.
    
    Args:
    all_viewports: If True, zoom all viewports; otherwise only the active one.
    

    Add a small text dot annotation at a 3D location.
    
    Args:
    text: Dot label text.
    x, y, z: Location coordinates.
    

    Add a hatch fill to a selected closed curve.
    
    Args:
    hatch_pattern: Hatch pattern name (e.g. 'Solid', 'Grid', 'Dots').
    scale: Pattern scale factor.
    

    Add a 3D text annotation object at a specific location.
    
    Args:
    text: The text string to display.
    x, y, z: Insertion point coordinates.
    height: Text height in model units.
    font: Font face name.
    

    Add a text object via Rhino command.
    
    Args:
    text: Text string.
    x, y, z: Insertion point.
    height: Text height.
    

    Add currently selected objects to an existing block definition.
    
    Args:
    name: Block definition name to add objects into.
    

    Return the number of instances of a specific block definition.
    
    Args:
    name: Block definition name.
    

    Create a block definition from currently selected objects.
    
    Args:
    name: Name for the new block definition.
    base_x, base_y, base_z: Base insertion point coordinates.
    

    Insert a block instance into the document.
    
    Args:
    name: Block definition name to insert.
    x, y, z: Insertion point.
    scale: Uniform scale factor.
    rotation: Rotation angle in degrees.
    

    Replace selected block instances with a different block definition.
    
    Args:
    new_name: Name of the replacement block definition.