@snaptrude/plugin-core 0.0.0-dev-20260908074328 → 0.0.0-surfaces-20260921090636

package/dist/api/core/geom/create/index.d.ts

@@ -1,14 +1,41 @@
 import * as z from "zod";
 import { PluginApiReturn } from "../../../../types";
-import { Vec3Handle, LineHandle, ArcHandle, CircleHandle, CurveHandle, ProfileHandle, ContourHandle, BrepHandle, FaceHandle, EdgeHandle, Vec3Components } from "../../../../handles";
+import type { SweepAlongCurveRecordOptions } from "../../../../massParameters";
+import { Vec3Handle, LineHandle, ArcHandle, SplineHandle, CircleHandle, CurveHandle, ProfileHandle, ContourHandle, BrepHandle, FaceHandle, EdgeHandle, Vec3Components } from "../../../../handles";
+/** Maximum boundary items one patch may span. */
+export declare const MAX_PATCH_BOUNDARY_CURVES = 16;
+/** Maximum interior points one patch may be pulled through. */
+export declare const MAX_PATCH_INTERIOR_POINTS = 64;
+/**
+ * An edge named together with the solid it belongs to — an edge handle cannot
+ * name its own solid, and one patch may meet two solids. `face` is the adjacent
+ * face a tangent patch continues: REQUIRED under `continuity: "tangent"`
+ * (a solid edge has two faces — the wall or the top of a rim — and only the
+ * caller knows which), ignored otherwise. Owner LAST, like every read that
+ * takes `(face, brep)`.
+ */
+export type OwnedEdge = {
+    edge: EdgeHandle;
+    brep: BrepHandle;
+    face?: FaceHandle;
+};
+/**
+ * The trailing bag of {@linkcode PluginGeomCreateApi.brepFromSweepAlongCurve}:
+ * the recorded switches plus `rail`, a live curve handle that never enters a
+ * record (a record is pure JSON, and a dead handle would not regenerate).
+ */
+export type SweepAlongCurveOptions = SweepAlongCurveRecordOptions & {
+    rail?: CurveHandle;
+};
 /**
  * Curve creation — construct new geometric curves from point handles (all-handle
  * model, §11).
  *
  * Each method takes point handles ({@linkcode Vec3Handle}) and returns an opaque
- * curve handle ({@linkcode LineHandle} or {@linkcode ArcHandle}) that you pass to
- * query, update, or entity-creation methods. Read geometry back as plain values
- * via the `snaptrude.core.geom.query.*` methods.
+ * curve handle ({@linkcode LineHandle}, {@linkcode ArcHandle}, or
+ * {@linkcode SplineHandle}) that you pass to query, update, or entity-creation
+ * methods. Read geometry back as plain values via the
+ * `snaptrude.core.geom.query.*` methods.
  *
  * Accessed via `snaptrude.core.geom.create`.
  */
@@ -69,6 +96,94 @@ export declare abstract class PluginGeomCreateApi {
      * ```
      */
     abstract circle(centrePoint: Vec3Handle, axis: Vec3Handle, radius: number): PluginApiReturn<CircleHandle>;
+    /**
+     * Create an open NURBS curve passing exactly THROUGH each point, in order
+     * (centripetal Catmull-Rom fit → clamped cubic B-spline; C1-smooth, no cusps
+     * on uneven spacing). Host API call — returns a handle. The points are
+     * interpolated, NOT control points. For a CLOSED smooth loop use
+     * {@linkcode PluginGeomCreateApi.profileFromSplinePoints} — closed splines
+     * exist only as profiles, never as a single curve handle.
+     *
+     * Pure host-side math — the geometry kernel is not loaded. The result is a
+     * {@linkcode CurveHandle}: pass it to `profileFromCurves` alongside lines and
+     * arcs, or read it back via `core.geom.query.curve.*`.
+     *
+     * @param points 3..256 ordered through-points; consecutive points must be distinct
+     * @returns The new open curve as a {@linkcode SplineHandle}
+     * @throws VALIDATION if fewer than 3 points (2 points are a straight line —
+     *   use {@linkcode PluginGeomCreateApi.line}), more than 256 points, or two
+     *   consecutive points coincide
+     *
+     * @examplePrompt Draw a smooth curve through these points
+     * @examplePrompt Make a wavy edge that passes through A, B, C and D
+     * @examplePrompt Freeform curved wall path through these clicks
+     *
+     * # Example
+     * ```ts
+     * const spline = await snaptrude.core.geom.create.splineFromPoints([p0, p1, p2, p3])
+     * // Mixed profile: smooth top, straight closing base
+     * const base = await snaptrude.core.geom.create.line(p3, p0)
+     * const profile = await snaptrude.core.geom.create.profileFromCurves([spline, base])
+     * ```
+     */
+    abstract splineFromPoints(points: Vec3Handle[]): PluginApiReturn<SplineHandle>;
+    /**
+     * Create an open NURBS curve DEFINED BY control points — the curve is pulled
+     * TOWARD the interior points, not through them; it starts at the first point
+     * and ends at the last. Knots are computed for you (clamped, uniform) —
+     * there is no knot-vector argument. For a curve that must pass THROUGH given
+     * points use {@linkcode PluginGeomCreateApi.splineFromPoints}.
+     *
+     * A curve made here records as `splinePoles` in a mass recipe and is
+     * re-minted verbatim on edit — so an agent that read a `splinePoles` curve
+     * back off a mass can move its poles and rebuild the mass with
+     * `design.update.parameters`. Pure host-side math — the geometry kernel is
+     * not loaded, and nothing is created in the scene.
+     *
+     * @param controlPoints 3..512 control points ({@linkcode Vec3Handle}s), in order
+     * @param options.degree 2 or 3; default `min(3, controlPoints.length - 1)`
+     * @returns The new open curve as a {@linkcode SplineHandle}
+     * @throws VALIDATION when fewer than `degree + 1` points are given, two
+     *   consecutive points coincide, or `degree` is not 2 or 3
+     *
+     * @examplePrompt Draw a smooth curve controlled by these four points
+     * @examplePrompt Rebuild this edge from its control polygon
+     *
+     * # Example
+     * ```ts
+     * const curve = await snaptrude.core.geom.create.splineFromControlPoints([p0, p1, p2, p3])
+     * // Quadratic instead of the default cubic
+     * const tighter = await snaptrude.core.geom.create.splineFromControlPoints(
+     *   [p0, p1, p2, p3],
+     *   { degree: 2 },
+     * )
+     * ```
+     */
+    abstract splineFromControlPoints(controlPoints: Vec3Handle[], options?: {
+        degree?: number;
+    }): PluginApiReturn<SplineHandle>;
+    /**
+     * Drops a curve onto a face along the face's normal and returns the curves it
+     * lands on — one per connected run, empty when the curve misses the face
+     * entirely. Host API call — returns new curve handles; the inputs are
+     * read-only. No lengths are involved: the result is a curve in the same
+     * internal length units as its inputs.
+     *
+     * **Not available on the shipped kernel build.** The member exists so the
+     * contract is stable, and every call throws VALIDATION until the projection
+     * primitives ship in a newer OpenCascade build.
+     *
+     * @param curve The curve to project
+     * @param face The face to project onto
+     * @param faceBrep The solid `face` belongs to — a face handle cannot name its
+     *   own solid
+     * @returns The projected curves as {@linkcode CurveHandle}`[]`
+     * @throws VALIDATION always on this build (the message names the kernel
+     *   version the member needs); once available, if `face` is not a face of
+     *   `faceBrep`
+     * @throws OPERATION_FAILED if the kernel could not project the curve
+     */
+    abstract curvesFromProjection(curve: CurveHandle, face: FaceHandle, faceBrep: BrepHandle): PluginApiReturn<CurveHandle[]>;
     /**
      * Create a closed profile from an ordered list of point handles connected by
      * line segments (last auto-connected to first). Host API call — returns a handle.
@@ -100,6 +215,38 @@ export declare abstract class PluginGeomCreateApi {
      * ```
      */
     abstract profileFromCurves(curves: CurveHandle[]): PluginApiReturn<ProfileHandle>;
+    /**
+     * Create a CLOSED smooth profile passing through each point, in order, with
+     * the loop closed smoothly back from the last point to the first (do NOT
+     * repeat the first point). Host API call — returns a handle. This is the
+     * closed counterpart of {@linkcode PluginGeomCreateApi.splineFromPoints} and
+     * the one-call route from points to an extrudable outline: wrap in
+     * `contourFromProfile` and extrude/loft/sweep as usual.
+     *
+     * The whole loop is smooth — v1 takes no mixed straight/spline input. For a
+     * profile that is part curve and part straight, build the pieces with
+     * `splineFromPoints` + `line` and join them with
+     * {@linkcode PluginGeomCreateApi.profileFromCurves}.
+     *
+     * @param points 3..256 ordered through-points of the loop (first point NOT repeated)
+     * @returns The new closed profile as a {@linkcode ProfileHandle}
+     * @throws VALIDATION if fewer than 3 points, more than 256 points,
+     *   consecutive points coincide (including last→first), or the loop
+     *   self-intersects
+     *
+     * @examplePrompt Make a blob-shaped floor plate through these points
+     * @examplePrompt Organic curved outline through these corners
+     * @examplePrompt Freeform podium profile
+     *
+     * # Example
+     * ```ts
+     * const profile = await snaptrude.core.geom.create.profileFromSplinePoints([p0, p1, p2, p3, p4])
+     * const contour = await snaptrude.core.geom.create.contourFromProfile(profile)
+     * const brep = await snaptrude.core.geom.create.brepFromExtrusion(contour, { x: 0, y: 1, z: 0 }, 3)
+     * const podium = await snaptrude.design.create.massFromBrep(brep, "Podium")
+     * ```
+     */
+    abstract profileFromSplinePoints(points: Vec3Handle[]): PluginApiReturn<ProfileHandle>;
     /**
      * Create an axis-aligned **rectangle** profile (XZ plane) of `width` × `depth`,
      * centred at `center` (defaults to the origin). Host API call — returns a handle.
@@ -210,15 +357,27 @@ export declare abstract class PluginGeomCreateApi {
      *
      * @param contour The cross-section to extrude (outer profile + optional holes)
      * @param direction Extrusion direction as plain `{x, y, z}` components (non-zero, normalised by the host)
-     * @param amount Extrusion distance (non-zero; negative extrudes opposite to `direction`)
+     * @param amount Extrusion distance in internal length units (non-zero; negative extrudes opposite to `direction`)
+     * @param options Optional twist and taper, both about `direction` through the
+     *   base contour's centroid. `twistInDegrees` — total rotation base → top in
+     *   DEGREES (an angle: never scaled by the project's length unit);
+     *   `topScale` — the top outline's scale, a ratio (1 = no taper); `levels` —
+     *   how many sections to build through, a count (2..64). Leave `levels` out
+     *   and the host resolves one and writes it into the record, so the mass
+     *   regenerates identically ever after. Omit the bag and this is the straight
+     *   extrusion it has always been, byte for byte.
      * @returns The new solid as a {@linkcode BrepHandle}
      * @throws if the extrusion is degenerate (zero amount, zero direction, or a
      *   direction lying in the contour plane) or the contour cannot be extruded
      *   into a valid solid
+     * @throws VALIDATION if `twistInDegrees` is not finite, `topScale` is not a
+     *   positive finite ratio, or `levels` is outside 2..64
      *
      * @examplePrompt Extrude this profile 3 metres up
      * @examplePrompt Make a solid by extruding this outline
      * @examplePrompt Create a cylinder from a circle profile
+     * @examplePrompt Extrude this floor plate 40m up with a 90 degree twist
+     * @examplePrompt Taper this tower to 60 percent of its footprint at the top
      *
      * # Example
      * ```ts
@@ -228,7 +387,80 @@ export declare abstract class PluginGeomCreateApi {
      * const faceCount = await snaptrude.core.geom.query.brep.getFaceCount(brep) // 6
      * ```
      */
-    abstract brepFromExtrusion(contour: ContourHandle, direction: Vec3Components, amount: number): PluginApiReturn<BrepHandle>;
+    abstract brepFromExtrusion(contour: ContourHandle, direction: Vec3Components, amount: number, options?: {
+        twistInDegrees?: number;
+        topScale?: number;
+        levels?: number;
+    }): PluginApiReturn<BrepHandle>;
+    /**
+     * Stretches a surface across a closed loop of boundary curves and thickens it
+     * into a SOLID in one call — a roof over four curves, a canopy between two
+     * rails, a blend across a gap. `thickness` is in internal length units and is
+     * required: only solids reach the canvas, and there is no separate surface
+     * object to keep. Pass edges as `{ edge, brep, face }` with
+     * `continuity: "tangent"` to leave the named face smoothly. The result carries
+     * NO recipe (`design.query.getParameters` returns `null`) — label it when you
+     * commit it, because the label is all the provenance there is.
+     *
+     * Runs on the OpenCascade kernel (the first kernel call loads a wasm of tens
+     * of MB — expect a pause of seconds).
+     *
+     * @param boundary 3..16 items forming ONE closed loop (ends meeting within
+     *   tolerance): a curve, or an edge named WITH the solid it belongs to
+     *   ({@linkcode OwnedEdge}) — an edge handle cannot name its own solid, and
+     *   one patch may meet two solids. Read scene breps with
+     *   `design.query.geometry.getBrep(x, { frame: "world" })` so every item is in
+     *   one frame.
+     * @param thickness Solid thickness in internal length units (> 0)
+     * @param options `interiorPoints` pull the surface through them (≤ 64, plain
+     *   `{x, y, z}` in the same frame as the boundary). `continuity` —
+     *   `"position"` (default) or `"tangent"`: every boundary item must then be an
+     *   edge item that also names the `face` to continue (a solid edge has two
+     *   faces — the wall or the top of a rim). `side` — `"below"` (default) or
+     *   `"above"`: which side of the boundary the solid grows to.
+     * @returns The thickened patch as a new {@linkcode BrepHandle}
+     * @throws VALIDATION if the boundary is not one closed loop (the message names
+     *   the gap and its size), a count cap is exceeded, `thickness` is not
+     *   positive, `continuity: "tangent"` is used with a curve item or with an
+     *   edge item that names no `face` (the message names the edge's two candidate
+     *   faces), or a `face` is not adjacent to its `edge`
+     * @throws OPERATION_FAILED if the kernel could not fill the boundary, the
+     *   filled surface misses its own boundary by more than 0.254 mm (the message
+     *   carries the measured gap), or the thicken produced no solid
+     *
+     * @examplePrompt Patch a roof over these four boundary curves, 250 mm thick
+     * @examplePrompt Span a canopy between these two curved rails, 300 mm thick
+     *
+     * # Example
+     * ```ts
+     * // A roof over four curves
+     * const roof = await snaptrude.core.geom.create.brepFromPatch(
+     *   [curveA, curveB, curveC, curveD],
+     *   0.25,
+     * )
+     * const mass = await snaptrude.design.create.massFromBrep(roof, "Roof patch")
+     * ```
+     *
+     * ```ts
+     * // A canopy between two towers' rims, leaving every wall it meets smoothly:
+     * // with `continuity: "tangent"` EVERY item is an edge naming its face.
+     * const canopy = await snaptrude.core.geom.create.brepFromPatch(
+     *   [
+     *     { edge: rimA, brep: towerA, face: wallA },
+     *     { edge: sideA, brep: towerA, face: endA },
+     *     { edge: rimB, brep: towerB, face: wallB },
+     *     { edge: sideB, brep: towerB, face: endB },
+     *   ],
+     *   0.3,
+     *   { continuity: "tangent" },
+     * )
+     * ```
+     */
+    abstract brepFromPatch(boundary: (CurveHandle | OwnedEdge)[], thickness: number, options?: {
+        interiorPoints?: Vec3Components[];
+        continuity?: "position" | "tangent";
+        side?: "below" | "above";
+    }): PluginApiReturn<BrepHandle>;
     /**
      * Create a closed solid **B-rep** by lofting between a bottom and a top
      * contour, optionally through intermediate cross-sections. Host API call —
@@ -257,7 +489,9 @@ export declare abstract class PluginGeomCreateApi {
      *   bottom — sections are auto-matched)
      * @param intermediateContours Optional in-between cross-sections, ordered
      *   bottom to top (hole-free; edge counts may differ — every section is
-     *   normalized to the largest)
+     *   normalized to the largest). Any count is accepted; a loft of more
+     *   than 32 sections counting the bottom and the top still builds but
+     *   carries no parameter record (records are capped, calls are not)
      * @param options Optional behavior switches. `compatibility` — `"auto"`
      *   (default) inserts vertices to match differing edge counts; `"strict"`
      *   skips normalization and throws VALIDATION when outer edge counts (or,
@@ -267,7 +501,11 @@ export declare abstract class PluginGeomCreateApi {
      *   correspondence unchanged (a twisted correspondence then builds through
      *   the triangulated lane for hole-free straight-edged pairs).
      *   `{ compatibility: "strict", seamAlignment: "authored" }` reproduces
-     *   pre-0.9.4 lofting exactly.
+     *   pre-0.9.4 lofting exactly. `smoothing` — `"ruled"` (default) keeps the
+     *   straight-sided lane above unchanged; `"smooth"` lofts every section in
+     *   ONE kernel pass, so the sides curve continuously through the
+     *   intermediates instead of creasing at each one (a vase, a curved tower —
+     *   the sections must still be planar and hole-free).
      * @returns The new solid as a {@linkcode BrepHandle}
      * @throws VALIDATION if the contours are coincident, their hole counts
      *   differ, any section has holes when intermediates are present
@@ -289,6 +527,7 @@ export declare abstract class PluginGeomCreateApi {
      * @examplePrompt Loft these outlines even though their corners don't line up
      * @examplePrompt Loft these outlines exactly as authored, corner to corner
      * @examplePrompt Fail the loft if my sections don't have matching edge counts
+     * @examplePrompt Loft these three outlines with smoothly curving sides
      *
      * # Example
      * ```ts
@@ -305,6 +544,7 @@ export declare abstract class PluginGeomCreateApi {
     abstract brepFromLoft(bottomContour: ContourHandle, topContour: ContourHandle, intermediateContours?: ContourHandle[], options?: {
         compatibility?: "strict" | "auto";
         seamAlignment?: "authored" | "auto";
+        smoothing?: "ruled" | "smooth";
     }): PluginApiReturn<BrepHandle>;
     /**
      * Create a closed solid **B-rep** from indexed mesh data: a vertex position
@@ -432,46 +672,107 @@ export declare abstract class PluginGeomCreateApi {
      */
     abstract brepFromIntersection(a: BrepHandle, b: BrepHandle): PluginApiReturn<BrepHandle>;
     /**
-     * Rounds the given straight edges of a solid with a constant radius. Host
-     * API call — returns a new {@linkcode BrepHandle}; the input brep is
-     * read-only.
-     *
-     * v1 fillets straight edges only, and no two filleted edges may share a
-     * vertex — corner blends produce spherical patches Snaptrude cannot
-     * represent. Runs on the OpenCascade kernel (the first kernel call loads a
-     * wasm of tens of MB — expect a pause of seconds).
+     * Rounds the given edges of a solid with a constant radius. Host API call —
+     * returns a new {@linkcode BrepHandle}; the input brep is read-only.
+     *
+     * Works on curved solids: edges may be straight, circular or spline, and
+     * adjacent edges (corner blends) are allowed. To pick a **rim** — the circle
+     * where a cylinder meets a flat cap — walk the edges and keep the ones whose
+     * two faces are a `cylinder` and a `plane`:
+     * `core.geom.query.brep.listEdges(brep)` → per edge
+     * `core.geom.query.edge.listFaces(edge)` → `core.geom.query.face.getSurfaceKind`
+     * on both faces. (`core.geom.query.brep.listEdgesBetween` takes two VERTEX
+     * indices — it is NOT a face-pair lookup.) For one cap's rim only,
+     * `core.geom.query.face.listEdges(capFace)` after a `getSurfaceKind` census of
+     * `brep.listFaces` is the shorter walk.
+     *
+     * When the input brep carries a creation recipe, the result carries it too,
+     * with this operation appended to `operations`; `design.create.massFromBrep`
+     * then keeps the mass editable through `design.update.parameters`.
+     *
+     * Runs on the OpenCascade kernel (the first kernel call loads a wasm of tens
+     * of MB — expect a pause of seconds).
      *
      * Inspect the result via `core.geom.query.brep.*`, or commit it to the scene
      * with `design.create.massFromBrep`.
      *
      * @param brep The solid whose edges to round
-     * @param edges The straight edges to fillet (≥1, all on `brep`, no two sharing a vertex)
-     * @param radius Fillet radius (positive, finite)
+     * @param edges The edges to fillet (one or more, all on `brep`, no
+     *   duplicates; more than 64 still fillets but the result carries no
+     *   parameter record)
+     * @param radius Fillet radius in internal length units (positive, finite) —
+     *   the radius at the START of the blend when a variable form is used
+     * @param options Optional VARIABLE blend, in one of two forms, each naming
+     *   exactly ONE edge: the law belongs to the whole tangent chain that edge
+     *   lies on, and it is measured from that edge's start. `endRadius` —
+     *   the radius at the far end, in internal length units, interpolated
+     *   linearly along the chain; needs an OPEN chain with two distinct ends, and
+     *   is refused on a closed rim (where the kernel silently builds a constant
+     *   radius) — use `radii` there. `radii` — a sampled law instead:
+     *   `position` is normalised ARC LENGTH along the chain (a ratio 0..1, never
+     *   converted), `radius` is internal length units; 2..32 rows with strictly
+     *   increasing `position`. On a closed rim 0 and 1 are the same point, so give
+     *   them the same radius and put the variation in the interior rows. The two
+     *   forms are mutually exclusive; omitted, the fillet is the constant-radius
+     *   one it has always been.
      * @returns The filleted solid as a new {@linkcode BrepHandle}
-     * @throws VALIDATION if `edges` is empty, `radius` is not a positive finite
-     *   number, an edge is not on `brep`, an edge is an arc (v1 fillets straight
-     *   edges only), or two edges share a vertex (fillet non-adjacent edges)
-     * @throws OPERATION_FAILED if the kernel cannot build the fillet (the radius
-     *   likely exceeds the adjacent face size — reduce it) or the result
-     *   contains curved surfaces Snaptrude cannot represent
-     *
-     * @examplePrompt Round the edges of this mass
+     * @throws VALIDATION if `edges` is empty or holds a duplicate, `radius` is
+     *   not a positive finite number, an edge is not on `brep`, or an edge has no
+     *   crease to round — it is a seam of a closed face, or it lies between two
+     *   patches of one smooth surface; for a variable blend, if `endRadius` and
+     *   `radii` are both given, more than one edge is passed, a `radii` table is
+     *   outside 2..32 rows or its positions do not strictly increase within
+     *   0..1, or `endRadius` names a closed rim (the message points at `radii`)
+     * @throws PRECONDITION_FAILED if an edge could not be located on the kernel
+     *   solid after healing (select a different edge, or fillet before the
+     *   operation that curved the solid), or the kernel could not blend the edge
+     *   named in the message (reduce the radius or drop that edge)
+     * @throws OPERATION_FAILED if the kernel or the translation fails, or the
+     *   result is non-manifold, splits into several solids, or contains a surface
+     *   Snaptrude cannot represent
+     *
+     * @examplePrompt Round the rim of the column with 200 mm
+     * @examplePrompt Soften where the dome meets the wall
      * @examplePrompt Fillet the corners of the podium with a 0.5m radius
      * @examplePrompt Soften the vertical edges of this tower
+     * @examplePrompt Blend this edge from 200mm at one end to 600mm at the other
+     * @examplePrompt Round this rim wider at the back than at the front
      *
      * # Example
      * ```ts
-     * const brep = await snaptrude.core.geom.create.brepFromExtrusion(contour, { x: 0, y: 1, z: 0 }, 3)
-     * const edges = await snaptrude.core.geom.query.brep.listEdges(brep)
-     * const rounded = await snaptrude.core.geom.create.brepFromFillet(brep, [edges[0]], 0.3)
+     * // Rim = every edge between the cylinder side and a plane cap
+     * const edges = await snaptrude.core.geom.query.brep.listEdges(column)
+     * const rim = []
+     * for (const edge of edges) {
+     *   const faces = await snaptrude.core.geom.query.edge.listFaces(edge)
+     *   const kinds = await Promise.all(
+     *     faces.map((f) => snaptrude.core.geom.query.face.getSurfaceKind(f)),
+     *   )
+     *   if (kinds.includes("cylinder") && kinds.includes("plane")) rim.push(edge)
+     * }
+     * const rounded = await snaptrude.core.geom.create.brepFromFillet(column, rim, 0.787) // 200 mm
      * ```
      */
-    abstract brepFromFillet(brep: BrepHandle, edges: EdgeHandle[], radius: number): PluginApiReturn<BrepHandle>;
+    abstract brepFromFillet(brep: BrepHandle, edges: EdgeHandle[], radius: number, options?: {
+        endRadius?: number;
+        radii?: {
+            position: number;
+            radius: number;
+        }[];
+    }): PluginApiReturn<BrepHandle>;
     /**
      * Grows or shrinks a solid by offsetting every face — positive distance
      * moves faces outward, negative moves them inward. Host API call — returns
      * a new {@linkcode BrepHandle}; the input brep is read-only.
      *
+     * Works on curved solids: a sphere offsets to a sphere, a torus to a torus,
+     * a cylinder to a cylinder. There is nothing to select — the whole solid is
+     * offset.
+     *
+     * When the input brep carries a creation recipe, the result carries it too,
+     * with this operation appended to `operations`; `design.create.massFromBrep`
+     * then keeps the mass editable through `design.update.parameters`.
+     *
      * Runs on the OpenCascade kernel (the first kernel call loads a wasm of
      * tens of MB — expect a pause of seconds).
      *
@@ -483,9 +784,15 @@ export declare abstract class PluginGeomCreateApi {
      * @returns The offset solid as a new {@linkcode BrepHandle}
      * @throws VALIDATION if `distance` is not finite, is too small to offset
      *   anything, or an inward distance consumes the solid entirely
-     * @throws OPERATION_FAILED if the kernel cannot build the offset or the
-     *   result contains curved surfaces Snaptrude cannot represent
-     *
+     * @throws OPERATION_FAILED if the kernel or the translation fails, or the
+     *   result is non-manifold, splits into several solids, or contains a surface
+     *   Snaptrude cannot represent (an offset free-form NURBS surface may have no
+     *   exact representation — the model is left unchanged). A distance the
+     *   solid cannot carry surfaces here, with a hint asking for a smaller one;
+     *   there is no per-face refusal — the kernel's per-face history verdict
+     *   ("this face was not offset") is logged, never raised (P4-D57)
+     *
+     * @examplePrompt Thicken the torus ring by 100 mm
      * @examplePrompt Grow this solid by 0.5m in every direction
      * @examplePrompt Shrink this mass by 200mm
      * @examplePrompt Offset the building envelope outward by 1m
@@ -503,6 +810,17 @@ export declare abstract class PluginGeomCreateApi {
      * input brep is read-only. The outer surface is kept and the walls grow
      * inward.
      *
+     * Works on curved solids: the open faces may be spherical, cylindrical,
+     * conical, toroidal or free-form patches, not only flat ones. To open the
+     * flat base of a dome, census the faces first — `core.geom.query.brep.listFaces`
+     * then `core.geom.query.face.getSurfaceKind` on each — and keep the `"plane"`
+     * one. A closed curved surface is stored as several patches (a sphere as
+     * lunes), so opening "the sphere" may mean passing several faces.
+     *
+     * When the input brep carries a creation recipe, the result carries it too,
+     * with this operation appended to `operations`; `design.create.massFromBrep`
+     * then keeps the mass editable through `design.update.parameters`.
+     *
      * Runs on the OpenCascade kernel (the first kernel call loads a wasm of
      * tens of MB — expect a pause of seconds).
      *
@@ -510,24 +828,36 @@ export declare abstract class PluginGeomCreateApi {
      * with `design.create.massFromBrep`.
      *
      * @param brep The solid to hollow
-     * @param openFaces The faces to remove as openings (≥1, all on `brep`)
+     * @param openFaces The faces to remove as openings (one or more, all on
+     *   `brep`, no duplicates; more than 32 still shells but the result carries
+     *   no parameter record)
      * @param thickness Wall thickness (positive, finite, smaller than half the solid's smallest span)
      * @returns The hollowed solid as a new {@linkcode BrepHandle}
-     * @throws VALIDATION if `openFaces` is empty, a face is not on `brep`,
-     *   `thickness` is not a positive finite number, or the thickness is too
-     *   large (it must be smaller than half the solid's smallest span)
-     * @throws OPERATION_FAILED if the kernel cannot build the shell or the
-     *   result contains curved surfaces Snaptrude cannot represent
-     *
+     * @throws VALIDATION if `openFaces` is empty or holds a duplicate, a face is
+     *   not on `brep`, `thickness` is not a positive finite number, or the
+     *   thickness is too large (it must be smaller than half the solid's smallest
+     *   span)
+     * @throws OPERATION_FAILED if the kernel or the translation fails, or the
+     *   result is non-manifold, splits into several solids, or contains a surface
+     *   Snaptrude cannot represent. A thickness the solid cannot carry surfaces
+     *   here, with a hint asking for one below half the smallest span; there is
+     *   no per-face refusal — the kernel's per-face history verdict ("this kept
+     *   face was not thickened") is logged, never raised (P4-D57)
+     *
+     * @examplePrompt Hollow the dome into a 300 mm shell, open at the base
      * @examplePrompt Hollow this mass into 200mm walls
      * @examplePrompt Shell this form with the top face open
      * @examplePrompt Turn this solid tower into a tube open at both ends
      *
      * # Example
      * ```ts
-     * const brep = await snaptrude.core.geom.create.brepFromExtrusion(contour, { x: 0, y: 1, z: 0 }, 3)
-     * const faces = await snaptrude.core.geom.query.brep.listFaces(brep)
-     * const hollow = await snaptrude.core.geom.create.brepFromShell(brep, [faces[0]], 0.2)
+     * // Open the dome at its flat base: the one face whose surface is a plane
+     * const faces = await snaptrude.core.geom.query.brep.listFaces(dome)
+     * const base = []
+     * for (const face of faces) {
+     *   if ((await snaptrude.core.geom.query.face.getSurfaceKind(face)) === "plane") base.push(face)
+     * }
+     * const hollow = await snaptrude.core.geom.create.brepFromShell(dome, base, 1.181) // 300 mm
      * ```
      */
     abstract brepFromShell(brep: BrepHandle, openFaces: FaceHandle[], thickness: number): PluginApiReturn<BrepHandle>;
@@ -567,28 +897,84 @@ export declare abstract class PluginGeomCreateApi {
      */
     abstract brepsFromSplit(brep: BrepHandle, planeOrigin: Vec3Components, planeNormal: Vec3Components): PluginApiReturn<BrepHandle[]>;
     /**
-     * Bevels the given straight edges of a solid with a symmetric planar cut.
-     * Host API call — returns a new {@linkcode BrepHandle}; the input brep is
-     * read-only.
+     * Cuts a solid with a FACE of another solid — the curved twin of
+     * {@linkcode PluginGeomCreateApi.brepsFromSplit}, which cuts with a plane.
+     * Host API call — returns new {@linkcode BrepHandle}s; both inputs are
+     * read-only. BOTH breps must be in the same frame: read scene masses with
+     * `design.query.geometry.getBrep(x, { frame: "world" })` (the default is each
+     * mass's own local frame, and two masses have two). The pieces come back in
+     * DESCENDING volume order; pick the one you want with
+     * `core.geom.query.brep.getCentroid` or `getVolume` and commit it. A piece
+     * carries no recipe — label it.
+     *
+     * Runs on the OpenCascade kernel (the first kernel call loads a wasm of tens
+     * of MB — expect a pause of seconds).
+     *
+     * @param brep The solid to cut
+     * @param toolFace The cutting face, read-only
+     * @param toolBrep The solid `toolFace` belongs to — a face handle cannot name
+     *   its own solid
+     * @returns The resulting pieces as {@linkcode BrepHandle}`[]`, largest first
+     * @throws VALIDATION if `toolFace` is not a face of `toolBrep`, `toolBrep` IS
+     *   `brep`, or the cut produced a single part — the surface does not pass all
+     *   the way through (extend it past the mass on every side, and check both
+     *   breps were read in the same frame)
+     * @throws OPERATION_FAILED if the kernel could not split the solid
+     *
+     * @examplePrompt Cut this mass with the curved roof surface and keep the lower part
+     *
+     * # Example
+     * ```ts
+     * const target = await snaptrude.design.query.geometry.getBrep(tower, { frame: "world" })
+     * const tool = await snaptrude.design.query.geometry.getBrep(roof, { frame: "world" })
+     * const [toolFace] = await snaptrude.core.geom.query.brep.listFaces(tool)
+     * const pieces = await snaptrude.core.geom.create.brepsFromSplitByFace(target, toolFace, tool)
+     * ```
+     */
+    abstract brepsFromSplitByFace(brep: BrepHandle, toolFace: FaceHandle, toolBrep: BrepHandle): PluginApiReturn<BrepHandle[]>;
+    /**
+     * Bevels the given edges of a solid with a symmetric planar cut. Host API
+     * call — returns a new {@linkcode BrepHandle}; the input brep is read-only.
+     *
+     * Works on curved solids: edges may be straight, circular or spline, and
+     * adjacent edges are allowed. Pick edges the same way as for
+     * {@linkcode PluginGeomCreateApi.brepFromFillet} — `brep.listEdges`, then
+     * `core.geom.query.edge.listFaces` and `core.geom.query.face.getSurfaceKind`
+     * on both faces of each edge. (`core.geom.query.brep.listEdgesBetween` takes
+     * two VERTEX indices — it is NOT a face-pair lookup.) Chamfering a cylinder's
+     * rim yields a cone patch where a fillet would yield a torus patch.
      *
-     * v1 chamfers straight edges only, and no two chamfered edges may share a
-     * vertex. Runs on the OpenCascade kernel (the first kernel call loads a
-     * wasm of tens of MB — expect a pause of seconds).
+     * When the input brep carries a creation recipe, the result carries it too,
+     * with this operation appended to `operations`; `design.create.massFromBrep`
+     * then keeps the mass editable through `design.update.parameters`.
+     *
+     * Runs on the OpenCascade kernel (the first kernel call loads a wasm of tens
+     * of MB — expect a pause of seconds).
      *
      * Inspect the result via `core.geom.query.brep.*`, or commit it to the scene
      * with `design.create.massFromBrep`.
      *
      * @param brep The solid whose edges to bevel
-     * @param edges The straight edges to chamfer (≥1, all on `brep`, no two sharing a vertex)
+     * @param edges The edges to chamfer (one or more, all on `brep`, no
+     *   duplicates; more than 64 still chamfers but the result carries no
+     *   parameter record)
      * @param distance Chamfer distance from the edge on each adjacent face (positive, finite)
      * @returns The chamfered solid as a new {@linkcode BrepHandle}
-     * @throws VALIDATION if `edges` is empty, `distance` is not a positive
-     *   finite number, an edge is not on `brep`, an edge is an arc (v1 chamfers
-     *   straight edges only), or two edges share a vertex (chamfer non-adjacent
-     *   edges)
-     * @throws OPERATION_FAILED if the kernel cannot build the chamfer (the
-     *   distance likely exceeds the adjacent face size — reduce it)
-     *
+     * @throws VALIDATION if `edges` is empty or holds a duplicate, `distance` is
+     *   not a positive finite number, an edge is not on `brep`, or an edge has no
+     *   crease to cut — it is a seam of a closed face, or it lies between two
+     *   patches of one smooth surface
+     * @throws PRECONDITION_FAILED if an edge could not be located on the kernel
+     *   solid after healing (select a different edge, or chamfer before the
+     *   operation that curved the solid)
+     * @throws OPERATION_FAILED if the kernel or the translation fails, or the
+     *   result is non-manifold, splits into several solids, or contains a surface
+     *   Snaptrude cannot represent. A distance larger than an adjacent face
+     *   surfaces here, with a hint asking for a smaller one: unlike
+     *   {@linkcode PluginGeomCreateApi.brepFromFillet}, a chamfer has no
+     *   per-edge kernel verdict, so the failure names no edge (P4-D59)
+     *
+     * @examplePrompt Chamfer the top edge of the cylinder
      * @examplePrompt Bevel these edges by 100mm
      * @examplePrompt Chamfer the top edges of the plinth
      * @examplePrompt Cut a 45-degree flat along the corners of this mass
@@ -619,11 +1005,15 @@ export declare abstract class PluginGeomCreateApi {
      * tapering across a bend or along an arc edge would create faces Snaptrude
      * cannot represent and throws (sweep each straight run separately and union
      * the results instead). An optional `transition` picks the corner
-     * treatment: `"miter"` (default) is today's sharp mitred bend;
+     * treatment: `"miter"` (default) is today's sharp mitred bend; `"round"`
+     * carries the section around each turning corner on a tangent circular arc,
+     * so the corner patch is a real curved (cylindrical) surface rather than a
+     * flat cut (open paths only — `"round"` on a closed ring path is refused);
      * `{ bevel: b }` chamfers each turning corner by cutting `b` back along
      * both adjacent legs (works on open and closed paths — each leg must be
-     * long enough for its cuts). On a corner-less path `transition` has no effect, and the
-     * varying-scale lane takes straight paths, so it never sees a corner.
+     * long enough for its cuts). On a corner-less path `transition` has no
+     * effect, and the varying-scale lane takes straight paths, so it never sees
+     * a corner.
      *
      * Open paths run on the OpenCascade kernel (the first kernel call loads a
      * wasm of tens of MB — expect a pause of seconds); closed paths are
@@ -633,19 +1023,22 @@ export declare abstract class PluginGeomCreateApi {
      * with `design.create.massFromBrep`.
      *
      * @param profile The cross-section to sweep (hole-free contour)
-     * @param path The polyline path as plain `{x, y, z}` points (≥2; repeat the
-     *   first point as the last to close the path into a ring)
+     * @param path The polyline path as plain `{x, y, z}` points (2 or more;
+     *   repeat the first point as the last to close the path into a ring; more
+     *   than 512 points still sweeps but the result carries no parameter record)
      * @param options Optional scale law and corner transition. Scale law:
      *   `startScale`/`endScale` (linear taper by arc length) or `scales` (one
      *   factor per path point; mutually exclusive with
      *   `startScale`/`endScale`); every factor must be finite and within
-     *   1e-3..1e3. `transition`: `"miter"` (default, sharp corners) or
-     *   `{ bevel: b }` (chamfered corners, `b` finite within 1e-3..1e3; open
-     *   and closed paths)
+     *   1e-3..1e3. `transition`: `"miter"` (default, sharp corners),
+     *   `"round"` (arc-carried corners — curved corner patches; open paths
+     *   only) or `{ bevel: b }` (chamfered corners, `b` finite within
+     *   1e-3..1e3; open and closed paths)
      * @returns The swept solid as a new {@linkcode BrepHandle}
      * @throws VALIDATION if the profile has holes, the path has fewer than 2
-     *   points, consecutive path points coincide, a coordinate is not finite,
-     *   or the profile plane contains the first path segment's direction
+     *   points, consecutive path points coincide, a
+     *   coordinate is not finite, or the profile plane contains the first
+     *   path segment's direction
      *   (degenerate sweep); for closed paths, if the ring has fewer than 3
      *   distinct corners, the path is non-planar, a corner doubles back, the
      *   profile has an arc edge, or the profile is too large for a mitred
@@ -653,11 +1046,14 @@ export declare abstract class PluginGeomCreateApi {
      *   is combined with `startScale`/`endScale`, `scales` does not match the
      *   path length, or a varying scale is used on a bent or closed path or
      *   with an arc-edged profile; for `{ bevel }`, if a leg is too short for
-     *   the cuts its beveled corners take from it or a corner nearly doubles
-     *   back so its chamfer collapses (the errors name the corner)
+     *   the cuts its bevelled corners take from it or a corner nearly doubles
+     *   back so its bevel collapses (the errors name the corner)
+     * @throws PRECONDITION_FAILED if `transition` is `"round"` and the path is
+     *   closed — round corners are an open-path lane; use `"miter"` or
+     *   `{ bevel }` on a ring
      * @throws OPERATION_FAILED if the kernel cannot sweep the profile into a
-     *   valid solid or a transition patch is a curved surface Snaptrude cannot
-     *   represent
+     *   valid solid — including a `"round"` corner whose arc does not fit its
+     *   legs, which is not pre-checked and so is not named per corner
      *
      * @examplePrompt Sweep this profile along the corridor path
      * @examplePrompt Extrude the railing section along this route
@@ -666,6 +1062,7 @@ export declare abstract class PluginGeomCreateApi {
      * @examplePrompt Taper this duct from 1x1 to 2x2 along its run
      * @examplePrompt Sweep a column section that narrows toward the top
      * @examplePrompt Chamfer the corners of this swept frame by 200mm
+     * @examplePrompt Sweep this handrail with rounded corners at the bends
      *
      * # Example
      * ```ts
@@ -701,17 +1098,70 @@ export declare abstract class PluginGeomCreateApi {
         startScale?: number;
         endScale?: number;
         scales?: number[];
-        transition?: "miter" | {
+        transition?: "miter" | "round" | {
             bevel: number;
         };
     }): PluginApiReturn<BrepHandle>;
+    /**
+     * Sweeps a cross-section along a SMOOTH path — splines, arcs and lines chained
+     * end to end — with control of how the profile turns.
+     * {@linkcode PluginGeomCreateApi.brepFromSweep} takes a polyline path; this
+     * takes curves. Host API call — returns a new {@linkcode BrepHandle}; the
+     * inputs are read-only. Records as `sweepAlongCurve`, so the orientation stays
+     * editable through `design.update.parameters` (agent-editable; the panel shows
+     * it read-only — a string is not a scalar row).
+     *
+     * Runs on the OpenCascade kernel (the first kernel call loads a wasm of tens
+     * of MB — expect a pause of seconds).
+     *
+     * @param profile Hole-free cross-section contour; placed at the first curve's start
+     * @param path 1..64 curves, ordered, meeting end to end within tolerance
+     * @param options `orientation` — `"upright"` (default) keeps the profile's up
+     *   aligned with world up (ducts, handrails, ribbons that must not roll);
+     *   `"frenet"` lets it roll with the path's curvature; `"fixed"` carries the
+     *   authored frame along unchanged, which is a pure translation — use it to
+     *   bend a footprint along an arc. `rail` is a second guide curve and needs a
+     *   newer kernel build than the one shipped here.
+     * @returns The swept solid as a new {@linkcode BrepHandle}
+     * @throws VALIDATION if the path curves are not connected, the path is closed,
+     *   the profile has holes, the first tangent lies in the profile plane, the
+     *   path runs vertically under `"upright"` (that frame is undefined there —
+     *   the message names the run and points at `"frenet"`), the path turns
+     *   parallel to the profile under `"fixed"`, or `rail` is passed on a kernel
+     *   build that cannot carry it
+     * @throws OPERATION_FAILED if the kernel could not sweep the profile — a
+     *   self-intersection on a tight bend
+     *
+     * @examplePrompt Sweep a 600x400 duct along this curved route and keep it upright
+     * @examplePrompt Run this handrail along the curved stair edge
+     * @examplePrompt Bend this footprint along the arc
+     *
+     * # Example
+     * ```ts
+     * const route = await snaptrude.core.geom.create.splineFromPoints(points)
+     * const duct = await snaptrude.core.geom.create.brepFromSweepAlongCurve(profile, [route], {
+     *   orientation: "upright",
+     * })
+     * ```
+     */
+    abstract brepFromSweepAlongCurve(profile: ContourHandle, path: CurveHandle[], options?: SweepAlongCurveOptions): PluginApiReturn<BrepHandle>;
     /**
      * Revolves a planar profile about an axis to make a solid of revolution — a
      * full turn by default. Host API call — returns a new
      * {@linkcode BrepHandle}; the input contour is read-only. Holes in the
-     * profile are allowed. Profile segments must stay parallel or perpendicular
-     * to the axis — inclined or arc segments would revolve into surfaces
-     * Snaptrude cannot represent.
+     * profile are allowed, and segments may run at any angle to the axis: an
+     * inclined segment revolves into a cone, an arc into a sphere or torus
+     * section. This is the general route to domes, vases, columns and rotundas.
+     *
+     * Two rules bind the axis to the profile. First, the axis line must lie IN
+     * the profile's plane — a revolution turns a planar section about a line
+     * drawn in that same plane. An axis that misses the plane (skew to it, or
+     * parallel but offset out of it) is refused: move the axis into the
+     * profile's plane, or move the profile onto the axis's plane. Second,
+     * within that plane the whole profile stays on ONE side of the axis.
+     * Vertices and whole segments may lie ON the axis — that is how a dome's
+     * pole and a cylinder's inner edge are authored — but no part of the profile
+     * may cross to the other side, which would sweep a self-intersecting solid.
      *
      * Runs on the OpenCascade kernel (the first kernel call loads a wasm of
      * tens of MB — expect a pause of seconds).
@@ -725,19 +1175,25 @@ export declare abstract class PluginGeomCreateApi {
      * @param angleInDegrees Optional revolution angle in degrees (0 < angle ≤ 360; default 360)
      * @returns The revolved solid as a new {@linkcode BrepHandle}
      * @throws VALIDATION if `axisDirection` is zero-length, `angleInDegrees` is
-     *   not in (0, 360], the axis passes through the profile interior, or a
-     *   coordinate is not finite
-     * @throws OPERATION_FAILED if the kernel cannot revolve the profile or the
-     *   result contains curved surfaces Snaptrude cannot represent (keep
-     *   profile segments parallel or perpendicular to the axis)
+     *   not in (0, 360], a coordinate is not finite, or the profile crosses the
+     *   axis (the message names the offending segment — keep the whole profile
+     *   on one side; points may touch the axis but not cross it)
+     * @throws PRECONDITION_FAILED if the axis does not lie in the profile's
+     *   plane — skew to it, or parallel but offset out of it (the message asks
+     *   you to move the axis into that plane)
+     * @throws OPERATION_FAILED if the kernel cannot revolve the profile into a
+     *   valid solid
      *
      * @examplePrompt Create a dome from this section
      * @examplePrompt Revolve this profile 360 degrees around the vertical axis
      * @examplePrompt Build a rotunda by revolving this wall section
+     * @examplePrompt Make a dome by revolving a quarter-circle about the vertical axis
+     * @examplePrompt Turn this curved outline into a vase
      *
      * # Example
      * ```ts
-     * // A cylinder: revolve a 2m-wide, 3m-tall rectangle about the Y axis at its edge
+     * // A cylinder: revolve a 2m-wide, 3m-tall rectangle about the Y axis at
+     * // its edge — the left edge sits ON the axis, which is legal.
      * const rect = await snaptrude.core.geom.create.profileFromLinePoints([
      *   await snaptrude.core.math.vec3.new(0, 0, 0),
      *   await snaptrude.core.math.vec3.new(2, 0, 0),
@@ -753,6 +1209,135 @@ export declare abstract class PluginGeomCreateApi {
      * ```
      */
     abstract brepFromRevolution(profile: ContourHandle, axisOrigin: Vec3Components, axisDirection: Vec3Components, angleInDegrees?: number): PluginApiReturn<BrepHandle>;
+    /**
+     * Create a solid **sphere** B-rep from a centre and radius. Host API call —
+     * returns a {@linkcode BrepHandle}; commit it to the scene with
+     * `design.create.massFromBrep`. The result carries an exact spherical
+     * surface (not a faceted approximation) and a creation recipe — read the
+     * committed mass's parameters back with `design.query.getParameters` and edit
+     * them with `design.update.parameters`.
+     *
+     * Runs on the OpenCascade kernel (the first kernel call loads a wasm of tens
+     * of MB — expect a pause of seconds).
+     *
+     * @param centre Sphere centre as plain `{x, y, z}` components (raw Babylon units)
+     * @param radius Sphere radius (> 0, raw Babylon units)
+     * @returns The new solid as a {@linkcode BrepHandle}
+     * @throws VALIDATION if `radius` is not a positive finite number or a
+     *   coordinate is not finite
+     *
+     * @examplePrompt Create a sphere of radius 5 at the origin
+     * @examplePrompt Add a 3m ball on top of the tower
+     *
+     * # Example
+     * ```ts
+     * const brep = await snaptrude.core.geom.create.brepFromSphere({ x: 0, y: 5, z: 0 }, 5)
+     * const mass = await snaptrude.design.create.massFromBrep(brep, "Sphere")
+     * ```
+     */
+    abstract brepFromSphere(centre: Vec3Components, radius: number): PluginApiReturn<BrepHandle>;
+    /**
+     * Create a solid **cylinder** B-rep from its bottom-cap centre, axis
+     * direction, radius and height. Host API call — returns a
+     * {@linkcode BrepHandle}; commit with `design.create.massFromBrep`. The
+     * bottom cap sits AT `base` and the solid extends `height` along `axis` —
+     * place `base` on the floor and use axis `{x: 0, y: 1, z: 0}` for an upright
+     * column. Carries a creation recipe (radius, height), editable through
+     * `design.update.parameters`.
+     *
+     * Runs on the OpenCascade kernel (the first kernel call loads a wasm of tens
+     * of MB — expect a pause of seconds).
+     *
+     * @param base Centre of the bottom cap as plain `{x, y, z}` components
+     * @param axis Axis direction as plain `{x, y, z}` components (non-zero, normalised by the host)
+     * @param radius Cylinder radius (> 0)
+     * @param height Cylinder height along `axis` (> 0)
+     * @returns The new solid as a {@linkcode BrepHandle}
+     * @throws VALIDATION if `radius`/`height` are not positive finite numbers or
+     *   `axis` is zero-length
+     *
+     * @examplePrompt Create a cylinder 2m across and 4m tall
+     * @examplePrompt Add a circular column here
+     *
+     * # Example
+     * ```ts
+     * const brep = await snaptrude.core.geom.create.brepFromCylinder(
+     *   { x: 0, y: 0, z: 0 },
+     *   { x: 0, y: 1, z: 0 },
+     *   1,
+     *   4,
+     * )
+     * const column = await snaptrude.design.create.massFromBrep(brep, "Column")
+     * ```
+     */
+    abstract brepFromCylinder(base: Vec3Components, axis: Vec3Components, radius: number, height: number): PluginApiReturn<BrepHandle>;
+    /**
+     * Create a solid **cone or frustum** B-rep: bottom-cap centre, axis, base
+     * radius, height, and an optional top radius (default 0 — a full cone to a
+     * point; > 0 — a frustum / tapered column). Host API call — returns a
+     * {@linkcode BrepHandle}; commit with `design.create.massFromBrep`. Carries
+     * a creation recipe (radii + height), editable through `design.update.parameters`.
+     *
+     * Runs on the OpenCascade kernel (the first kernel call loads a wasm of tens
+     * of MB — expect a pause of seconds).
+     *
+     * @param base Centre of the bottom cap as plain `{x, y, z}` components
+     * @param axis Axis direction as plain `{x, y, z}` components (non-zero, normalised by the host)
+     * @param baseRadius Radius at the base (> 0)
+     * @param height Height along `axis` (> 0)
+     * @param topRadius Optional radius at the top (≥ 0, ≠ `baseRadius`; default 0 = apex)
+     * @returns The new solid as a {@linkcode BrepHandle}
+     * @throws VALIDATION if radii/height are invalid, `topRadius === baseRadius`
+     *   (that is a cylinder — use {@linkcode PluginGeomCreateApi.brepFromCylinder}),
+     *   or `axis` is zero-length
+     *
+     * @examplePrompt Create a cone roof 4m wide and 3m tall
+     * @examplePrompt Make a tapered column narrowing from 1m to 0.6m
+     *
+     * # Example
+     * ```ts
+     * const roof = await snaptrude.core.geom.create.brepFromCone(
+     *   { x: 0, y: 9, z: 0 },
+     *   { x: 0, y: 1, z: 0 },
+     *   2,
+     *   3,
+     * )
+     * ```
+     */
+    abstract brepFromCone(base: Vec3Components, axis: Vec3Components, baseRadius: number, height: number, topRadius?: number): PluginApiReturn<BrepHandle>;
+    /**
+     * Create a solid **torus** (ring / donut) B-rep from its centre, plane
+     * normal, ring radius and tube radius. Host API call — returns a
+     * {@linkcode BrepHandle}; commit with `design.create.massFromBrep`.
+     * `majorRadius` is centre-to-tube-centre; `minorRadius` is the tube's own
+     * radius and must be strictly smaller. Carries a creation recipe, editable
+     * through `design.update.parameters`.
+     *
+     * Runs on the OpenCascade kernel (the first kernel call loads a wasm of tens
+     * of MB — expect a pause of seconds).
+     *
+     * @param centre Torus centre as plain `{x, y, z}` components
+     * @param axis Plane normal of the ring as plain `{x, y, z}` components (non-zero)
+     * @param majorRadius Ring radius, centre to tube centre (> 0)
+     * @param minorRadius Tube radius (> 0 and < `majorRadius` — a self-intersecting torus is rejected)
+     * @returns The new solid as a {@linkcode BrepHandle}
+     * @throws VALIDATION if a radius is invalid, `minorRadius >= majorRadius`,
+     *   or `axis` is zero-length
+     *
+     * @examplePrompt Create a donut-shaped ring 10m across with a 1m tube
+     * @examplePrompt Add a torus canopy around the tower
+     *
+     * # Example
+     * ```ts
+     * const ring = await snaptrude.core.geom.create.brepFromTorus(
+     *   { x: 0, y: 6, z: 0 },
+     *   { x: 0, y: 1, z: 0 },
+     *   5,
+     *   1,
+     * )
+     * ```
+     */
+    abstract brepFromTorus(centre: Vec3Components, axis: Vec3Components, majorRadius: number, minorRadius: number): PluginApiReturn<BrepHandle>;
 }
 /**
  * Arguments for {@linkcode PluginGeomCreateApi.line}.
@@ -799,6 +1384,32 @@ export declare const PluginGeomCreateCircleArgs: z.ZodObject<{
     radius: z.ZodNumber;
 }, z.core.$strip>;
 export type PluginGeomCreateCircleArgs = z.infer<typeof PluginGeomCreateCircleArgs>;
+/**
+ * Arguments for {@linkcode PluginGeomCreateApi.splineFromPoints}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `points` | {@linkcode Vec3Handle}`[]` | 3..256 ordered through-points of the curve |
+ */
+export declare const PluginGeomCreateSplineFromPointsArgs: z.ZodObject<{
+    points: z.ZodArray<z.ZodPipe<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>, z.ZodTransform<import("../../../..").Handle<"vec3">, string>>>;
+}, z.core.$strip>;
+export type PluginGeomCreateSplineFromPointsArgs = z.infer<typeof PluginGeomCreateSplineFromPointsArgs>;
+/**
+ * Arguments for {@linkcode PluginGeomCreateApi.splineFromControlPoints}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `controlPoints` | {@linkcode Vec3Handle}`[]` | 3..512 control points of the curve, in order |
+ * | `options` | `object`? | `degree`: 2 or 3 (default `min(3, controlPoints.length - 1)`) |
+ */
+export declare const PluginGeomCreateSplineFromControlPointsArgs: z.ZodObject<{
+    controlPoints: z.ZodArray<z.ZodPipe<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>, z.ZodTransform<import("../../../..").Handle<"vec3">, string>>>;
+    options: z.ZodOptional<z.ZodObject<{
+        degree: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type PluginGeomCreateSplineFromControlPointsArgs = z.infer<typeof PluginGeomCreateSplineFromControlPointsArgs>;
 /**
  * Arguments for {@linkcode PluginGeomCreateApi.profileFromLinePoints}.
  *
@@ -818,9 +1429,20 @@ export type PluginGeomCreateProfileFromLinePointsArgs = z.infer<typeof PluginGeo
  * | `curves` | {@linkcode CurveHandle}`[]` | Ordered curve handles forming a closed loop |
  */
 export declare const PluginGeomCreateProfileFromCurvesArgs: z.ZodObject<{
-    curves: z.ZodArray<z.ZodUnion<readonly [z.ZodPipe<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>, z.ZodTransform<import("../../../..").Handle<"line">, string>>, z.ZodPipe<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>, z.ZodTransform<import("../../../..").Handle<"arc">, string>>]>>;
+    curves: z.ZodArray<z.ZodType<CurveHandle, unknown, z.core.$ZodTypeInternals<CurveHandle, unknown>>>;
 }, z.core.$strip>;
 export type PluginGeomCreateProfileFromCurvesArgs = z.infer<typeof PluginGeomCreateProfileFromCurvesArgs>;
+/**
+ * Arguments for {@linkcode PluginGeomCreateApi.profileFromSplinePoints}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `points` | {@linkcode Vec3Handle}`[]` | 3..256 ordered through-points of the closed loop (first point NOT repeated) |
+ */
+export declare const PluginGeomCreateProfileFromSplinePointsArgs: z.ZodObject<{
+    points: z.ZodArray<z.ZodPipe<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>, z.ZodTransform<import("../../../..").Handle<"vec3">, string>>>;
+}, z.core.$strip>;
+export type PluginGeomCreateProfileFromSplinePointsArgs = z.infer<typeof PluginGeomCreateProfileFromSplinePointsArgs>;
 /**
  * Arguments for {@linkcode PluginGeomCreateApi.contourFromProfile}.
  *
@@ -868,6 +1490,7 @@ export type PluginGeomCreateBrepFromFacesArgs = z.infer<typeof PluginGeomCreateB
  * | `contour` | {@linkcode ContourHandle} | The cross-section to extrude |
  * | `direction` | {@linkcode Vec3Components} | Extrusion direction (non-zero, finite components) |
  * | `amount` | `number` | Extrusion distance (finite, non-zero) |
+ * | `options` | `object`? | Optional twist and taper: `twistInDegrees` (an angle, finite), `topScale` (a ratio, finite and positive) and `levels` (a count, 2..64) |
  */
 export declare const PluginGeomCreateBrepFromExtrusionArgs: z.ZodObject<{
     contour: z.ZodPipe<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>, z.ZodTransform<import("../../../..").Handle<"contour">, string>>;
@@ -877,6 +1500,11 @@ export declare const PluginGeomCreateBrepFromExtrusionArgs: z.ZodObject<{
         z: z.ZodNumber;
     }, z.core.$strip>;
     amount: z.ZodNumber;
+    options: z.ZodOptional<z.ZodObject<{
+        twistInDegrees: z.ZodOptional<z.ZodNumber>;
+        topScale: z.ZodOptional<z.ZodNumber>;
+        levels: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
 }, z.core.$strip>;
 export type PluginGeomCreateBrepFromExtrusionArgs = z.infer<typeof PluginGeomCreateBrepFromExtrusionArgs>;
 /**
@@ -886,8 +1514,8 @@ export type PluginGeomCreateBrepFromExtrusionArgs = z.infer<typeof PluginGeomCre
  * |---|---|---|
  * | `bottomContour` | {@linkcode ContourHandle} | The bottom cross-section |
  * | `topContour` | {@linkcode ContourHandle} | The top cross-section |
- * | `intermediateContours` | {@linkcode ContourHandle}`[]`? | Optional in-between cross-sections, ordered bottom to top |
- * | `options` | `object`? | Optional behavior switches: `compatibility` (`"strict"` throws on mismatched edge counts instead of auto-matching; default `"auto"`) and `seamAlignment` (`"authored"` keeps the authored correspondence instead of searching seam rotations; default `"auto"`) |
+ * | `intermediateContours` | {@linkcode ContourHandle}`[]`? | Optional in-between cross-sections, ordered bottom to top (any count; more than 32 sections in all builds but carries no parameter record) |
+ * | `options` | `object`? | Optional behavior switches: `compatibility` (`"strict"` throws on mismatched edge counts instead of auto-matching; default `"auto"`), `seamAlignment` (`"authored"` keeps the authored correspondence instead of searching seam rotations; default `"auto"`) and `smoothing` (`"smooth"` lofts every section in one pass, so the sides curve through the intermediates; default `"ruled"`) |
  */
 export declare const PluginGeomCreateBrepFromLoftArgs: z.ZodObject<{
     bottomContour: z.ZodPipe<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>, z.ZodTransform<import("../../../..").Handle<"contour">, string>>;
@@ -902,6 +1530,10 @@ export declare const PluginGeomCreateBrepFromLoftArgs: z.ZodObject<{
             auto: "auto";
             authored: "authored";
         }>>;
+        smoothing: z.ZodOptional<z.ZodEnum<{
+            ruled: "ruled";
+            smooth: "smooth";
+        }>>;
     }, z.core.$strip>>;
 }, z.core.$strip>;
 export type PluginGeomCreateBrepFromLoftArgs = z.infer<typeof PluginGeomCreateBrepFromLoftArgs>;
@@ -944,15 +1576,62 @@ export type PluginGeomCreateBrepBooleanArgs = z.infer<typeof PluginGeomCreateBre
  * | Property | Type | Description |
  * |---|---|---|
  * | `brep` | {@linkcode BrepHandle} | The solid whose edges to round |
- * | `edges` | {@linkcode EdgeHandle}`[]` | The straight edges to fillet (≥1) |
- * | `radius` | `number` | Fillet radius (positive, finite) |
+ * | `edges` | {@linkcode EdgeHandle}`[]` | The edges to fillet (one or more; more than 64 builds but carries no parameter record) |
+ * | `radius` | `number` | Fillet radius (positive, finite); the start radius of a variable blend |
+ * | `options` | `object`? | Optional variable blend: `endRadius` (positive, finite) or `radii` (2..32 rows of `{ position, radius }`, `position` a ratio 0..1 strictly increasing). Mutually exclusive, and either one takes exactly ONE edge |
  */
 export declare const PluginGeomCreateBrepFromFilletArgs: z.ZodObject<{
     brep: z.ZodPipe<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>, z.ZodTransform<import("../../../..").Handle<"brep">, string>>;
     edges: z.ZodArray<z.ZodPipe<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>, z.ZodTransform<import("../../../..").Handle<"edge">, string>>>;
     radius: z.ZodNumber;
+    options: z.ZodOptional<z.ZodObject<{
+        endRadius: z.ZodOptional<z.ZodNumber>;
+        radii: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            position: z.ZodNumber;
+            radius: z.ZodNumber;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>;
 }, z.core.$strip>;
 export type PluginGeomCreateBrepFromFilletArgs = z.infer<typeof PluginGeomCreateBrepFromFilletArgs>;
+/** An edge with the solid it belongs to. See {@linkcode OwnedEdge}. */
+export declare const OwnedEdge: z.ZodObject<{
+    edge: z.ZodPipe<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>, z.ZodTransform<import("../../../..").Handle<"edge">, string>>;
+    brep: z.ZodPipe<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>, z.ZodTransform<import("../../../..").Handle<"brep">, string>>;
+    face: z.ZodOptional<z.ZodPipe<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>, z.ZodTransform<import("../../../..").Handle<"face">, string>>>;
+}, z.core.$strip>;
+/**
+ * Arguments for {@linkcode PluginGeomCreateApi.brepFromPatch}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `boundary` | ({@linkcode CurveHandle} \| {@linkcode OwnedEdge})`[]` | 3..16 items forming one closed loop |
+ * | `thickness` | `number` | Solid thickness in internal length units (positive, finite) |
+ * | `options` | `object`? | `interiorPoints` (≤ 64 plain `{x, y, z}` the surface is pulled through), `continuity` (`"position"` default, or `"tangent"` — every item must then be an edge item naming its `face`), `side` (`"below"` default, or `"above"`) |
+ */
+export declare const PluginGeomCreateBrepFromPatchArgs: z.ZodObject<{
+    boundary: z.ZodArray<z.ZodUnion<readonly [z.ZodType<CurveHandle, unknown, z.core.$ZodTypeInternals<CurveHandle, unknown>>, z.ZodObject<{
+        edge: z.ZodPipe<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>, z.ZodTransform<import("../../../..").Handle<"edge">, string>>;
+        brep: z.ZodPipe<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>, z.ZodTransform<import("../../../..").Handle<"brep">, string>>;
+        face: z.ZodOptional<z.ZodPipe<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>, z.ZodTransform<import("../../../..").Handle<"face">, string>>>;
+    }, z.core.$strip>]>>;
+    thickness: z.ZodNumber;
+    options: z.ZodOptional<z.ZodObject<{
+        interiorPoints: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            x: z.ZodNumber;
+            y: z.ZodNumber;
+            z: z.ZodNumber;
+        }, z.core.$strip>>>;
+        continuity: z.ZodOptional<z.ZodEnum<{
+            position: "position";
+            tangent: "tangent";
+        }>>;
+        side: z.ZodOptional<z.ZodEnum<{
+            below: "below";
+            above: "above";
+        }>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type PluginGeomCreateBrepFromPatchArgs = z.infer<typeof PluginGeomCreateBrepFromPatchArgs>;
 /**
  * Arguments for {@linkcode PluginGeomCreateApi.brepFromOffset}.
  *
@@ -972,7 +1651,7 @@ export type PluginGeomCreateBrepFromOffsetArgs = z.infer<typeof PluginGeomCreate
  * | Property | Type | Description |
  * |---|---|---|
  * | `brep` | {@linkcode BrepHandle} | The solid to hollow |
- * | `openFaces` | {@linkcode FaceHandle}`[]` | The faces to remove as openings (≥1) |
+ * | `openFaces` | {@linkcode FaceHandle}`[]` | The faces to remove as openings (one or more; more than 32 builds but carries no parameter record) |
  * | `thickness` | `number` | Wall thickness (positive, finite) |
  */
 export declare const PluginGeomCreateBrepFromShellArgs: z.ZodObject<{
@@ -1004,13 +1683,43 @@ export declare const PluginGeomCreateBrepsFromSplitArgs: z.ZodObject<{
     }, z.core.$strip>;
 }, z.core.$strip>;
 export type PluginGeomCreateBrepsFromSplitArgs = z.infer<typeof PluginGeomCreateBrepsFromSplitArgs>;
+/**
+ * Arguments for {@linkcode PluginGeomCreateApi.brepsFromSplitByFace}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `brep` | {@linkcode BrepHandle} | The solid to cut |
+ * | `toolFace` | {@linkcode FaceHandle} | The cutting face (read-only) |
+ * | `toolBrep` | {@linkcode BrepHandle} | The solid `toolFace` belongs to (owner last) |
+ */
+export declare const PluginGeomCreateBrepsFromSplitByFaceArgs: z.ZodObject<{
+    brep: z.ZodPipe<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>, z.ZodTransform<import("../../../..").Handle<"brep">, string>>;
+    toolFace: z.ZodPipe<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>, z.ZodTransform<import("../../../..").Handle<"face">, string>>;
+    toolBrep: z.ZodPipe<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>, z.ZodTransform<import("../../../..").Handle<"brep">, string>>;
+}, z.core.$strip>;
+export type PluginGeomCreateBrepsFromSplitByFaceArgs = z.infer<typeof PluginGeomCreateBrepsFromSplitByFaceArgs>;
+/**
+ * Arguments for {@linkcode PluginGeomCreateApi.curvesFromProjection}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `curve` | {@linkcode CurveHandle} | The curve to project |
+ * | `face` | {@linkcode FaceHandle} | The face to project onto |
+ * | `faceBrep` | {@linkcode BrepHandle} | The solid `face` belongs to (owner last) |
+ */
+export declare const PluginGeomCreateCurvesFromProjectionArgs: z.ZodObject<{
+    curve: z.ZodType<CurveHandle, unknown, z.core.$ZodTypeInternals<CurveHandle, unknown>>;
+    face: z.ZodPipe<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>, z.ZodTransform<import("../../../..").Handle<"face">, string>>;
+    faceBrep: z.ZodPipe<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>, z.ZodTransform<import("../../../..").Handle<"brep">, string>>;
+}, z.core.$strip>;
+export type PluginGeomCreateCurvesFromProjectionArgs = z.infer<typeof PluginGeomCreateCurvesFromProjectionArgs>;
 /**
  * Arguments for {@linkcode PluginGeomCreateApi.brepFromChamfer}.
  *
  * | Property | Type | Description |
  * |---|---|---|
  * | `brep` | {@linkcode BrepHandle} | The solid whose edges to bevel |
- * | `edges` | {@linkcode EdgeHandle}`[]` | The straight edges to chamfer (≥1) |
+ * | `edges` | {@linkcode EdgeHandle}`[]` | The edges to chamfer (one or more; more than 64 builds but carries no parameter record) |
  * | `distance` | `number` | Chamfer distance from the edge on each adjacent face (positive, finite) |
  */
 export declare const PluginGeomCreateBrepFromChamferArgs: z.ZodObject<{
@@ -1025,8 +1734,8 @@ export type PluginGeomCreateBrepFromChamferArgs = z.infer<typeof PluginGeomCreat
  * | Property | Type | Description |
  * |---|---|---|
  * | `profile` | {@linkcode ContourHandle} | The cross-section to sweep (hole-free) |
- * | `path` | {@linkcode Vec3Components}`[]` | The polyline path (≥2 points, finite components; repeating the first point as the last closes it into a ring — closed paths must be flat and straight-segmented and take a straight-edged profile) |
- * | `options` | `object`? | Optional scale law: `startScale`/`endScale` (linear taper by arc length) or per-point `scales` (mutually exclusive; factors finite, 1e-3..1e3; `scales.length` must equal `path.length`). Optional corner `transition`: `"miter"` (default) or `{ bevel }` (chamfered corners; finite, 1e-3..1e3) |
+ * | `path` | {@linkcode Vec3Components}`[]` | The polyline path (2 or more points, finite components — more than 512 builds but carries no parameter record; repeating the first point as the last closes it into a ring — closed paths must be flat and straight-segmented and take a straight-edged profile) |
+ * | `options` | `object`? | Optional scale law: `startScale`/`endScale` (linear taper by arc length) or per-point `scales` (mutually exclusive; factors finite, 1e-3..1e3; `scales.length` must equal `path.length`). Optional corner `transition`: `"miter"` (default), `"round"` (arc-carried corners) or `{ bevel }` (chamfered corners; finite, 1e-3..1e3) |
  */
 export declare const PluginGeomCreateBrepFromSweepArgs: z.ZodObject<{
     profile: z.ZodPipe<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>, z.ZodTransform<import("../../../..").Handle<"contour">, string>>;
@@ -1039,20 +1748,42 @@ export declare const PluginGeomCreateBrepFromSweepArgs: z.ZodObject<{
         startScale: z.ZodOptional<z.ZodNumber>;
         endScale: z.ZodOptional<z.ZodNumber>;
         scales: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
-        transition: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"miter">, z.ZodObject<{
+        transition: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"miter">, z.ZodLiteral<"round">, z.ZodObject<{
             bevel: z.ZodNumber;
         }, z.core.$strip>]>>;
     }, z.core.$strip>>;
 }, z.core.$strip>;
 export type PluginGeomCreateBrepFromSweepArgs = z.infer<typeof PluginGeomCreateBrepFromSweepArgs>;
+/**
+ * Arguments for {@linkcode PluginGeomCreateApi.brepFromSweepAlongCurve}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `profile` | {@linkcode ContourHandle} | The cross-section to sweep (hole-free) |
+ * | `path` | {@linkcode CurveHandle}`[]` | 1..64 curves, ordered, meeting end to end |
+ * | `options` | `object`? | `orientation` — `"upright"` (default), `"frenet"` or `"fixed"`; `rail` — a second guide {@linkcode CurveHandle} (needs a newer kernel build) |
+ */
+export declare const PluginGeomCreateBrepFromSweepAlongCurveArgs: z.ZodObject<{
+    profile: z.ZodPipe<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>, z.ZodTransform<import("../../../..").Handle<"contour">, string>>;
+    path: z.ZodArray<z.ZodType<CurveHandle, unknown, z.core.$ZodTypeInternals<CurveHandle, unknown>>>;
+    options: z.ZodOptional<z.ZodObject<{
+        orientation: z.ZodOptional<z.ZodEnum<{
+            fixed: "fixed";
+            frenet: "frenet";
+            upright: "upright";
+        }>>;
+        rail: z.ZodOptional<z.ZodType<CurveHandle, unknown, z.core.$ZodTypeInternals<CurveHandle, unknown>>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type PluginGeomCreateBrepFromSweepAlongCurveArgs = z.infer<typeof PluginGeomCreateBrepFromSweepAlongCurveArgs>;
 /**
  * Arguments for {@linkcode PluginGeomCreateApi.brepFromRevolution}.
  *
  * | Property | Type | Description |
  * |---|---|---|
  * | `profile` | {@linkcode ContourHandle} | The cross-section to revolve (holes allowed) |
- * | `axisOrigin` | {@linkcode Vec3Components} | A point on the revolution axis (finite components) |
- * | `axisDirection` | {@linkcode Vec3Components} | The axis direction (non-zero, finite components) |
+ * | `axisOrigin` | {@linkcode Vec3Components} | A point on the revolution axis (finite components; the axis must lie in the profile's plane) |
+ * | `axisDirection` | {@linkcode Vec3Components} | The axis direction (non-zero, finite components; the axis must lie in the profile's plane) |
  * | `angleInDegrees` | `number`? | Revolution angle in degrees (0 < angle ≤ 360; default 360) |
  */
 export declare const PluginGeomCreateBrepFromRevolutionArgs: z.ZodObject<{
@@ -1070,4 +1801,98 @@ export declare const PluginGeomCreateBrepFromRevolutionArgs: z.ZodObject<{
     angleInDegrees: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strip>;
 export type PluginGeomCreateBrepFromRevolutionArgs = z.infer<typeof PluginGeomCreateBrepFromRevolutionArgs>;
+/**
+ * Arguments for {@linkcode PluginGeomCreateApi.brepFromSphere}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `centre` | {@linkcode Vec3Components} | Sphere centre (finite components) |
+ * | `radius` | `number` | Sphere radius (finite; positivity is checked host-side so the error names the parameter) |
+ */
+export declare const PluginGeomCreateBrepFromSphereArgs: z.ZodObject<{
+    centre: z.ZodObject<{
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+        z: z.ZodNumber;
+    }, z.core.$strip>;
+    radius: z.ZodNumber;
+}, z.core.$strip>;
+export type PluginGeomCreateBrepFromSphereArgs = z.infer<typeof PluginGeomCreateBrepFromSphereArgs>;
+/**
+ * Arguments for {@linkcode PluginGeomCreateApi.brepFromCylinder}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `base` | {@linkcode Vec3Components} | Centre of the bottom cap (finite components) |
+ * | `axis` | {@linkcode Vec3Components} | Axis direction (non-zero, finite components) |
+ * | `radius` | `number` | Cylinder radius (finite, positive) |
+ * | `height` | `number` | Height along `axis` (finite, positive) |
+ */
+export declare const PluginGeomCreateBrepFromCylinderArgs: z.ZodObject<{
+    base: z.ZodObject<{
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+        z: z.ZodNumber;
+    }, z.core.$strip>;
+    axis: z.ZodObject<{
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+        z: z.ZodNumber;
+    }, z.core.$strip>;
+    radius: z.ZodNumber;
+    height: z.ZodNumber;
+}, z.core.$strip>;
+export type PluginGeomCreateBrepFromCylinderArgs = z.infer<typeof PluginGeomCreateBrepFromCylinderArgs>;
+/**
+ * Arguments for {@linkcode PluginGeomCreateApi.brepFromCone}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `base` | {@linkcode Vec3Components} | Centre of the bottom cap (finite components) |
+ * | `axis` | {@linkcode Vec3Components} | Axis direction (non-zero, finite components) |
+ * | `baseRadius` | `number` | Radius at the base (finite, positive) |
+ * | `height` | `number` | Height along `axis` (finite, positive) |
+ * | `topRadius` | `number`? | Radius at the top (finite, ≥ 0, ≠ `baseRadius`; default 0 = apex) |
+ */
+export declare const PluginGeomCreateBrepFromConeArgs: z.ZodObject<{
+    base: z.ZodObject<{
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+        z: z.ZodNumber;
+    }, z.core.$strip>;
+    axis: z.ZodObject<{
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+        z: z.ZodNumber;
+    }, z.core.$strip>;
+    baseRadius: z.ZodNumber;
+    height: z.ZodNumber;
+    topRadius: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type PluginGeomCreateBrepFromConeArgs = z.infer<typeof PluginGeomCreateBrepFromConeArgs>;
+/**
+ * Arguments for {@linkcode PluginGeomCreateApi.brepFromTorus}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `centre` | {@linkcode Vec3Components} | Torus centre (finite components) |
+ * | `axis` | {@linkcode Vec3Components} | Plane normal of the ring (non-zero, finite components) |
+ * | `majorRadius` | `number` | Ring radius, centre to tube centre (finite, positive) |
+ * | `minorRadius` | `number` | Tube radius (finite, positive, strictly less than `majorRadius`) |
+ */
+export declare const PluginGeomCreateBrepFromTorusArgs: z.ZodObject<{
+    centre: z.ZodObject<{
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+        z: z.ZodNumber;
+    }, z.core.$strip>;
+    axis: z.ZodObject<{
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+        z: z.ZodNumber;
+    }, z.core.$strip>;
+    majorRadius: z.ZodNumber;
+    minorRadius: z.ZodNumber;
+}, z.core.$strip>;
+export type PluginGeomCreateBrepFromTorusArgs = z.infer<typeof PluginGeomCreateBrepFromTorusArgs>;
 //# sourceMappingURL=index.d.ts.map