@snaptrude/plugin-core 0.0.0-dev-20260827135706 → 0.0.0-dev-20260907135026

package/api-manifest.json

@@ -729,8 +729,9 @@
   {
     "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.",
+    "summary": "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.",
     "examplePrompts": [
+      "Chamfer the top edge of the cylinder",
       "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```"
@@ -738,6 +739,28 @@
     "argsType": "BrepHandle",
     "resultType": "BrepHandle"
   },
+  {
+    "path": "core.geom.create.brepFromCone",
+    "namespace": "core.geom.create",
+    "summary": "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`.",
+    "examplePrompts": [
+      "Create a cone roof 4m wide and 3m tall",
+      "Make a tapered column narrowing from 1m to 0.6m\n\n# Example\n```ts\nconst roof = await snaptrude.core.geom.create.brepFromCone(\n{ x: 0, y: 9, z: 0 },\n{ x: 0, y: 1, z: 0 },\n2,\n3,\n)\n```"
+    ],
+    "argsType": "Vec3Components",
+    "resultType": "BrepHandle"
+  },
+  {
+    "path": "core.geom.create.brepFromCylinder",
+    "namespace": "core.geom.create",
+    "summary": "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`.",
+    "examplePrompts": [
+      "Create a cylinder 2m across and 4m tall",
+      "Add a circular column here\n\n# Example\n```ts\nconst brep = await snaptrude.core.geom.create.brepFromCylinder(\n{ x: 0, y: 0, z: 0 },\n{ x: 0, y: 1, z: 0 },\n1,\n4,\n)\nconst column = await snaptrude.design.create.massFromBrep(brep, \"Column\")\n```"
+    ],
+    "argsType": "Vec3Components",
+    "resultType": "BrepHandle"
+  },
   {
     "path": "core.geom.create.brepFromExtrusion",
     "namespace": "core.geom.create",
@@ -765,11 +788,12 @@
   {
     "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.",
+    "summary": "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.",
     "examplePrompts": [
-      "Round the edges of this mass",
+      "Round the rim of the column with 200 mm",
+      "Soften where the dome meets the wall",
       "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```"
+      "Soften the vertical edges of this tower\n\n# Example\n```ts\n// Rim = every edge between the cylinder side and a plane cap\nconst edges = await snaptrude.core.geom.query.brep.listEdges(column)\nconst rim = []\nfor (const edge of edges) {\nconst faces = await snaptrude.core.geom.query.edge.listFaces(edge)\nconst kinds = await Promise.all(\nfaces.map((f) => snaptrude.core.geom.query.face.getSurfaceKind(f)),\n)\nif (kinds.includes(\"cylinder\") && kinds.includes(\"plane\")) rim.push(edge)\n}\nconst rounded = await snaptrude.core.geom.create.brepFromFillet(column, rim, 0.787) // 200 mm\n```"
     ],
     "argsType": "BrepHandle",
     "resultType": "BrepHandle"
@@ -820,6 +844,7 @@
     "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": [
+      "Thicken the torus ring by 100 mm",
       "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```"
@@ -830,11 +855,13 @@
   {
     "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.",
+    "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, 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.",
     "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```"
+      "Build a rotunda by revolving this wall section",
+      "Make a dome by revolving a quarter-circle about the vertical axis",
+      "Turn this curved outline into a vase\n\n# Example\n```ts\n// A cylinder: revolve a 2m-wide, 3m-tall rectangle about the Y axis at\n// its edge — the left edge sits ON the axis, which is legal.\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"
@@ -844,13 +871,25 @@
     "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 the dome into a 300 mm shell, open at the base",
       "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```"
+      "Turn this solid tower into a tube open at both ends\n\n# Example\n```ts\n// Open the dome at its flat base: the one face whose surface is a plane\nconst faces = await snaptrude.core.geom.query.brep.listFaces(dome)\nconst base = []\nfor (const face of faces) {\nif ((await snaptrude.core.geom.query.face.getSurfaceKind(face)) === \"plane\") base.push(face)\n}\nconst hollow = await snaptrude.core.geom.create.brepFromShell(dome, base, 1.181) // 300 mm\n```"
     ],
     "argsType": "BrepHandle",
     "resultType": "BrepHandle"
   },
+  {
+    "path": "core.geom.create.brepFromSphere",
+    "namespace": "core.geom.create",
+    "summary": "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`.",
+    "examplePrompts": [
+      "Create a sphere of radius 5 at the origin",
+      "Add a 3m ball on top of the tower\n\n# Example\n```ts\nconst brep = await snaptrude.core.geom.create.brepFromSphere({ x: 0, y: 5, z: 0 }, 5)\nconst mass = await snaptrude.design.create.massFromBrep(brep, \"Sphere\")\n```"
+    ],
+    "argsType": "Vec3Components",
+    "resultType": "BrepHandle"
+  },
   {
     "path": "core.geom.create.brepFromSubtraction",
     "namespace": "core.geom.create",
@@ -866,7 +905,7 @@
   {
     "path": "core.geom.create.brepFromSweep",
     "namespace": "core.geom.create",
-    "summary": "Sweeps a planar profile along a 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. Repeating the first point as the last closes the path into a ring solid (a picture frame): closed paths must be flat and straight-segmented and take a straight-edged (arc-free) profile — the ring's cross-section is the authored profile projected along the first leg onto the first mitre plane, so a profile not perpendicular to the first leg appears sheared. An optional scale law tapers the sweep: `startScale`/`endScale` interpolate linearly by arc length, or `scales` gives one factor per path point (scaling is about the profile centroid). A uniform scale (all factors equal) works on any path today's sweep accepts; a varying scale takes straight (collinear) open paths with straight-edged profiles — 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; `{ 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.",
+    "summary": "Sweeps a planar profile along a 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. Repeating the first point as the last closes the path into a ring solid (a picture frame): closed paths must be flat and straight-segmented and take a straight-edged (arc-free) profile — the ring's cross-section is the authored profile projected along the first leg onto the first mitre plane, so a profile not perpendicular to the first leg appears sheared. An optional scale law tapers the sweep: `startScale`/`endScale` interpolate linearly by arc length, or `scales` gives one factor per path point (scaling is about the profile centroid). A uniform scale (all factors equal) works on any path today's sweep accepts; a varying scale takes straight (collinear) open paths with straight-edged profiles — 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; `\"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.",
     "examplePrompts": [
       "Sweep this profile along the corridor path",
       "Extrude the railing section along this route",
@@ -874,11 +913,23 @@
       "Sweep a frame profile around a closed rectangular loop",
       "Taper this duct from 1x1 to 2x2 along its run",
       "Sweep a column section that narrows toward the top",
-      "Chamfer the corners of this swept frame by 200mm\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// A closed ring (picture frame): repeat the first point as the last\nconst frame = await snaptrude.core.geom.create.brepFromSweep(profile, [\n{ x: 0, y: 0, z: 0 },\n{ x: 0, y: 3, z: 0 },\n{ x: 4, y: 3, z: 0 },\n{ x: 4, y: 0, z: 0 },\n{ x: 0, y: 0, z: 0 },\n])\n// A tapered straight run: 0.4x0.4 at the start, 0.8x0.8 at the end\nconst flue = await snaptrude.core.geom.create.brepFromSweep(\nprofile,\n[\n{ x: 0, y: 0, z: 0 },\n{ x: 0, y: 10, z: 0 },\n],\n{ startScale: 1, endScale: 2 },\n)\n```"
+      "Chamfer the corners of this swept frame by 200mm",
+      "Sweep this handrail with rounded corners at the bends\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// A closed ring (picture frame): repeat the first point as the last\nconst frame = await snaptrude.core.geom.create.brepFromSweep(profile, [\n{ x: 0, y: 0, z: 0 },\n{ x: 0, y: 3, z: 0 },\n{ x: 4, y: 3, z: 0 },\n{ x: 4, y: 0, z: 0 },\n{ x: 0, y: 0, z: 0 },\n])\n// A tapered straight run: 0.4x0.4 at the start, 0.8x0.8 at the end\nconst flue = await snaptrude.core.geom.create.brepFromSweep(\nprofile,\n[\n{ x: 0, y: 0, z: 0 },\n{ x: 0, y: 10, z: 0 },\n],\n{ startScale: 1, endScale: 2 },\n)\n```"
     ],
     "argsType": "ContourHandle",
     "resultType": "BrepHandle"
   },
+  {
+    "path": "core.geom.create.brepFromTorus",
+    "namespace": "core.geom.create",
+    "summary": "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`.",
+    "examplePrompts": [
+      "Create a donut-shaped ring 10m across with a 1m tube",
+      "Add a torus canopy around the tower\n\n# Example\n```ts\nconst ring = await snaptrude.core.geom.create.brepFromTorus(\n{ x: 0, y: 6, z: 0 },\n{ x: 0, y: 1, z: 0 },\n5,\n1,\n)\n```"
+    ],
+    "argsType": "Vec3Components",
+    "resultType": "BrepHandle"
+  },
   {
     "path": "core.geom.create.brepFromUnion",
     "namespace": "core.geom.create",
@@ -965,6 +1016,18 @@
     "argsType": "Vec3Handle[]",
     "resultType": "ProfileHandle"
   },
+  {
+    "path": "core.geom.create.profileFromSplinePoints",
+    "namespace": "core.geom.create",
+    "summary": "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.",
+    "examplePrompts": [
+      "Make a blob-shaped floor plate through these points",
+      "Organic curved outline through these corners",
+      "Freeform podium profile\n\n# Example\n```ts\nconst profile = await snaptrude.core.geom.create.profileFromSplinePoints([p0, p1, p2, p3, p4])\nconst contour = await snaptrude.core.geom.create.contourFromProfile(profile)\nconst brep = await snaptrude.core.geom.create.brepFromExtrusion(contour, { x: 0, y: 1, z: 0 }, 3)\nconst podium = await snaptrude.design.create.massFromBrep(brep, \"Podium\")\n```"
+    ],
+    "argsType": "Vec3Handle[]",
+    "resultType": "ProfileHandle"
+  },
   {
     "path": "core.geom.create.profileRect",
     "namespace": "core.geom.create",
@@ -976,6 +1039,29 @@
     "argsType": "number",
     "resultType": "ProfileHandle"
   },
+  {
+    "path": "core.geom.create.splineFromControlPoints",
+    "namespace": "core.geom.create",
+    "summary": "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}.",
+    "examplePrompts": [
+      "Draw a smooth curve controlled by these four points",
+      "Rebuild this edge from its control polygon\n\n# Example\n```ts\nconst curve = await snaptrude.core.geom.create.splineFromControlPoints([p0, p1, p2, p3])\n// Quadratic instead of the default cubic\nconst tighter = await snaptrude.core.geom.create.splineFromControlPoints(\n[p0, p1, p2, p3],\n{ degree: 2 },\n)\n```"
+    ],
+    "argsType": "Vec3Handle[]",
+    "resultType": "SplineHandle"
+  },
+  {
+    "path": "core.geom.create.splineFromPoints",
+    "namespace": "core.geom.create",
+    "summary": "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.",
+    "examplePrompts": [
+      "Draw a smooth curve through these points",
+      "Make a wavy edge that passes through A, B, C and D",
+      "Freeform curved wall path through these clicks\n\n# Example\n```ts\nconst spline = await snaptrude.core.geom.create.splineFromPoints([p0, p1, p2, p3])\n// Mixed profile: smooth top, straight closing base\nconst base = await snaptrude.core.geom.create.line(p3, p0)\nconst profile = await snaptrude.core.geom.create.profileFromCurves([spline, base])\n```"
+    ],
+    "argsType": "Vec3Handle[]",
+    "resultType": "SplineHandle"
+  },
   {
     "path": "core.geom.delete.contour",
     "namespace": "core.geom.delete",
@@ -1101,10 +1187,11 @@
       "Read the radius of this curved edge",
       "Is this edge straight or an arc?",
       "Get the exact start and end points of this edge",
-      "Measure the length of each edge of this mass\n\n# Example\n```ts\nconst [mass] = await snaptrude.design.query.listMasses()\nconst brep = await snaptrude.design.query.geometry.getBrep(mass)\nif (brep) {\nconst edges = await snaptrude.core.geom.query.brep.listEdges(brep)\nfor (const edge of edges) {\nconst curve = await snaptrude.core.geom.query.brep.getEdgeCurve(brep, edge)\nif (curve.type === \"arc\") console.log(\"arc radius:\", curve.radius)\n}\n}\n```"
+      "Measure the length of each edge of this mass",
+      "Read the control points of this curved edge\n\n# Example\n```ts\nconst [mass] = await snaptrude.design.query.listMasses()\nconst brep = await snaptrude.design.query.geometry.getBrep(mass)\nif (brep) {\nconst edges = await snaptrude.core.geom.query.brep.listEdges(brep)\nfor (const edge of edges) {\nconst curve = await snaptrude.core.geom.query.brep.getEdgeCurve(brep, edge)\nif (curve.type === \"arc\") console.log(\"arc radius:\", curve.radius)\n}\n}\n```"
     ],
     "argsType": "BrepHandle",
-    "resultType": "| { type: \"line\"; startPoint: Vec3Components; endPoint: Vec3Components; length: number }\n    | {\n        type: \"arc\"\n        startPoint: Vec3Components\n        endPoint: Vec3Components\n        centre: Vec3Components\n        axis: Vec3Components\n        radius: number\n        length: number\n      }\n    | {\n        type: \"circle\"\n        centre: Vec3Components\n        axis: Vec3Components\n        radius: number\n        length: number\n      }"
+    "resultType": "| { type: \"line\"; startPoint: Vec3Components; endPoint: Vec3Components; length: number }\n    | {\n        type: \"arc\"\n        startPoint: Vec3Components\n        endPoint: Vec3Components\n        centre: Vec3Components\n        axis: Vec3Components\n        radius: number\n        length: number\n      }\n    | {\n        type: \"circle\"\n        centre: Vec3Components\n        axis: Vec3Components\n        radius: number\n        length: number\n      }\n    | {\n        type: \"spline\"\n        startPoint: Vec3Components\n        endPoint: Vec3Components\n        degree: number\n        controlPoints: Vec3Components[]\n        /** Expanded by multiplicity: `controlPoints.length + degree + 1` entries. */\n        knots: number[]\n        length: number\n      }"
   },
   {
     "path": "core.geom.query.brep.getFaceCount",
@@ -1138,6 +1225,18 @@
     "argsType": "BrepHandle",
     "resultType": "Vec3Components"
   },
+  {
+    "path": "core.geom.query.brep.getVolume",
+    "namespace": "core.geom.query.brep",
+    "summary": "Get the enclosed **volume** of a closed solid, integrated from its exact surfaces. Curved faces are measured analytically, not from their tessellation — a real sphere of radius 5 reports 523.6, whatever its triangle count. That makes this the reliable way to confirm a solid is the shape you intended (a torus should measure 2·π²·R·r²).",
+    "examplePrompts": [
+      "What is the volume of this mass?",
+      "How much concrete is in this shape?",
+      "Check the volume of the dome I just made\n\n# Example\n```ts\nconst [mass] = await snaptrude.design.query.listMasses()\nconst brep = await snaptrude.design.query.geometry.getBrep(mass)\nif (brep) {\nconst volume = await snaptrude.core.geom.query.brep.getVolume(brep)\nconsole.log(\"volume:\", volume)\n}\n```"
+    ],
+    "argsType": "BrepHandle",
+    "resultType": "number"
+  },
   {
     "path": "core.geom.query.brep.hasEdge",
     "namespace": "core.geom.query.brep",
@@ -1742,7 +1841,7 @@
   {
     "path": "core.geom.query.edge.getCurve",
     "namespace": "core.geom.query.edge",
-    "summary": "Get the underlying curve geometry of an edge (a line or arc).",
+    "summary": "Get the underlying curve geometry of an edge (a line, arc or spline).",
     "examplePrompts": [],
     "argsType": "EdgeHandle",
     "resultType": "CurveHandle | null"
@@ -1819,6 +1918,19 @@
     "argsType": "FaceHandle",
     "resultType": "number"
   },
+  {
+    "path": "core.geom.query.face.getSurfaceKind",
+    "namespace": "core.geom.query.face",
+    "summary": "Read what KIND of surface a face lies on. This is the one read that tells a genuinely curved face from a faceted approximation of one: every face of a 200-triangle \"dome\" answers `\"plane\"`, while a real dome has faces answering `\"sphere\"`. Use it to confirm a curved solid actually came out curved.",
+    "examplePrompts": [
+      "Is this face flat or curved?",
+      "Check that this dome is a real sphere, not a faceted approximation",
+      "What kind of surface is this face?",
+      "How many curved faces does this mass have?\n\n# Example\n```ts\nconst [mass] = await snaptrude.design.query.listMasses()\nconst brep = await snaptrude.design.query.geometry.getBrep(mass)\nif (brep) {\nconst faces = await snaptrude.core.geom.query.brep.listFaces(brep)\nconst kinds = []\nfor (const face of faces) kinds.push(await snaptrude.core.geom.query.face.getSurfaceKind(face))\nconsole.log(\"spherical faces:\", kinds.filter((k) => k === \"sphere\").length)\n}\n```"
+    ],
+    "argsType": "FaceHandle",
+    "resultType": "\"plane\" | \"cylinder\" | \"cone\" | \"sphere\" | \"torus\" | \"spline\" | null"
+  },
   {
     "path": "core.geom.query.face.hasHoles",
     "namespace": "core.geom.query.face",
@@ -4769,6 +4881,17 @@
     "argsType": null,
     "resultType": "PluginFamilyBundle | null"
   },
+  {
+    "path": "design.family.getParameters",
+    "namespace": "design.family",
+    "summary": "Read a placed component's current parameter values and its sheet.",
+    "examplePrompts": [
+      "What size is that table?",
+      "Show me the parameters on this partition\n\n# Example\n```ts\nconst { values, parameters } = await snaptrude.design.family.getParameters({ component })\n```"
+    ],
+    "argsType": "PluginDesignFamilyGetParametersArgs",
+    "resultType": "PluginFamilyInstanceParameters | null"
+  },
   {
     "path": "design.family.getReference",
     "namespace": "design.family",
@@ -4793,12 +4916,13 @@
   {
     "path": "design.family.place",
     "namespace": "design.family",
-    "summary": "Arm placement with the prepared family.",
+    "summary": "Put a family into the model — either the prepared draft or any family from {@linkcode PluginDesignFamilyApi.list}.",
     "examplePrompts": [
       "Place it in the model",
-      "Let me put this on the facade\n\n# Example\n```ts\nawait snaptrude.design.family.place()\n```"
+      "Put a louvre screen at the origin",
+      "Copy that table two metres to the right\n\n# Example\n```ts\n// positioned — geometry exists when this resolves\nconst { component } = await snaptrude.design.family.place({\nid: \"revit:gypsum-stud-partition~90ad72\",\nposition: { x: 0, y: 0, z: 0 },\nrotation: 90,\n})\nawait snaptrude.design.transform.move([component], { x: 2, y: 0, z: 0 })\n\n// interactive — the user clicks\nawait snaptrude.design.family.place()\n```"
     ],
-    "argsType": null,
+    "argsType": "PluginDesignFamilyPlaceArgs",
     "resultType": "PluginFamilyPlaceResult"
   },
   {
@@ -4813,6 +4937,17 @@
     "argsType": "PluginDesignFamilyPrepareArgs",
     "resultType": "PluginFamilyPrepareResult"
   },
+  {
+    "path": "design.family.setParameters",
+    "namespace": "design.family",
+    "summary": "Change a placed component's parameters and rebuild its geometry in place.",
+    "examplePrompts": [
+      "Make that table seat 8",
+      "Change the stud spacing to 400\n\n# Example\n```ts\nawait snaptrude.design.family.setParameters({ component, values: { seats: 8 } })\n```"
+    ],
+    "argsType": "PluginDesignFamilySetParametersArgs",
+    "resultType": "PluginFamilyInstanceParameters"
+  },
   {
     "path": "design.furniture.exists",
     "namespace": "design.furniture",
@@ -5207,6 +5342,7 @@
     "summary": "Get the boundary representation (B-rep) of a scene component — the solid geometry (faces, edges, vertices) behind a wall, slab, room or any other scene entity, as a reusable {@linkcode BrepHandle} for the `core.geom.query.brep.*` reads.",
     "examplePrompts": [
       "Get the 3D solid geometry of the selected wall",
+      "Round the top rim of this column and put it back where it is",
       "How many faces does this mass have?",
       "Inspect the mesh of this slab so I can look at its faces and edges",
       "Read the vertices of the selected column's geometry"
@@ -5318,6 +5454,19 @@
     "argsType": "ComponentHandle",
     "resultType": "string"
   },
+  {
+    "path": "design.query.getParameters",
+    "namespace": "design.query",
+    "summary": "Read a mass's creation-parameter record — the recipe it was built from (`kind` plus the values that constructor was called with). Present on masses committed from a `core.geom.create` brep constructor that carries a recipe: {@linkcode MassParametersRecord} covers the four primitives (sphere, cylinder, cone, torus), extrusions, revolutions, lofts and sweeps.",
+    "examplePrompts": [
+      "What radius is this sphere?",
+      "Is this mass parametric?",
+      "Read back the dome's creation parameters",
+      "How tall was this cylinder made?\n\n# Example\n```ts\nconst [mass] = await snaptrude.design.query.listMasses({ isSelected: true })\nconst params = await snaptrude.design.query.getParameters(mass)\nif (params?.kind === \"sphere\") console.log(\"radius:\", params.values.radius)\n```"
+    ],
+    "argsType": "ComponentHandle",
+    "resultType": "MassParametersRecord | null"
+  },
   {
     "path": "design.query.getProperties",
     "namespace": "design.query",
@@ -5895,6 +6044,19 @@
     "argsType": "ComponentHandle",
     "resultType": "PluginDesignChangeResult"
   },
+  {
+    "path": "design.update.parameters",
+    "namespace": "design.update",
+    "summary": "Edit a parametric mass by patching its creation recipe and rebuilding the solid in place — the mass keeps its id, storey, materials, position and linked copies; only the geometry changes. Read the current record with `design.query.getParameters` first.",
+    "examplePrompts": [
+      "Make the dome's radius 8 metres",
+      "Raise the podium to 5 m",
+      "Widen the vase — move its profile points 20 cm outward",
+      "Change the fillet on the rounded column to 300 mm\n\n# Example\n```ts\n// { kind: \"sphere\", values: { centre, radius: 19.685 }, … }\nconst before = await snaptrude.design.query.getParameters(dome)\nconst after = await snaptrude.design.update.parameters(dome, { radius: 31.496 }) // 8 m in internal units\n\n// Fillet radius on a recorded result: read → edit → send the array back\nconst rec = await snaptrude.design.query.getParameters(column)\nconst operations = rec?.operations ?? []\nif (operations[0]?.op === \"fillet\") {\noperations[0].radius = 1.181\nawait snaptrude.design.update.parameters(column, { operations })\n}\n```"
+    ],
+    "argsType": "ComponentHandle",
+    "resultType": "MassParametersRecord"
+  },
   {
     "path": "design.update.roof",
     "namespace": "design.update",