@snaptrude/plugin-core 0.9.1 → 0.9.2

package/api-manifest.json

@@ -715,6 +715,18 @@
     "argsType": "Vec3Handle",
     "resultType": "ArcHandle"
   },
+  {
+    "path": "core.geom.create.brepFromChamfer",
+    "namespace": "core.geom.create",
+    "summary": "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.",
+    "examplePrompts": [
+      "Bevel these edges by 100mm",
+      "Chamfer the top edges of the plinth",
+      "Cut a 45-degree flat along the corners of this mass\n\n# Example\n```ts\nconst brep = await snaptrude.core.geom.create.brepFromExtrusion(contour, { x: 0, y: 1, z: 0 }, 3)\nconst edges = await snaptrude.core.geom.query.brep.listEdges(brep)\nconst beveled = await snaptrude.core.geom.create.brepFromChamfer(brep, [edges[0]], 0.1)\n```"
+    ],
+    "argsType": "BrepHandle",
+    "resultType": "BrepHandle"
+  },
   {
     "path": "core.geom.create.brepFromExtrusion",
     "namespace": "core.geom.create",
@@ -739,6 +751,18 @@
     "argsType": "Vec3Components[][]",
     "resultType": "BrepHandle"
   },
+  {
+    "path": "core.geom.create.brepFromFillet",
+    "namespace": "core.geom.create",
+    "summary": "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.",
+    "examplePrompts": [
+      "Round the edges of this mass",
+      "Fillet the corners of the podium with a 0.5m radius",
+      "Soften the vertical edges of this tower\n\n# Example\n```ts\nconst brep = await snaptrude.core.geom.create.brepFromExtrusion(contour, { x: 0, y: 1, z: 0 }, 3)\nconst edges = await snaptrude.core.geom.query.brep.listEdges(brep)\nconst rounded = await snaptrude.core.geom.create.brepFromFillet(brep, [edges[0]], 0.3)\n```"
+    ],
+    "argsType": "BrepHandle",
+    "resultType": "BrepHandle"
+  },
   {
     "path": "core.geom.create.brepFromIntersection",
     "namespace": "core.geom.create",
@@ -754,11 +778,12 @@
   {
     "path": "core.geom.create.brepFromLoft",
     "namespace": "core.geom.create",
-    "summary": "Create a closed solid **B-rep** by lofting between a bottom and a top contour. Host API call — returns a {@linkcode BrepHandle}. Both contours must have the same number of edges (and matching hole counts); side faces connect corresponding edges by authored index. Corresponding edges must stay coplanar — a twisted loft would produce non-planar side faces and is rejected. The contours are copied — the input handles are never mutated.",
+    "summary": "Create a closed solid **B-rep** by lofting between a bottom and a top contour, optionally through intermediate cross-sections. Host API call — returns a {@linkcode BrepHandle}. All sections must have the same number of edges; side faces connect corresponding edges by authored index. Corresponding edges must stay coplanar segment to segment (matching hole counts allowed in the two-section form) — a twisted loft would produce non-planar side faces and is rejected. With intermediates the loft is a chain of ruled segments folded into one solid: sections must be planar and hole-free, ordered bottom → intermediates → top. The contours are copied — the input handles are never mutated.",
     "examplePrompts": [
       "Make a tapered tower from these two outlines",
       "Loft between a large base and a smaller top",
-      "Create a frustum from two squares\n\n# Example\n```ts\n// A square frustum: 4m base lofted to a 2m top, 3m up\nconst base = await snaptrude.core.geom.create.profileRect(4, 4)\nconst top = await snaptrude.core.geom.create.profileRect(2, 2, await snaptrude.core.math.vec3.new(0, 3, 0))\nconst brep = await snaptrude.core.geom.create.brepFromLoft(\nawait snaptrude.core.geom.create.contourFromProfile(base),\nawait snaptrude.core.geom.create.contourFromProfile(top),\n)\nconst faceCount = await snaptrude.core.geom.query.brep.getFaceCount(brep) // 6\n```"
+      "Create a frustum from two squares",
+      "Loft the tower through these three floor outlines\n\n# Example\n```ts\n// A square frustum: 4m base lofted to a 2m top, 3m up\nconst base = await snaptrude.core.geom.create.profileRect(4, 4)\nconst top = await snaptrude.core.geom.create.profileRect(2, 2, await snaptrude.core.math.vec3.new(0, 3, 0))\nconst brep = await snaptrude.core.geom.create.brepFromLoft(\nawait snaptrude.core.geom.create.contourFromProfile(base),\nawait snaptrude.core.geom.create.contourFromProfile(top),\n)\nconst faceCount = await snaptrude.core.geom.query.brep.getFaceCount(brep) // 6\n```"
     ],
     "argsType": "ContourHandle",
     "resultType": "BrepHandle"
@@ -775,6 +800,42 @@
     "argsType": "Vec3Components[]",
     "resultType": "BrepHandle"
   },
+  {
+    "path": "core.geom.create.brepFromOffset",
+    "namespace": "core.geom.create",
+    "summary": "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.",
+    "examplePrompts": [
+      "Grow this solid by 0.5m in every direction",
+      "Shrink this mass by 200mm",
+      "Offset the building envelope outward by 1m\n\n# Example\n```ts\nconst brep = await snaptrude.core.geom.create.brepFromExtrusion(contour, { x: 0, y: 1, z: 0 }, 3)\nconst grown = await snaptrude.core.geom.create.brepFromOffset(brep, 0.5)\n```"
+    ],
+    "argsType": "BrepHandle",
+    "resultType": "BrepHandle"
+  },
+  {
+    "path": "core.geom.create.brepFromRevolution",
+    "namespace": "core.geom.create",
+    "summary": "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.",
+    "examplePrompts": [
+      "Create a dome from this section",
+      "Revolve this profile 360 degrees around the vertical axis",
+      "Build a rotunda by revolving this wall section\n\n# Example\n```ts\n// A cylinder: revolve a 2m-wide, 3m-tall rectangle about the Y axis at its edge\nconst rect = await snaptrude.core.geom.create.profileFromLinePoints([\nawait snaptrude.core.math.vec3.new(0, 0, 0),\nawait snaptrude.core.math.vec3.new(2, 0, 0),\nawait snaptrude.core.math.vec3.new(2, 3, 0),\nawait snaptrude.core.math.vec3.new(0, 3, 0),\n])\nconst profile = await snaptrude.core.geom.create.contourFromProfile(rect)\nconst cylinder = await snaptrude.core.geom.create.brepFromRevolution(\nprofile,\n{ x: 0, y: 0, z: 0 },\n{ x: 0, y: 1, z: 0 },\n)\n```"
+    ],
+    "argsType": "ContourHandle",
+    "resultType": "BrepHandle"
+  },
+  {
+    "path": "core.geom.create.brepFromShell",
+    "namespace": "core.geom.create",
+    "summary": "Hollows a solid into constant-thickness walls, removing the given faces as openings. Host API call — returns a new {@linkcode BrepHandle}; the input brep is read-only. The outer surface is kept and the walls grow inward.",
+    "examplePrompts": [
+      "Hollow this mass into 200mm walls",
+      "Shell this form with the top face open",
+      "Turn this solid tower into a tube open at both ends\n\n# Example\n```ts\nconst brep = await snaptrude.core.geom.create.brepFromExtrusion(contour, { x: 0, y: 1, z: 0 }, 3)\nconst faces = await snaptrude.core.geom.query.brep.listFaces(brep)\nconst hollow = await snaptrude.core.geom.create.brepFromShell(brep, [faces[0]], 0.2)\n```"
+    ],
+    "argsType": "BrepHandle",
+    "resultType": "BrepHandle"
+  },
   {
     "path": "core.geom.create.brepFromSubtraction",
     "namespace": "core.geom.create",
@@ -787,6 +848,18 @@
     "argsType": "BrepHandle",
     "resultType": "BrepHandle"
   },
+  {
+    "path": "core.geom.create.brepFromSweep",
+    "namespace": "core.geom.create",
+    "summary": "Sweeps a planar profile along an open polyline path, with mitred corners at each bend. Host API call — returns a new {@linkcode BrepHandle}; the input contour is read-only. The profile must be hole-free and must not lie in a plane containing the first path segment's direction.",
+    "examplePrompts": [
+      "Sweep this profile along the corridor path",
+      "Extrude the railing section along this route",
+      "Run a duct profile through these points\n\n# Example\n```ts\nconst rect = await snaptrude.core.geom.create.profileRect(0.4, 0.4)\nconst profile = await snaptrude.core.geom.create.contourFromProfile(rect)\n// profileRect lies in the XZ plane, so the path must START out of that\n// plane (here: straight up), then it can run horizontally.\nconst duct = await snaptrude.core.geom.create.brepFromSweep(profile, [\n{ x: 0, y: 0, z: 0 },\n{ x: 0, y: 2.8, z: 0 },\n{ x: 10, y: 2.8, z: 0 },\n])\n```"
+    ],
+    "argsType": "ContourHandle",
+    "resultType": "BrepHandle"
+  },
   {
     "path": "core.geom.create.brepFromUnion",
     "namespace": "core.geom.create",
@@ -799,6 +872,18 @@
     "argsType": "BrepHandle",
     "resultType": "BrepHandle"
   },
+  {
+    "path": "core.geom.create.brepsFromSplit",
+    "namespace": "core.geom.create",
+    "summary": "Cuts a solid by an infinite plane and returns one brep per resulting piece — a single piece if the plane misses the solid. Host API call — returns new {@linkcode BrepHandle}s; the input brep is read-only. The plane is defined by a point on it and its normal direction.",
+    "examplePrompts": [
+      "Cut this building at 12m height",
+      "Split the tower from the podium with a horizontal plane",
+      "Slice this mass along a vertical plane\n\n# Example\n```ts\nconst pieces = await snaptrude.core.geom.create.brepsFromSplit(\ntowerBrep,\n{ x: 0, y: 12, z: 0 },\n{ x: 0, y: 1, z: 0 },\n)\nconsole.log(\"pieces:\", pieces.length)\n```"
+    ],
+    "argsType": "BrepHandle",
+    "resultType": "BrepHandle[]"
+  },
   {
     "path": "core.geom.create.circle",
     "namespace": "core.geom.create",
@@ -961,6 +1046,18 @@
     "argsType": "BrepHandle",
     "resultType": "Vec3Components"
   },
+  {
+    "path": "core.geom.query.brep.getDistance",
+    "namespace": "core.geom.query.brep",
+    "summary": "Measures the minimum distance between two solids, with the closest witness point on each. Touching or overlapping solids report a distance of 0 with contact points.",
+    "examplePrompts": [
+      "What is the clearance between these two masses?",
+      "How far apart are the tower and the neighbouring building?",
+      "Find the closest points between these two solids\n\n# Example\n```ts\nconst [a, b] = await snaptrude.design.query.listMasses()\nconst brepA = await snaptrude.design.query.geometry.getBrep(a)\nconst brepB = await snaptrude.design.query.geometry.getBrep(b)\nif (brepA && brepB) {\nconst { distance, pointA, pointB } = await snaptrude.core.geom.query.brep.getDistance(brepA, brepB)\nconsole.log(\"clearance:\", distance)\n}\n```"
+    ],
+    "argsType": "BrepHandle",
+    "resultType": "{ distance: number; pointA: Vec3Components; pointB: Vec3Components }"
+  },
   {
     "path": "core.geom.query.brep.getEdge",
     "namespace": "core.geom.query.brep",
@@ -2753,7 +2850,7 @@
   {
     "path": "core.io.terrain.replaceMesh",
     "namespace": "core.io.terrain",
-    "summary": "Replace the terrain surface with a caller-supplied triangle mesh. Undoable (one step), and the replacement persists with the project.",
+    "summary": "Replace the terrain surface with a caller-supplied triangle mesh. Undoable (one step), and the replacement persists with the project. The returned promise resolves only after the surface is fully applied and recorded — it is safe to toggle terrain resolution or read the surface back the moment it resolves.",
     "examplePrompts": [
       "Replace the terrain with this surveyed mesh",
       "Flatten a building pad into the site surface",

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

@@ -1,6 +1,6 @@
 import * as z from "zod";
 import { PluginApiReturn } from "../../../../types";
-import { Vec3Handle, LineHandle, ArcHandle, CircleHandle, CurveHandle, ProfileHandle, ContourHandle, BrepHandle, Vec3Components } from "../../../../handles";
+import { Vec3Handle, LineHandle, ArcHandle, CircleHandle, CurveHandle, ProfileHandle, ContourHandle, BrepHandle, FaceHandle, EdgeHandle, Vec3Components } from "../../../../handles";
 /**
  * Curve creation — construct new geometric curves from point handles (all-handle
  * model, §11).
@@ -231,25 +231,36 @@ export declare abstract class PluginGeomCreateApi {
     abstract brepFromExtrusion(contour: ContourHandle, direction: Vec3Components, amount: number): PluginApiReturn<BrepHandle>;
     /**
      * Create a closed solid **B-rep** by lofting between a bottom and a top
-     * contour. Host API call — returns a {@linkcode BrepHandle}. Both contours
-     * must have the same number of edges (and matching hole counts); side faces
-     * connect corresponding edges by authored index. Corresponding edges must
-     * stay coplanar — a twisted loft would produce non-planar side faces and is
-     * rejected. The contours are copied — the input handles are never mutated.
+     * contour, optionally through intermediate cross-sections. Host API call —
+     * returns a {@linkcode BrepHandle}. All sections must have the same number
+     * of edges; side faces connect corresponding edges by authored index.
+     * Corresponding edges must stay coplanar segment to segment (matching hole
+     * counts allowed in the two-section form) — a twisted loft would produce
+     * non-planar side faces and is rejected. With intermediates the loft is a
+     * chain of ruled segments folded into one solid: sections must be planar
+     * and hole-free, ordered bottom → intermediates → top. The contours are
+     * copied — the input handles are never mutated.
      *
      * Inspect the result via `core.geom.query.brep.*`, or commit it to the scene
      * with `design.create.massFromBrep`.
      *
      * @param bottomContour The bottom cross-section
-     * @param topContour The top cross-section (same edge and hole counts as the bottom)
+     * @param topContour The top cross-section (same edge count as the bottom)
+     * @param intermediateContours Optional in-between cross-sections, ordered
+     *   bottom to top (hole-free, same edge count as the bottom and top)
      * @returns The new solid as a {@linkcode BrepHandle}
-     * @throws if the contours are coincident, their edge or hole counts differ,
-     *   a side face between corresponding edges would be non-planar, or the
-     *   contours cannot be lofted into a valid solid
+     * @throws VALIDATION if the contours are coincident, their edge or hole
+     *   counts differ, any section has holes when intermediates are present
+     *   (multi-section lofts take hole-free sections), a section is non-planar,
+     *   or a side face between corresponding edges would be non-planar (a
+     *   twisted section pair — the error names the offending sections)
+     * @throws OPERATION_FAILED if the lofted segments cannot be joined into a
+     *   valid solid
      *
      * @examplePrompt Make a tapered tower from these two outlines
      * @examplePrompt Loft between a large base and a smaller top
      * @examplePrompt Create a frustum from two squares
+     * @examplePrompt Loft the tower through these three floor outlines
      *
      * # Example
      * ```ts
@@ -263,7 +274,7 @@ export declare abstract class PluginGeomCreateApi {
      * const faceCount = await snaptrude.core.geom.query.brep.getFaceCount(brep) // 6
      * ```
      */
-    abstract brepFromLoft(bottomContour: ContourHandle, topContour: ContourHandle): PluginApiReturn<BrepHandle>;
+    abstract brepFromLoft(bottomContour: ContourHandle, topContour: ContourHandle, intermediateContours?: ContourHandle[]): PluginApiReturn<BrepHandle>;
     /**
      * Create a closed solid **B-rep** from indexed mesh data: a vertex position
      * array plus face loops of indices into it. Host API call — returns a
@@ -389,6 +400,265 @@ 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).
+     *
+     * 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)
+     * @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
+     * @examplePrompt Fillet the corners of the podium with a 0.5m radius
+     * @examplePrompt Soften the vertical edges of this tower
+     *
+     * # 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)
+     * ```
+     */
+    abstract brepFromFillet(brep: BrepHandle, edges: EdgeHandle[], 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.
+     *
+     * 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 to offset
+     * @param distance Offset distance (finite, non-zero; positive grows, negative shrinks)
+     * @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
+     *
+     * @examplePrompt Grow this solid by 0.5m in every direction
+     * @examplePrompt Shrink this mass by 200mm
+     * @examplePrompt Offset the building envelope outward by 1m
+     *
+     * # Example
+     * ```ts
+     * const brep = await snaptrude.core.geom.create.brepFromExtrusion(contour, { x: 0, y: 1, z: 0 }, 3)
+     * const grown = await snaptrude.core.geom.create.brepFromOffset(brep, 0.5)
+     * ```
+     */
+    abstract brepFromOffset(brep: BrepHandle, distance: number): PluginApiReturn<BrepHandle>;
+    /**
+     * Hollows a solid into constant-thickness walls, removing the given faces
+     * as openings. Host API call — returns a new {@linkcode BrepHandle}; the
+     * input brep is read-only. The outer surface is kept and the walls grow
+     * inward.
+     *
+     * 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 to hollow
+     * @param openFaces The faces to remove as openings (≥1, all on `brep`)
+     * @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
+     *
+     * @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)
+     * ```
+     */
+    abstract brepFromShell(brep: BrepHandle, openFaces: FaceHandle[], thickness: number): PluginApiReturn<BrepHandle>;
+    /**
+     * Cuts a solid by an infinite plane and returns one brep per resulting
+     * piece — a single piece if the plane misses the solid. Host API call —
+     * returns new {@linkcode BrepHandle}s; the input brep is read-only. The
+     * plane is defined by a point on it and its normal direction.
+     *
+     * Runs on the OpenCascade kernel (the first kernel call loads a wasm of
+     * tens of MB — expect a pause of seconds).
+     *
+     * Inspect each result via `core.geom.query.brep.*`, or commit them to the
+     * scene with `design.create.massFromBrep`.
+     *
+     * @param brep The solid to split
+     * @param planeOrigin A point on the cutting plane as plain `{x, y, z}` components
+     * @param planeNormal The plane normal as plain `{x, y, z}` components (non-zero)
+     * @returns The resulting pieces as {@linkcode BrepHandle}`[]` (one per solid)
+     * @throws VALIDATION if `planeNormal` is zero-length or the origin/normal
+     *   components are not finite
+     * @throws OPERATION_FAILED if the kernel cannot split the solid
+     *
+     * @examplePrompt Cut this building at 12m height
+     * @examplePrompt Split the tower from the podium with a horizontal plane
+     * @examplePrompt Slice this mass along a vertical plane
+     *
+     * # Example
+     * ```ts
+     * const pieces = await snaptrude.core.geom.create.brepsFromSplit(
+     *   towerBrep,
+     *   { x: 0, y: 12, z: 0 },
+     *   { x: 0, y: 1, z: 0 },
+     * )
+     * console.log("pieces:", pieces.length)
+     * ```
+     */
+    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.
+     *
+     * 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).
+     *
+     * 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 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)
+     *
+     * @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
+     *
+     * # 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 beveled = await snaptrude.core.geom.create.brepFromChamfer(brep, [edges[0]], 0.1)
+     * ```
+     */
+    abstract brepFromChamfer(brep: BrepHandle, edges: EdgeHandle[], distance: number): PluginApiReturn<BrepHandle>;
+    /**
+     * Sweeps a planar profile along an open polyline path, with mitred corners
+     * at each bend. Host API call — returns a new {@linkcode BrepHandle}; the
+     * input contour is read-only. The profile must be hole-free and must not
+     * lie in a plane containing the first path segment's direction.
+     *
+     * 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 profile The cross-section to sweep (hole-free contour)
+     * @param path The polyline path as plain `{x, y, z}` points (≥2, open — first ≠ last)
+     * @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, the path is closed (open
+     *   paths only in v1), a coordinate is not finite, or the profile plane
+     *   contains the first path segment's direction (degenerate sweep)
+     * @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
+     *
+     * @examplePrompt Sweep this profile along the corridor path
+     * @examplePrompt Extrude the railing section along this route
+     * @examplePrompt Run a duct profile through these points
+     *
+     * # Example
+     * ```ts
+     * const rect = await snaptrude.core.geom.create.profileRect(0.4, 0.4)
+     * const profile = await snaptrude.core.geom.create.contourFromProfile(rect)
+     * // profileRect lies in the XZ plane, so the path must START out of that
+     * // plane (here: straight up), then it can run horizontally.
+     * const duct = await snaptrude.core.geom.create.brepFromSweep(profile, [
+     *   { x: 0, y: 0, z: 0 },
+     *   { x: 0, y: 2.8, z: 0 },
+     *   { x: 10, y: 2.8, z: 0 },
+     * ])
+     * ```
+     */
+    abstract brepFromSweep(profile: ContourHandle, path: Vec3Components[]): 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.
+     *
+     * 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 profile The cross-section to revolve (planar contour, holes allowed)
+     * @param axisOrigin A point on the revolution axis as plain `{x, y, z}` components
+     * @param axisDirection The axis direction as plain `{x, y, z}` components (non-zero)
+     * @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)
+     *
+     * @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
+     *
+     * # Example
+     * ```ts
+     * // A cylinder: revolve a 2m-wide, 3m-tall rectangle about the Y axis at its edge
+     * 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),
+     *   await snaptrude.core.math.vec3.new(2, 3, 0),
+     *   await snaptrude.core.math.vec3.new(0, 3, 0),
+     * ])
+     * const profile = await snaptrude.core.geom.create.contourFromProfile(rect)
+     * const cylinder = await snaptrude.core.geom.create.brepFromRevolution(
+     *   profile,
+     *   { x: 0, y: 0, z: 0 },
+     *   { x: 0, y: 1, z: 0 },
+     * )
+     * ```
+     */
+    abstract brepFromRevolution(profile: ContourHandle, axisOrigin: Vec3Components, axisDirection: Vec3Components, angleInDegrees?: number): PluginApiReturn<BrepHandle>;
 }
 /**
  * Arguments for {@linkcode PluginGeomCreateApi.line}.
@@ -522,10 +792,12 @@ 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 |
  */
 export declare const PluginGeomCreateBrepFromLoftArgs: z.ZodObject<{
     bottomContour: z.ZodPipe<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>, z.ZodTransform<import("../../../..").Handle<"contour">, string>>;
     topContour: z.ZodPipe<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>, z.ZodTransform<import("../../../..").Handle<"contour">, string>>;
+    intermediateContours: z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>, z.ZodTransform<import("../../../..").Handle<"contour">, string>>>>;
 }, z.core.$strip>;
 export type PluginGeomCreateBrepFromLoftArgs = z.infer<typeof PluginGeomCreateBrepFromLoftArgs>;
 /**
@@ -561,4 +833,127 @@ export declare const PluginGeomCreateBrepBooleanArgs: z.ZodObject<{
     b: z.ZodPipe<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>, z.ZodTransform<import("../../../..").Handle<"brep">, string>>;
 }, z.core.$strip>;
 export type PluginGeomCreateBrepBooleanArgs = z.infer<typeof PluginGeomCreateBrepBooleanArgs>;
+/**
+ * Arguments for {@linkcode PluginGeomCreateApi.brepFromFillet}.
+ *
+ * | 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) |
+ */
+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;
+}, z.core.$strip>;
+export type PluginGeomCreateBrepFromFilletArgs = z.infer<typeof PluginGeomCreateBrepFromFilletArgs>;
+/**
+ * Arguments for {@linkcode PluginGeomCreateApi.brepFromOffset}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `brep` | {@linkcode BrepHandle} | The solid to offset |
+ * | `distance` | `number` | Offset distance (finite, non-zero; positive grows, negative shrinks) |
+ */
+export declare const PluginGeomCreateBrepFromOffsetArgs: z.ZodObject<{
+    brep: z.ZodPipe<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>, z.ZodTransform<import("../../../..").Handle<"brep">, string>>;
+    distance: z.ZodNumber;
+}, z.core.$strip>;
+export type PluginGeomCreateBrepFromOffsetArgs = z.infer<typeof PluginGeomCreateBrepFromOffsetArgs>;
+/**
+ * Arguments for {@linkcode PluginGeomCreateApi.brepFromShell}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `brep` | {@linkcode BrepHandle} | The solid to hollow |
+ * | `openFaces` | {@linkcode FaceHandle}`[]` | The faces to remove as openings (≥1) |
+ * | `thickness` | `number` | Wall thickness (positive, finite) |
+ */
+export declare const PluginGeomCreateBrepFromShellArgs: z.ZodObject<{
+    brep: z.ZodPipe<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>, z.ZodTransform<import("../../../..").Handle<"brep">, string>>;
+    openFaces: z.ZodArray<z.ZodPipe<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>, z.ZodTransform<import("../../../..").Handle<"face">, string>>>;
+    thickness: z.ZodNumber;
+}, z.core.$strip>;
+export type PluginGeomCreateBrepFromShellArgs = z.infer<typeof PluginGeomCreateBrepFromShellArgs>;
+/**
+ * Arguments for {@linkcode PluginGeomCreateApi.brepsFromSplit}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `brep` | {@linkcode BrepHandle} | The solid to split |
+ * | `planeOrigin` | {@linkcode Vec3Components} | A point on the cutting plane (finite components) |
+ * | `planeNormal` | {@linkcode Vec3Components} | The plane normal (non-zero, finite components) |
+ */
+export declare const PluginGeomCreateBrepsFromSplitArgs: z.ZodObject<{
+    brep: z.ZodPipe<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>, z.ZodTransform<import("../../../..").Handle<"brep">, string>>;
+    planeOrigin: z.ZodObject<{
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+        z: z.ZodNumber;
+    }, z.core.$strip>;
+    planeNormal: z.ZodObject<{
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+        z: z.ZodNumber;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type PluginGeomCreateBrepsFromSplitArgs = z.infer<typeof PluginGeomCreateBrepsFromSplitArgs>;
+/**
+ * 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) |
+ * | `distance` | `number` | Chamfer distance from the edge on each adjacent face (positive, finite) |
+ */
+export declare const PluginGeomCreateBrepFromChamferArgs: 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>>>;
+    distance: z.ZodNumber;
+}, z.core.$strip>;
+export type PluginGeomCreateBrepFromChamferArgs = z.infer<typeof PluginGeomCreateBrepFromChamferArgs>;
+/**
+ * Arguments for {@linkcode PluginGeomCreateApi.brepFromSweep}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `profile` | {@linkcode ContourHandle} | The cross-section to sweep (hole-free) |
+ * | `path` | {@linkcode Vec3Components}`[]` | The open polyline path (≥2 points, finite components) |
+ */
+export declare const PluginGeomCreateBrepFromSweepArgs: z.ZodObject<{
+    profile: z.ZodPipe<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>, z.ZodTransform<import("../../../..").Handle<"contour">, string>>;
+    path: z.ZodArray<z.ZodObject<{
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+        z: z.ZodNumber;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type PluginGeomCreateBrepFromSweepArgs = z.infer<typeof PluginGeomCreateBrepFromSweepArgs>;
+/**
+ * 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) |
+ * | `angleInDegrees` | `number`? | Revolution angle in degrees (0 < angle ≤ 360; default 360) |
+ */
+export declare const PluginGeomCreateBrepFromRevolutionArgs: z.ZodObject<{
+    profile: z.ZodPipe<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>, z.ZodTransform<import("../../../..").Handle<"contour">, string>>;
+    axisOrigin: z.ZodObject<{
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+        z: z.ZodNumber;
+    }, z.core.$strip>;
+    axisDirection: z.ZodObject<{
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+        z: z.ZodNumber;
+    }, z.core.$strip>;
+    angleInDegrees: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type PluginGeomCreateBrepFromRevolutionArgs = z.infer<typeof PluginGeomCreateBrepFromRevolutionArgs>;
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/api/core/geom/create/index.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/api/core/geom/create/index.ts"],"names":[],"mappings":"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"}