@snaptrude/plugin-core 1.0.3 → 1.0.4

package/api-manifest.json

@@ -494,30 +494,6 @@
     "argsType": null,
     "resultType": "PluginCameraMode"
   },
-  {
-    "path": "core.camera.getNavigationSettings",
-    "namespace": "core.camera",
-    "summary": "Read the arrow-key navigation settings: whether the arrow keys walk the camera, the eye height used by `setPose`'s `standAt` and by walkthroughs that follow the floor, the walking speed, and whether walking stops at walls. Paired with {@linkcode PluginCameraApi.updateNavigationSettings}.",
-    "examplePrompts": [
-      "Is arrow-key navigation on?",
-      "What eye height does the camera use?\n\n# Example\n```ts\nconst { isKeyboardNavigationEnabled } =\nawait snaptrude.core.camera.getNavigationSettings()\n```"
-    ],
-    "argsType": null,
-    "resultType": "PluginCameraNavigationSettings"
-  },
-  {
-    "path": "core.camera.getPose",
-    "namespace": "core.camera",
-    "summary": "Read where the camera is and where it looks: the eye and target positions (world coordinates, internal `babylon` units), the view direction as yaw and pitch, the vertical field of view, the projection and the 2D/3D mode. Paired with {@linkcode PluginCameraApi.setPose}.",
-    "examplePrompts": [
-      "Where is the camera right now?",
-      "Remember this viewpoint so we can come back to it",
-      "Which way is the camera facing?",
-      "How high above the ground is the camera?\n\n# Example\n```ts\nconst pose = await snaptrude.core.camera.getPose()\nconsole.log(pose.eye, pose.yawInDegrees, pose.pitchInDegrees)\n```"
-    ],
-    "argsType": null,
-    "resultType": "PluginCameraPose"
-  },
   {
     "path": "core.camera.getProjection",
     "namespace": "core.camera",
@@ -543,31 +519,6 @@
     "argsType": "Vec3Handle",
     "resultType": "boolean"
   },
-  {
-    "path": "core.camera.move",
-    "namespace": "core.camera",
-    "summary": "Walk or fly the camera by a displacement in its own frame: `forward` along the level view direction, `right` to its side and `up` vertically, in internal `babylon` units. The view direction does not change. With `options.followsFloor` the camera keeps its height above the floor as it goes, climbing and descending stairs and ramps the way the arrow keys do. Stops a playing walkthrough and switches from 2D plan view to 3D first. View-state only: not write-gated, not undoable.",
-    "examplePrompts": [
-      "Walk forward 3 metres",
-      "Step to the right a little",
-      "Walk up the stairs ahead",
-      "Raise the camera by 2 metres\n\n# Example\n```ts\nconst metre = 1 / 0.254\nawait snaptrude.core.camera.move(\n{ forward: 3 * metre },\n{ followsFloor: true, durationInSeconds: 2 },\n)\n```"
-    ],
-    "argsType": "PluginCameraMoveDisplacement",
-    "resultType": "PluginCameraPose"
-  },
-  {
-    "path": "core.camera.rotate",
-    "namespace": "core.camera",
-    "summary": "Turn the camera in place by signed angles: `yawInDegrees` to the right (clockwise seen from above) and `pitchInDegrees` up. The eye does not move; the resulting pitch is kept within ±89°. Stops a playing walkthrough and switches from 2D plan view to 3D first. View-state only: not write-gated, not undoable.",
-    "examplePrompts": [
-      "Turn around",
-      "Look 45 degrees to the left",
-      "Tilt the camera down a bit\n\n# Example\n```ts\nawait snaptrude.core.camera.rotate(180, 0, { durationInSeconds: 1 })\n```"
-    ],
-    "argsType": "number",
-    "resultType": "PluginCameraPose"
-  },
   {
     "path": "core.camera.setMode",
     "namespace": "core.camera",
@@ -581,19 +532,6 @@
     "argsType": "PluginCameraMode",
     "resultType": "boolean"
   },
-  {
-    "path": "core.camera.setPose",
-    "namespace": "core.camera",
-    "summary": "Place the camera, optionally easing there over `options.durationInSeconds`, and resolve once the new view has been drawn, so a capture that follows sees it without a fixed wait. `pose` is one of:",
-    "examplePrompts": [
-      "Stand in the living room at eye level facing the window",
-      "Move the camera to (40, 12, 30) looking at the entrance",
-      "Fly the camera smoothly over to the courtyard",
-      "Put me back at the viewpoint we saved earlier\n\n# Example\n```ts\nconst { camera } = snaptrude.core\nawait camera.setPose({ standAt: { x: 20, y: 0, z: 35 }, yawInDegrees: 90 })\nawait camera.setPose(\n{ eye: { x: 60, y: 25, z: 60 }, target: { x: 0, y: 5, z: 0 } },\n{ durationInSeconds: 1.5 },\n)\n```"
-    ],
-    "argsType": "PluginCameraPoseInput",
-    "resultType": "PluginCameraPose"
-  },
   {
     "path": "core.camera.setProjection",
     "namespace": "core.camera",
@@ -621,18 +559,6 @@
     "argsType": "PluginStandardView",
     "resultType": "boolean"
   },
-  {
-    "path": "core.camera.updateNavigationSettings",
-    "namespace": "core.camera",
-    "summary": "Change arrow-key navigation settings; only the fields given change. `isKeyboardNavigationEnabled` is the user's Project Settings switch and is saved on this device; the other settings last for the session. Write-gated: this changes the user's preferences, not just the view.",
-    "examplePrompts": [
-      "Turn off arrow-key navigation",
-      "Use a 1.6 m eye height",
-      "Make walking stop at walls\n\n# Example\n```ts\nawait snaptrude.core.camera.updateNavigationSettings({\neyeHeight: 1.6 / 0.254,\nisCollisionEnabled: true,\n})\n```"
-    ],
-    "argsType": "PluginCameraNavigationSettingsPatch",
-    "resultType": "PluginCameraNavigationSettings"
-  },
   {
     "path": "core.camera.zoomExtents",
     "namespace": "core.camera",
@@ -698,6 +624,19 @@
     "argsType": "CommentHandle",
     "resultType": "PluginCommentDetails | null"
   },
+  {
+    "path": "core.comment.goTo",
+    "namespace": "core.comment",
+    "summary": "Take the camera to a comment's pin — mirrors clicking the comment in the sidebar: switches proposal if the comment belongs to another design option, activates its storey in 2D, restores the camera the comment was posted from, and selects it. Returns `false` for an unknown comment, a reply (replies have no pin), or an un-anchored project comment with no camera to restore.",
+    "examplePrompts": [
+      "Take me to the comment about the staircase",
+      "Show me where this comment is pinned",
+      "Jump the camera to the open comment on the roof",
+      "Navigate to the first unresolved comment\n\n# Example\n```ts\nconst [open] = await snaptrude.core.comment.list({ resolved: false })\nif (open) await snaptrude.core.comment.goTo(open)\n```"
+    ],
+    "argsType": "CommentHandle",
+    "resultType": "boolean"
+  },
   {
     "path": "core.comment.isResolved",
     "namespace": "core.comment",
@@ -714,16 +653,30 @@
   {
     "path": "core.comment.list",
     "namespace": "core.comment",
-    "summary": "List every comment in the project (deleted ones are excluded), returned as comment handles you can pass to the other comment methods.",
+    "summary": "List every comment in the project (deleted ones are excluded), returned as comment handles you can pass to the other comment methods. Pass a `filter` to narrow by resolved state, storey, or anchored component.",
     "examplePrompts": [
       "List all the comments in this project",
       "How many comments are on this model?",
       "Show every note in the file",
-      "Get all comments so I can check which are resolved\n\n# Example\n```ts\nconst comments = await snaptrude.core.comment.list()\nconsole.log(`${comments.length} comments in the project`)\n```"
+      "Which comments are still open on the second floor?",
+      "Get all comments so I can check which are resolved\n\n# Example\n```ts\nconst comments = await snaptrude.core.comment.list()\nconsole.log(`${comments.length} comments in the project`)\nconst open = await snaptrude.core.comment.list({ resolved: false, storey: 2 })\n```"
     ],
-    "argsType": null,
+    "argsType": "PluginCommentListFilter",
     "resultType": "CommentHandle[]"
   },
+  {
+    "path": "core.comment.listMentionableUsers",
+    "namespace": "core.comment",
+    "summary": "List the teammates who can be",
+    "examplePrompts": [
+      "Who can I tag in a comment on this project?",
+      "List the teammates I can mention",
+      "Find the structural engineer's email so I can tag them",
+      "Show me everyone on this project's team\n\n# Example\n```ts\nconst users = await snaptrude.core.comment.listMentionableUsers()\nconst alex = users.find((u) => u.name.toLowerCase().includes(\"alex\"))\nif (alex) await snaptrude.core.comment.tag(comment, alex.email)\n```"
+    ],
+    "argsType": null,
+    "resultType": "PluginCommentAuthor[]"
+  },
   {
     "path": "core.comment.reopen",
     "namespace": "core.comment",
@@ -803,9 +756,8 @@
   {
     "path": "core.geom.create.brepFromChamfer",
     "namespace": "core.geom.create",
-    "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.",
+    "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": [
-      "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```"
@@ -813,28 +765,6 @@
     "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",
@@ -842,9 +772,7 @@
     "examplePrompts": [
       "Extrude this profile 3 metres up",
       "Make a solid by extruding this outline",
-      "Create a cylinder from a circle profile",
-      "Extrude this floor plate 40m up with a 90 degree twist",
-      "Taper this tower to 60 percent of its footprint at the top\n\n# Example\n```ts\nconst rect = await snaptrude.core.geom.create.profileRect(4, 3)\nconst contour = await snaptrude.core.geom.create.contourFromProfile(rect)\nconst brep = await snaptrude.core.geom.create.brepFromExtrusion(contour, { x: 0, y: 1, z: 0 }, 3)\nconst faceCount = await snaptrude.core.geom.query.brep.getFaceCount(brep) // 6\n```"
+      "Create a cylinder from a circle profile\n\n# Example\n```ts\nconst rect = await snaptrude.core.geom.create.profileRect(4, 3)\nconst contour = await snaptrude.core.geom.create.contourFromProfile(rect)\nconst brep = await snaptrude.core.geom.create.brepFromExtrusion(contour, { x: 0, y: 1, z: 0 }, 3)\nconst faceCount = await snaptrude.core.geom.query.brep.getFaceCount(brep) // 6\n```"
     ],
     "argsType": "ContourHandle",
     "resultType": "BrepHandle"
@@ -864,14 +792,11 @@
   {
     "path": "core.geom.create.brepFromFillet",
     "namespace": "core.geom.create",
-    "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.",
+    "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 rim of the column with 200 mm",
-      "Soften where the dome meets the wall",
+      "Round the edges of this mass",
       "Fillet the corners of the podium with a 0.5m radius",
-      "Soften the vertical edges of this tower",
-      "Blend this edge from 200mm at one end to 600mm at the other",
-      "Round this rim wider at the back than at the front\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```"
+      "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"
@@ -891,7 +816,7 @@
   {
     "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, optionally through intermediate cross-sections. Host API call — returns a {@linkcode BrepHandle}. Sections with different edge counts are auto-matched: vertices are deterministically inserted on the smaller sections at the larger section's perimeter positions, so the same input always yields the same solid. For straight-edge (all-line) sections the seam is auto-aligned too — winding and start-vertex correspondence are chosen to avoid a twist, so outlines authored from any starting corner loft cleanly; arc-bearing sections keep the authored correspondence unchanged. A pair whose side faces would be non-planar under every correspondence still builds for hole-free straight-edged pairs — planar side quads stay quads and warped ones split into planar triangles (the triangulated fallback); arc-bearing or holed twisted pairs are rejected, as is auto-matching that would pair an arc with a straight edge. Matching hole counts are allowed in the two-section form. 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.",
+    "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}. Sections with different edge counts are auto-matched: vertices are deterministically inserted on the smaller sections at the larger section's perimeter positions, so the same input always yields the same solid. For straight-edge (all-line) sections the seam is auto-aligned too — winding and start-vertex correspondence are chosen to avoid a twist, so outlines authored from any starting corner loft cleanly; arc-bearing sections keep the authored correspondence unchanged. A pair whose side faces would be non-planar under every correspondence still builds for hole-free straight-edged pairs — planar side quads stay quads and warped ones split into planar triangles (the triangulated lane); arc-bearing or holed twisted pairs are rejected, as is auto-matching that would pair an arc with a straight edge. Matching hole counts are allowed in the two-section form. 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",
@@ -900,8 +825,7 @@
       "Loft a four-sided base to a five-sided top",
       "Loft these outlines even though their corners don't line up",
       "Loft these outlines exactly as authored, corner to corner",
-      "Fail the loft if my sections don't have matching edge counts",
-      "Loft these three outlines with smoothly curving sides\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```"
+      "Fail the loft if my sections don't have matching edge counts\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"
@@ -923,7 +847,6 @@
     "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```"
@@ -931,27 +854,14 @@
     "argsType": "BrepHandle",
     "resultType": "BrepHandle"
   },
-  {
-    "path": "core.geom.create.brepFromPatch",
-    "namespace": "core.geom.create",
-    "summary": "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.",
-    "examplePrompts": [
-      "Patch a roof over these four boundary curves, 250 mm thick",
-      "Span a canopy between these two curved rails, 300 mm thick\n\n# Example\n```ts\n// A roof over four curves\nconst roof = await snaptrude.core.geom.create.brepFromPatch(\n[curveA, curveB, curveC, curveD],\n0.984, // 250 mm\n)\nconst mass = await snaptrude.design.create.massFromBrep(roof, \"Roof patch\")\n```\n\n```ts\n// A canopy between two towers' rims, leaving every wall it meets smoothly:\n// with `continuity: \"tangent\"` EVERY item is an edge naming its face.\nconst canopy = await snaptrude.core.geom.create.brepFromPatch(\n[\n{ edge: rimA, brep: towerA, face: wallA },\n{ edge: sideA, brep: towerA, face: endA },\n{ edge: rimB, brep: towerB, face: wallB },\n{ edge: sideB, brep: towerB, face: endB },\n],\n1.181, // 300 mm\n{ continuity: \"tangent\" },\n)\n```"
-    ],
-    "argsType": "(CurveHandle | OwnedEdge)[]",
-    "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, 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.",
+    "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",
-      "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```"
+      "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"
@@ -961,25 +871,13 @@
     "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\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```"
+      "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.brepFromSphere",
-    "namespace": "core.geom.create",
-    "summary": "Create a solid **sphere** B-rep (boundary representation: the solid's exact faces, edges and vertices) 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",
@@ -987,7 +885,7 @@
     "examplePrompts": [
       "Subtract the courtyard from the building mass",
       "Cut this solid out of that one",
-      "Subtract this box solid from that solid\n\n# Example\n```ts\n// buildingBrep minus courtyardBrep — order matters\nconst carved = await snaptrude.core.geom.create.brepFromSubtraction(buildingBrep, courtyardBrep)\n```"
+      "Punch a hole through the slab with this box\n\n# Example\n```ts\n// buildingBrep minus courtyardBrep — order matters\nconst carved = await snaptrude.core.geom.create.brepFromSubtraction(buildingBrep, courtyardBrep)\n```"
     ],
     "argsType": "BrepHandle",
     "resultType": "BrepHandle"
@@ -995,7 +893,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 a sharp mitred bend; `\"round\"` carries the section around each turning corner on a tangent circular arc, so the corner patch is a real curved surface (geometrically cylindrical; `getSurfaceKind` reports it as `\"spline\"`) 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 a varying scale only accepts straight paths, so it never meets 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; `{ 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",
@@ -1003,35 +901,11 @@
       "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",
-      "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.brepFromSweepAlongCurve",
-    "namespace": "core.geom.create",
-    "summary": "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`. The properties panel shows it read-only, because it is a text value, not a number. A railed sweep records nothing (`getParameters` answers `null`).",
-    "examplePrompts": [
-      "Sweep a 600x400 duct along this curved route and keep it upright",
-      "Run this handrail along the curved stair edge",
-      "Bend this footprint along the arc\n\n# Example\n```ts\nconst route = await snaptrude.core.geom.create.splineFromPoints(points)\nconst duct = await snaptrude.core.geom.create.brepFromSweepAlongCurve(profile, [route], {\norientation: \"upright\",\n})\n```"
+      "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```"
     ],
     "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",
@@ -1056,16 +930,6 @@
     "argsType": "BrepHandle",
     "resultType": "BrepHandle[]"
   },
-  {
-    "path": "core.geom.create.brepsFromSplitByFace",
-    "namespace": "core.geom.create",
-    "summary": "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.",
-    "examplePrompts": [
-      "Cut this mass with the curved roof surface and keep the lower part\n\n# Example\n```ts\nconst target = await snaptrude.design.query.geometry.getBrep(tower, { frame: \"world\" })\nconst tool = await snaptrude.design.query.geometry.getBrep(roof, { frame: \"world\" })\nconst [toolFace] = await snaptrude.core.geom.query.brep.listFaces(tool)\nconst pieces = await snaptrude.core.geom.create.brepsFromSplitByFace(target, toolFace, tool)\n```"
-    ],
-    "argsType": "BrepHandle",
-    "resultType": "BrepHandle[]"
-  },
   {
     "path": "core.geom.create.circle",
     "namespace": "core.geom.create",
@@ -1096,14 +960,6 @@
     "argsType": "ProfileHandle",
     "resultType": "ContourHandle"
   },
-  {
-    "path": "core.geom.create.curvesFromProjection",
-    "namespace": "core.geom.create",
-    "summary": "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.",
-    "examplePrompts": [],
-    "argsType": "CurveHandle",
-    "resultType": "CurveHandle[]"
-  },
   {
     "path": "core.geom.create.line",
     "namespace": "core.geom.create",
@@ -1136,22 +992,10 @@
     "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",
-    "summary": "Create an axis-aligned **rectangle** profile in the XZ plane, `width` × `depth`, centred at `center` (defaults to the origin). Host API call — returns a handle.",
+    "summary": "Create an axis-aligned **rectangle** profile (XZ plane) of `width` × `depth`, centred at `center` (defaults to the origin). Host API call — returns a handle.",
     "examplePrompts": [
       "Draw a 4m by 3m rectangle",
       "Make a rectangular outline for a room footprint"
@@ -1159,28 +1003,6 @@
     "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\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",
@@ -1262,7 +1084,7 @@
   {
     "path": "core.geom.query.brep.getCentroid",
     "namespace": "core.geom.query.brep",
-    "summary": "Get the centroid of a brep: the mean of its vertex positions for planar and cylinder-sided solids; for a solid with sphere, cone, torus or spline geometry, its exact centre of mass (integrated over the surfaces; the vertex mean again if the kernel cannot integrate it, e.g. an open brep).",
+    "summary": "Get the centroid (mean of all vertex positions) of a brep.",
     "examplePrompts": [
       "Find the centre point of this shape",
       "What is the centroid of the selected object?\n\n# Example\n```ts\nconst [mass] = await snaptrude.design.query.listMasses()\nconst brep = await snaptrude.design.query.geometry.getBrep(mass)\nif (brep) {\nconst centroid = await snaptrude.core.geom.query.brep.getCentroid(brep)\nconsole.log(centroid.x, centroid.y, centroid.z)\n}\n```"
@@ -1273,7 +1095,7 @@
   {
     "path": "core.geom.query.brep.getDistance",
     "namespace": "core.geom.query.brep",
-    "summary": "Measures the minimum distance between two solids, with the closest point on each. Touching or overlapping solids report a distance of 0 with contact points.",
+    "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?",
@@ -1306,11 +1128,10 @@
       "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",
-      "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```"
+      "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```"
     ],
     "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      }\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      }"
+    "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      }"
   },
   {
     "path": "core.geom.query.brep.getFaceCount",
@@ -1344,18 +1165,6 @@
     "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",
@@ -1960,7 +1769,7 @@
   {
     "path": "core.geom.query.edge.getCurve",
     "namespace": "core.geom.query.edge",
-    "summary": "Get the underlying curve geometry of an edge (a line, arc or spline).",
+    "summary": "Get the underlying curve geometry of an edge (a line or arc).",
     "examplePrompts": [],
     "argsType": "EdgeHandle",
     "resultType": "CurveHandle | null"
@@ -1997,28 +1806,6 @@
     "argsType": "EdgeHandle",
     "resultType": "VertexHandle[]"
   },
-  {
-    "path": "core.geom.query.face.getArea",
-    "namespace": "core.geom.query.face",
-    "summary": "Exact surface area of one face of `brep`, in internal length units SQUARED — integrated off the face's own surface, not its facets, so a curved patch reads exactly rather than as its triangles. Needs the parent brep: a face handle cannot name its own solid.",
-    "examplePrompts": [
-      "How big is this roof patch?",
-      "Which face of this mass has the largest area?\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 areas = await Promise.all(\nfaces.map((f) => snaptrude.core.geom.query.face.getArea(f, brep)),\n)\n}\n```"
-    ],
-    "argsType": "FaceHandle",
-    "resultType": "number"
-  },
-  {
-    "path": "core.geom.query.face.getCentroid",
-    "namespace": "core.geom.query.face",
-    "summary": "Centre of area of one face of `brep`, as a point in that brep's frame (internal length units). On a solid whose every face reads `\"spline\"` this is the read that tells two patches apart — the top of a thickened patch from its bottom, one quarter of a closed surface from the next.",
-    "examplePrompts": [
-      "Where is the middle of this face?",
-      "Pick the topmost face of this curved mass\n\n# Example\n```ts\nconst centre = await snaptrude.core.geom.query.face.getCentroid(face, brep)\n```"
-    ],
-    "argsType": "FaceHandle",
-    "resultType": "Vec3Components"
-  },
   {
     "path": "core.geom.query.face.getHalfEdge",
     "namespace": "core.geom.query.face",
@@ -2059,19 +1846,6 @@
     "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",
@@ -2422,7 +2196,7 @@
     "summary": "Add a hole to a contour by appending an inner profile. Immutable — returns a NEW contour and leaves the input unchanged.",
     "examplePrompts": [
       "Cut a hole in this shape",
-      "Punch an opening through this outline\n\n# Example\n```ts\nconst outer = await snaptrude.core.geom.create.profileRect(10, 8)\nconst contour = await snaptrude.core.geom.create.contourFromProfile(outer)\nconst hole = await snaptrude.core.geom.create.profileRect(2, 2)\nconst withHole = await snaptrude.core.geom.update.contour.addHole(contour, hole)\nconst count = await snaptrude.core.geom.query.contour.getHoleCount(withHole) // 1\n```"
+      "Punch an opening through this floor outline\n\n# Example\n```ts\nconst outer = await snaptrude.core.geom.create.profileRect(10, 8)\nconst contour = await snaptrude.core.geom.create.contourFromProfile(outer)\nconst hole = await snaptrude.core.geom.create.profileRect(2, 2)\nconst withHole = await snaptrude.core.geom.update.contour.addHole(contour, hole)\nconst count = await snaptrude.core.geom.query.contour.getHoleCount(withHole) // 1\n```"
     ],
     "argsType": "ContourHandle",
     "resultType": "ContourHandle"
@@ -2466,7 +2240,7 @@
     "summary": "Remove a hole from a contour by inner-profile index. Immutable — returns a NEW contour and leaves the input unchanged.",
     "examplePrompts": [
       "Remove the hole from this shape",
-      "Fill in the opening in this outline\n\n# Example\n```ts\nconst outer = await snaptrude.core.geom.create.profileRect(10, 8)\nconst hole = await snaptrude.core.geom.create.profileRect(2, 2)\nconst contour = await snaptrude.core.geom.create.contourFromProfiles(outer, [hole])\nconst solid = await snaptrude.core.geom.update.contour.removeHole(contour, 0)\n```"
+      "Fill in the opening in this floor outline\n\n# Example\n```ts\nconst outer = await snaptrude.core.geom.create.profileRect(10, 8)\nconst hole = await snaptrude.core.geom.create.profileRect(2, 2)\nconst contour = await snaptrude.core.geom.create.contourFromProfiles(outer, [hole])\nconst solid = await snaptrude.core.geom.update.contour.removeHole(contour, 0)\n```"
     ],
     "argsType": "ContourHandle",
     "resultType": "ContourHandle"
@@ -3323,55 +3097,14 @@
     "argsType": "UnderlayHandle",
     "resultType": "{ scaleFactor: number }"
   },
-  {
-    "path": "core.layers.assign",
-    "namespace": "core.layers",
-    "summary": "Move objects onto a layer (picking a layer in the object properties panel).",
-    "examplePrompts": [
-      "Move the selected objects to the BIM layer",
-      "Move the selected objects to the Furniture layer",
-      "Assign the generated walls to the Structure layer",
-      "Put these masses on layer 3f2a…\n\n# Example\n```ts\nconst { assigned, skipped } = await snaptrude.core.layers.assign(ids, layerId)\n```"
-    ],
-    "argsType": "ComponentHandle[]",
-    "resultType": "PluginCoreLayersAssignResult"
-  },
-  {
-    "path": "core.layers.create",
-    "namespace": "core.layers",
-    "summary": "Create a new layer in the Layers panel (the panel's \"Add new layer\" button followed by naming it).",
-    "examplePrompts": [
-      "Create a new layer called Furniture",
-      "Add a layer called Landscape",
-      "Add a layer named Landscape to the Layers panel",
-      "Make a new layer for the facade elements",
-      "Create layers named Structure and Services\n\n# Example\n```ts\nconst layer = await snaptrude.core.layers.create(\"Furniture\")\nawait snaptrude.core.layers.setActive(layer.id)\n```"
-    ],
-    "argsType": "string",
-    "resultType": "PluginCoreLayersCreateResult"
-  },
-  {
-    "path": "core.layers.delete",
-    "namespace": "core.layers",
-    "summary": "Delete a layer (the panel row's \"Delete layer\").",
-    "examplePrompts": [
-      "Delete the Furniture layer and everything on it",
-      "Delete the Furniture layer and move its objects to Default",
-      "Remove layer 3f2a… and move its objects to the default layer",
-      "Merge the Services layer into Structure and delete it",
-      "Delete every empty layer\n\n# Example\n```ts\nawait snaptrude.core.layers.delete(layerId, { deleteObjects: true })\nconst { layers } = await snaptrude.core.layers.list()\nconst def = layers.find((l) => l.isDefault)!\nawait snaptrude.core.layers.delete(otherId, { targetLayerId: def.id })\n```"
-    ],
-    "argsType": "string",
-    "resultType": "PluginCoreLayersDeleteResult"
-  },
   {
     "path": "core.layers.get",
     "namespace": "core.layers",
-    "summary": "Get one Layers-panel layer by id, including layers owned by other design options.",
+    "summary": "Get a single drawing layer by id.",
     "examplePrompts": [
-      "Get the Layers-panel layer with id 3f2a…",
-      "Is the Furniture layer locked or hidden?",
-      "How many objects are on layer 3f2a…?\n\n# Example\n```ts\nconst layer = await snaptrude.core.layers.get(layerId)\nif (layer) console.log(layer.name, layer.objectCount)\n```"
+      "Get the drawing layer with id ly_5",
+      "Is layer ly_5 hidden or locked?",
+      "Look up a single drawing layer by its id\n\n# Example\n```ts\nconst layer = await snaptrude.core.layers.get(\"ly_5\")\nif (layer) console.log(layer.name, layer.hidden, layer.locked)\n```"
     ],
     "argsType": "string",
     "resultType": "PluginCoreLayersGetResult"
@@ -3379,51 +3112,35 @@
   {
     "path": "core.layers.getActive",
     "namespace": "core.layers",
-    "summary": "Get the active Layers-panel layer: the one new objects land on.",
+    "summary": "Get the active drawing layer of a storey.",
     "examplePrompts": [
-      "Which layer is active?",
-      "Which layer in the Layers panel is active?",
-      "What layer will new objects go on?",
-      "Which layer are new walls and masses being added to?\n\n# Example\n```ts\nconst active = await snaptrude.core.layers.getActive()\nif (active) console.log(active.name)\n```"
+      "Which drawing layer is active on this storey?",
+      "Get the current layer on storey st_2",
+      "What layer am I drawing on?\n\n# Example\n```ts\nconst active = await snaptrude.core.layers.getActive(\"st_2\")\nif (active) console.log(active.name)\n```"
     ],
-    "argsType": null,
+    "argsType": "string",
     "resultType": "PluginCoreLayersGetActiveResult"
   },
   {
     "path": "core.layers.list",
     "namespace": "core.layers",
-    "summary": "List the layers in the Layers panel: the active design option's layers, default layer first, then in creation order.",
-    "examplePrompts": [
-      "List all the layers in the Layers panel",
-      "Show me the layers in the left sidebar",
-      "What layers does this project have?",
-      "Show every layer with whether it is locked or hidden",
-      "Which layer is the default layer?",
-      "Which layers are empty?\n\n# Example\n```ts\nconst { layers } = await snaptrude.core.layers.list()\nfor (const l of layers) console.log(l.name, l.objectCount, l.locked, l.hidden)\n```"
-    ],
-    "argsType": null,
-    "resultType": "PluginCoreLayersListResult"
-  },
-  {
-    "path": "core.layers.rename",
-    "namespace": "core.layers",
-    "summary": "Rename a layer (the panel row's \"Rename layer\").",
+    "summary": "List the drawing layers of a storey.",
     "examplePrompts": [
-      "Rename the Furniture layer to Loose furniture",
-      "Rename layer 3f2a… to Existing building",
-      "Change the name of the Landscape layer\n\n# Example\n```ts\nawait snaptrude.core.layers.rename(layerId, \"Loose furniture\")\n```"
+      "List the drawing layers on this storey",
+      "Show all the PDF underlays on storey st_2",
+      "What CAD layers are on the ground floor?\n\n# Example\n```ts\nconst { layers } = await snaptrude.core.layers.list(\"st_2\")\nfor (const l of layers) console.log(l.name, l.layerType, l.hidden)\n```"
     ],
     "argsType": "string",
-    "resultType": "PluginCoreLayersRenameResult"
+    "resultType": "PluginCoreLayersListResult"
   },
   {
     "path": "core.layers.setActive",
     "namespace": "core.layers",
-    "summary": "Make a layer the active layer (clicking its row in the Layers panel).",
+    "summary": "Make a drawing layer the active layer of its storey.",
     "examplePrompts": [
-      "Put new objects on the Furniture layer",
-      "Make the Structure layer the active layer in the Layers panel",
-      "Switch the active layer to Landscape\n\n# Example\n```ts\nawait snaptrude.core.layers.setActive(layerId)\n```"
+      "Draw on layer ly_5",
+      "Make this the active layer",
+      "Switch the active layer to the CAD underlay\n\n# Example\n```ts\nawait snaptrude.core.layers.setActive(\"ly_5\")\n```"
     ],
     "argsType": "string",
     "resultType": "PluginCoreLayersSetActiveResult"
@@ -3431,12 +3148,11 @@
   {
     "path": "core.layers.update",
     "namespace": "core.layers",
-    "summary": "Lock/unlock or show/hide a layer (the panel row's padlock and eye).",
+    "summary": "Update a drawing layer's visibility.",
     "examplePrompts": [
-      "Lock the Default layer",
-      "Lock the Structure layer",
-      "Hide the Landscape layer in the Layers panel",
-      "Unlock layer 3f2a… and show it again\n\n# Example\n```ts\nawait snaptrude.core.layers.update(layerId, { locked: true, hidden: false })\n```"
+      "Hide the PDF underlay layer",
+      "Show the CAD layer again",
+      "Hide layer ly_5\n\n# Example\n```ts\nconst layer = await snaptrude.core.layers.update(\"ly_5\", true)\n```"
     ],
     "argsType": "string",
     "resultType": "PluginCoreLayersUpdateResult"
@@ -4166,66 +3882,6 @@
     "argsType": null,
     "resultType": "number"
   },
-  {
-    "path": "core.storeys.layers.get",
-    "namespace": "core.storeys.layers",
-    "summary": "Get a single storey layer by id.",
-    "examplePrompts": [
-      "Get the storey drawing layer with id ly_5",
-      "Is storey layer ly_5 hidden?",
-      "Look up a storey underlay layer by id\n\n# Example\n```ts\nconst layer = await snaptrude.core.storeys.layers.get(\"ly_5\")\nif (layer) console.log(layer.name, layer.hidden, layer.locked)\n```"
-    ],
-    "argsType": "string",
-    "resultType": "PluginCoreStoreysLayersGetResult"
-  },
-  {
-    "path": "core.storeys.layers.getActive",
-    "namespace": "core.storeys.layers",
-    "summary": "Get the active storey layer of a storey.",
-    "examplePrompts": [
-      "Which sketch surface (Wall/Rough) is active on this storey?",
-      "Get the active storey drawing layer on st_2",
-      "Which storey layer is new sketch geometry drawn onto?\n\n# Example\n```ts\nconst active = await snaptrude.core.storeys.layers.getActive(\"st_2\")\nif (active) console.log(active.name)\n```"
-    ],
-    "argsType": "string",
-    "resultType": "PluginCoreStoreysLayersGetActiveResult"
-  },
-  {
-    "path": "core.storeys.layers.list",
-    "namespace": "core.storeys.layers",
-    "summary": "List the storey layers of a storey.",
-    "examplePrompts": [
-      "List the sketch surfaces and underlays on this storey",
-      "Show all the PDF underlays on storey st_2",
-      "What CAD layers are on the ground floor?\n\n# Example\n```ts\nconst { layers } = await snaptrude.core.storeys.layers.list(\"st_2\")\nfor (const l of layers) console.log(l.name, l.layerType, l.hidden)\n```"
-    ],
-    "argsType": "string",
-    "resultType": "PluginCoreStoreysLayersListResult"
-  },
-  {
-    "path": "core.storeys.layers.setActive",
-    "namespace": "core.storeys.layers",
-    "summary": "Make a storey layer the active layer of its storey.",
-    "examplePrompts": [
-      "Switch this storey's sketch surface to the Rough layer",
-      "Make storey layer ly_5 the active sketch surface",
-      "Switch the active storey layer to the CAD underlay\n\n# Example\n```ts\nawait snaptrude.core.storeys.layers.setActive(\"ly_5\")\n```"
-    ],
-    "argsType": "string",
-    "resultType": "PluginCoreStoreysLayersSetActiveResult"
-  },
-  {
-    "path": "core.storeys.layers.update",
-    "namespace": "core.storeys.layers",
-    "summary": "Update a storey layer's visibility.",
-    "examplePrompts": [
-      "Hide the PDF underlay layer",
-      "Show the CAD underlay again",
-      "Hide storey layer ly_5\n\n# Example\n```ts\nconst layer = await snaptrude.core.storeys.layers.update(\"ly_5\", true)\n```"
-    ],
-    "argsType": "string",
-    "resultType": "PluginCoreStoreysLayersUpdateResult"
-  },
   {
     "path": "core.storeys.list",
     "namespace": "core.storeys",
@@ -4242,7 +3898,7 @@
   {
     "path": "core.storeys.setActive",
     "namespace": "core.storeys",
-    "summary": "Make a storey the active storey — the same as clicking it in the storey/layer panel. Subsequent draws and creates target this storey, and in 2D the viewport switches to that storey's plan (and its cut range), unless the active view is already a plan on it. This is a view/navigation change: it is **not** undoable and commits nothing to the model.",
+    "summary": "Make a storey the active storey — the same as clicking it in the storey/layer panel. Subsequent draws and creates target this storey, and in 2D the viewport switches to it. This is a view/navigation change: it is **not** undoable and commits nothing to the model.",
     "examplePrompts": [
       "Switch to the second floor",
       "Make the ground storey active",
@@ -4566,46 +4222,6 @@
     "resultType": "boolean",
     "deprecated": "core.camera.zoomSelection"
   },
-  {
-    "path": "design.bim.create",
-    "namespace": "design.bim",
-    "summary": "Execute native Sketch-to-BIM. Revalidates scope, catalogue access and construction before mutation. Uses native progress/cancel controls and worker cancellation. Floors/roofs retain project defaults.",
-    "examplePrompts": [
-      "Convert these sketch rooms to BIM with wall layers chosen for each room boundary"
-    ],
-    "argsType": "string",
-    "resultType": "PluginBimResult"
-  },
-  {
-    "path": "design.bim.getContext",
-    "namespace": "design.bim",
-    "summary": "Read room adjacency and native conversion eligibility in the active proposal.",
-    "examplePrompts": [
-      "Inspect the rooms on each side of these sketch wall boundaries"
-    ],
-    "argsType": "PluginBimContextArgs",
-    "resultType": "PluginBimContext"
-  },
-  {
-    "path": "design.bim.prepare",
-    "namespace": "design.bim",
-    "summary": "Stage a complete wall-construction assignment. A new prepare replaces this plugin's prior plan.",
-    "examplePrompts": [
-      "Validate wall layer assignments before converting sketch rooms to BIM"
-    ],
-    "argsType": "PluginBimPrepareArgs",
-    "resultType": "PluginBimPreparation"
-  },
-  {
-    "path": "design.bim.update",
-    "namespace": "design.bim",
-    "summary": "Add a partition graph with explicit connectivity and chosen wall families in one undo step. Validation is part of this call. PG2 splits intersections and generates floors with native lineage. Does not move/delete existing edges, infer face snapping, or change catalogue definitions.",
-    "examplePrompts": [
-      "Add bathroom partitions attached to these existing graph boundaries"
-    ],
-    "argsType": "string",
-    "resultType": "PluginBimUpdateResult"
-  },
   {
     "path": "design.boolean.intersect",
     "namespace": "design.boolean",
@@ -4647,38 +4263,6 @@
     "argsType": "ComponentHandle[]",
     "resultType": "BooleanOutcome"
   },
-  {
-    "path": "design.catalog.get",
-    "namespace": "design.catalog",
-    "summary": "",
-    "examplePrompts": [],
-    "argsType": "PluginCatalogReference",
-    "resultType": "PluginCatalogEntry | null"
-  },
-  {
-    "path": "design.catalog.list",
-    "namespace": "design.catalog",
-    "summary": "",
-    "examplePrompts": [],
-    "argsType": "PluginCatalogKind",
-    "resultType": "PluginCatalogEntry[]"
-  },
-  {
-    "path": "design.catalog.listCategories",
-    "namespace": "design.catalog",
-    "summary": "Discover categories from accessible saved families and current project constructions. Omit parent for roots; pass a slash-separated returned path for its direct children. This metadata read does not fetch recipes, include unsaved drafts or legacy mesh inventories, or establish capabilities. Use search then get before placement. Names retain their case.",
-    "examplePrompts": [],
-    "argsType": "PluginCatalogListCategoriesArgs",
-    "resultType": "PluginCatalogCategory[]"
-  },
-  {
-    "path": "design.catalog.search",
-    "namespace": "design.catalog",
-    "summary": "Search accessible saved-family and project-construction metadata without downloading recipes. Categories are data, not an SDK enum. Legacy mesh inventories and unsaved drafts are excluded. Inspect selected references with get before placement; a search match does not prove validity or supported behavior. Pagination reads live data, not a snapshot. Failures reject.",
-    "examplePrompts": [],
-    "argsType": "PluginCatalogSearchArgs",
-    "resultType": "PluginCatalogSearchResult"
-  },
   {
     "path": "design.create.beam",
     "namespace": "design.create",
@@ -4689,7 +4273,7 @@
       "Run a 300x600 beam across the room",
       "Extrude this cross-section into a 5m long beam\n\n# Example\n```ts\nconst rect = await snaptrude.core.geom.create.profileRect(0.3, 0.6)\nconst section = await snaptrude.core.geom.create.contourFromProfile(rect)\nconst alongX = await snaptrude.core.math.vec3.new(1, 0, 0)\nconst beam = await snaptrude.design.create.beam(section, 6, alongX)\n```"
     ],
-    "argsType": "| [section: ContourHandle, length: number, direction?: Vec3Handle]\n      | [axis: LineHandle, options: PluginFamilyPlacement]",
+    "argsType": "ContourHandle",
     "resultType": "ComponentHandle"
   },
   {
@@ -4705,17 +4289,6 @@
     "argsType": "PluginBuildableEnvelopePolygonVertex[]",
     "resultType": "PluginBuildableEnvelopeCreateResult"
   },
-  {
-    "path": "design.create.buildableEnvelopeFromSite",
-    "namespace": "design.create",
-    "summary": "Create a default buildable envelope for an existing site — the same as the right panel's \"Create Buildable Envelope\" button. Front, side and rear distances are seeded from Site Analysis or the Program sheet, with a 10 ft fallback, and the envelope is linked to the site. Call it only after the user agrees (for example when `design.update.siteEdge` throws `NO_BUILDABLE_ENVELOPE`).",
-    "examplePrompts": [
-      "Create a buildable envelope for this site with default setbacks",
-      "Add the zoning envelope to my site\n\n# Example\n```ts\nconst [{ siteId }] = (await snaptrude.program.site.listEdges()).sites\nconst { buildableEnvelopeId } =\nawait snaptrude.design.create.buildableEnvelopeFromSite(siteId)\n```"
-    ],
-    "argsType": "string",
-    "resultType": "PluginDesignCreateBuildableEnvelopeFromSiteResult"
-  },
   {
     "path": "design.create.ceiling",
     "namespace": "design.create",
@@ -4726,7 +4299,7 @@
       "Put a dropped ceiling in the living room at 3 metres",
       "Add a 50mm thick ceiling lifted 2800mm from floor level\n\n# Example\n```ts\nconst rect = await snaptrude.core.geom.create.profileRect(5, 4)\nconst contour = await snaptrude.core.geom.create.contourFromProfile(rect)\nconst ceiling = await snaptrude.design.create.ceiling(contour, 0.05, 2.8)\n```"
     ],
-    "argsType": "| [contour: ContourHandle, thickness: number, heightFromFloor?: number]\n      | [contour: ContourHandle, options: PluginFamilyCeilingOptions]",
+    "argsType": "ContourHandle",
     "resultType": "ComponentHandle"
   },
   {
@@ -4739,29 +4312,19 @@
       "Create a 450mm square concrete column 4 metres high",
       "Stand a column up from this base point\n\n# Example\n```ts\nconst rect = await snaptrude.core.geom.create.profileRect(0.45, 0.45)\nconst crossSection = await snaptrude.core.geom.create.contourFromProfile(rect)\nconst base = await snaptrude.core.math.vec3.new(4, 0, 4)\nconst column = await snaptrude.design.create.column(base, crossSection, 3)\n```"
     ],
-    "argsType": "| [\n          position: Vec3Handle,\n          crossSection: ContourHandle,\n          height: number,\n          directionUp?: Vec3Handle,\n        ]\n      | [axis: LineHandle, options: PluginFamilyPlacement]",
+    "argsType": "Vec3Handle",
     "resultType": "ComponentHandle"
   },
-  {
-    "path": "design.create.columnsFromGrids",
-    "namespace": "design.create",
-    "summary": "Create **columns at every grid-line intersection** of the given grid groups, sized `width` × `depth` and oriented to the grid axes, on the grids' storey. All columns commit as ONE undoable unit.",
-    "examplePrompts": [
-      "Generate columns on this grid",
-      "Place 450mm square columns at every grid intersection\n\n# Example\n```ts\nconst grids = await snaptrude.design.query.listGrids()\nconst columns = await snaptrude.design.create.columnsFromGrids(grids, 0.45, 0.45)\n```"
-    ],
-    "argsType": "ComponentHandle[]",
-    "resultType": "ComponentHandle[]"
-  },
   {
     "path": "design.create.copy",
     "namespace": "design.create",
-    "summary": "**Copy** existing entities, offsetting each copy by `displacement * i` (i = 1…count), source positions preserved. Migrated from the removed `tools.copy`. The created copies become the active selection. Undoable.",
+    "summary": "**Copy** existing entities, offsetting each copy by `displacement * i` (i = 1…count), source positions preserved. Migrated from the removed `tools.copy`. In `\"instance\"` mode copies stay in the source's instance family where possible; `\"unique\"` makes independent geometry. The created copies become the active selection. Undoable.",
     "examplePrompts": [
       "Copy this room 3 times spaced 6m apart",
       "Duplicate the selected furniture along the X axis",
       "Make 5 copies of this column at 4 metre intervals",
-      "Array these walls with a 3m offset"
+      "Array these walls with a 3m offset",
+      "Clone the desk as a unique copy, not an instance"
     ],
     "argsType": "ComponentHandle[]",
     "resultType": "ComponentHandle[]",
@@ -4770,7 +4333,7 @@
   {
     "path": "design.create.door",
     "namespace": "design.create",
-    "summary": "Place a parametric **door** family into a host wall.",
+    "summary": "Place a **door** from the catalog into a host wall.",
     "examplePrompts": [
       "Add a door to this wall here",
       "Place a sliding door on the selected wall",
@@ -4787,17 +4350,17 @@
   {
     "path": "design.create.doors",
     "namespace": "design.create",
-    "summary": "Place **many doors** into host walls in one undoable operation (bulk plural of {@linkcode door}). Each item carries its own family id, host wall, world position, and optional `facing`, `label`, `width` and `height` — the same fields as a `\"door\"` {@linkcode PluginDesignCreateOpeningOptions}. Validate-all-or-throw; one command.",
+    "summary": "Place **many doors** into host walls in one undoable operation (bulk plural of {@linkcode door}). Each item carries its own catalog id, host wall, world position, and optional `facing`, `label`, `width` and `height` — the same fields as a `\"door\"` {@linkcode PluginDesignCreateOpeningOptions}. Validate-all-or-throw; one command.",
     "examplePrompts": [
       "Add doors to all of these walls at once",
       "Place a door in every room in one operation",
       "Bulk add the entrance doors from this schedule",
       "Put three doors on this wall in a single undo step",
-      "Add all the doors for this floor plan together\n\nA width/height (top-level, or under the family's own keys in `values`) on a family that\ntakes its size from its Type while Custom Sizes is off is never dropped: the Type within\n25 mm is chosen, else Custom Sizes is turned on and that size is built, leaving the Type\nlabel stale. `design.doors.checkPlacement` reports which as `sizing`; `customSizes: \"No\"`\nwith a size no Type matches is refused."
+      "Add all the doors for this floor plan together"
     ],
     "argsType": "PluginCreateDoorItem[]",
     "resultType": "ComponentHandle[]",
-    "performance": "Bulk creator — the whole batch is ONE host round-trip and ONE undo entry. Always prefer this over calling `design.create.door` in a loop: build the full `items[]` array first (all host walls and points up front), then make one call. # Example ```ts const v = snaptrude.core.math.vec3 const [wall] = await snaptrude.design.query.listWalls({ isSelected: true }) const [entry] = await snaptrude.design.doors.listCatalog() const [front, side] = await snaptrude.design.create.doors([ { familyId: entry.id, hostWall: wall, position: await v.new(2, 0, 5), label: \"D-01\" }, { familyId: entry.id, hostWall: wall, position: await v.new(6, 0, 5), values: { width: \"1200mm\" } }, ]) // The host still resolves after both cuts: const currentWall = await snaptrude.design.query.getHost(front) ```"
+    "performance": "Bulk creator — the whole batch is ONE host round-trip and ONE undo entry, and each distinct catalog source loads once. Always prefer this over calling `design.create.door` in a loop: build the full `items[]` array first (all host walls and points up front), then make one call. # Example ```ts const v = snaptrude.core.math.vec3 const [wall] = await snaptrude.design.query.listWalls({ isSelected: true }) const [entry] = await snaptrude.design.doors.listCatalog() const [front, side] = await snaptrude.design.create.doors([ { catalogId: entry.id, hostWall: wall, position: await v.new(2, 0, 5), label: \"D-01\" }, { catalogId: entry.id, hostWall: wall, position: await v.new(6, 0, 5), width: 1.2 }, ]) // `wall` was re-cut twice and no longer resolves — ask the opening for its host: const currentWall = await snaptrude.design.query.getHost(front) ```"
   },
   {
     "path": "design.create.floor",
@@ -4809,9 +4372,9 @@
       "Lay flooring across the selected outline",
       "Put a floor at this position with 150mm thickness\n\n# Example\n```ts\nconst rect = await snaptrude.core.geom.create.profileRect(5, 4)\nconst contour = await snaptrude.core.geom.create.contourFromProfile(rect)\nconst floor = await snaptrude.design.create.floor(contour, 0.1)\n```"
     ],
-    "argsType": "| [contour: ContourHandle, thickness: number, position?: Vec3Handle]\n      | [contour: ContourHandle, options: PluginFamilyFloorOptions]",
-    "resultType": "ComponentHandle[]",
-    "performance": "For dimensional floors, `design.create.floors(items[])` uses one host round-trip and one undo entry. That bulk method does not accept native family options; use this method for a family-backed floor."
+    "argsType": "ContourHandle",
+    "resultType": "ComponentHandle",
+    "performance": "For MORE THAN ONE floor, call `design.create.floors(items[])` — one host round-trip and ONE undo entry for the whole batch. Looping this single-floor creator is N round-trips and N undo entries."
   },
   {
     "path": "design.create.floors",
@@ -4860,50 +4423,14 @@
     "performance": "Bulk creator — the whole batch is ONE host round-trip and ONE undo entry, and each distinct catalog source loads once. Always prefer this over calling `design.create.furniture` in a loop: build the full `items[]` array first (all positions and angles up front), then make one call. # Example ```ts const v = snaptrude.core.math.vec3 const [chair] = await snaptrude.design.furniture.listCatalog() const placed = await snaptrude.design.create.furnitureItems([ { catalogId: chair.id, position: await v.new(3, 0, 5), label: \"Chair-01\" }, { catalogId: chair.id, position: await v.new(4, 0, 5), angleInDegrees: 90 }, { catalogId: chair.id, position: await v.new(5, 0, 5), angleInDegrees: 180 }, ]) ```"
   },
   {
-    "path": "design.create.grid",
+    "path": "design.create.mass",
     "namespace": "design.create",
-    "summary": "Create a free rectangular **structural grid** — one grid group with two perpendicular line families (`linesX` lines spaced `spacingX` apart, and `linesY` lines spaced `spacingY` apart) on the active storey. One undoable creation.",
+    "summary": "Create a **mass** — a generic extruded prism (default `massType` \"Generic mass\"). Same footprint-extrude path as {@linkcode PluginDesignCreateApi.space}.",
     "examplePrompts": [
-      "Create a 5 by 8 structural grid with 6 metre spacing",
-      "Add a column grid rotated 30 degrees",
-      "Set up a structural grid at the site origin\n\n# Example\n```ts\nconst centre = await snaptrude.core.math.vec3.new(0, 0, 0)\nconst grid = await snaptrude.design.create.grid(5, 8, 6, 6, { center: centre })\n```"
-    ],
-    "argsType": "number",
-    "resultType": "ComponentHandle"
-  },
-  {
-    "path": "design.create.gridFromCurve",
-    "namespace": "design.create",
-    "summary": "Create a **structural grid from a single curve** — one grid group holding one wing with one line (the draw tool's output). The curve may be a line or an arc; circles are rejected with `VALIDATION`. Undoable.",
-    "examplePrompts": [
-      "Draw a grid line from A to B",
-      "Add a curved grid line through these points",
-      "Create grid line \"C\" along this wall\n\n# Example\n```ts\nconst { vec3 } = snaptrude.core.math\nconst from = await vec3.new(0, 0, 0)\nconst to = await vec3.new(30, 0, 0)\nconst curve = await snaptrude.core.geom.create.line(from, to)\nconst grid = await snaptrude.design.create.gridFromCurve(curve, { tag: \"A\" })\n```"
-    ],
-    "argsType": "CurveHandle",
-    "resultType": "ComponentHandle"
-  },
-  {
-    "path": "design.create.gridsFromMasses",
-    "namespace": "design.create",
-    "summary": "Generate **structural grids fitted to mass footprints** — one grid group per footprint cluster, with counts and orientation derived from each footprint's geometry and the given spacings. All created groups commit as ONE undoable unit.",
-    "examplePrompts": [
-      "Generate grids for the selected masses",
-      "Auto-generate a 6m structural grid on this building",
-      "Fit column grids to every mass on this storey\n\n# Example\n```ts\nconst masses = await snaptrude.design.query.listMasses({ storeys: [1] })\nconst grids = await snaptrude.design.create.gridsFromMasses(masses, 6, 6)\n```"
-    ],
-    "argsType": "ComponentHandle[]",
-    "resultType": "ComponentHandle[]"
-  },
-  {
-    "path": "design.create.mass",
-    "namespace": "design.create",
-    "summary": "Create a **mass** — a generic extruded prism (default `massType` \"Generic mass\"). Same footprint-extrude path as {@linkcode PluginDesignCreateApi.space}.",
-    "examplePrompts": [
-      "Create a generic mass 30m tall from this footprint",
-      "Block out a conceptual massing volume for the site",
-      "Extrude this shape into a building mass",
-      "Add a simple study-model volume at the origin\n\n# Example\n```ts\nconst rect = await snaptrude.core.geom.create.profileRect(20, 15)\nconst contour = await snaptrude.core.geom.create.contourFromProfile(rect)\nconst tower = await snaptrude.design.create.mass(contour, 30, \"Tower A\", undefined, \"Building\")\n```"
+      "Create a generic mass 30m tall from this footprint",
+      "Block out a conceptual massing volume for the site",
+      "Extrude this shape into a building mass",
+      "Add a simple study-model volume at the origin\n\n# Example\n```ts\nconst rect = await snaptrude.core.geom.create.profileRect(20, 15)\nconst contour = await snaptrude.core.geom.create.contourFromProfile(rect)\nconst tower = await snaptrude.design.create.mass(contour, 30, \"Tower A\", undefined, \"Building\")\n```"
     ],
     "argsType": "ContourHandle",
     "resultType": "ComponentHandle"
@@ -4923,14 +4450,14 @@
   {
     "path": "design.create.opening",
     "namespace": "design.create",
-    "summary": "Place a parametric **door or window** into a host wall with parameter overrides.",
+    "summary": "Place a catalog **door or window** into a host wall with optional size overrides.",
     "examplePrompts": [
       "Add a 1m wide door to this wall here",
       "Place a window with a 0.9m sill height on the selected wall"
     ],
     "argsType": "PluginDesignCreateOpeningOptions",
     "resultType": "ComponentHandle",
-    "performance": "Single-opening creator — use it for one hosted opening. For MORE THAN ONE, call `design.create.doors(items[])` / `design.create.windows(items[])`: the same per-item fields, one host round-trip, ONE undo entry. # Example ```ts const opening = await snaptrude.design.create.opening({ kind: \"window\", familyId: windowType.id, hostWall: wall, position: await snaptrude.core.math.vec3.new(3, 0, 5), width: 1.2, height: 1.5, sillHeight: 0.9, }) ```"
+    "performance": "Single-opening creator — use it for one hosted opening. For MORE THAN ONE, call `design.create.doors(items[])` / `design.create.windows(items[])`: the same per-item fields, one host round-trip, ONE undo entry. # Example ```ts const opening = await snaptrude.design.create.opening({ kind: \"window\", catalogId: windowType.id, hostWall: wall, position: await snaptrude.core.math.vec3.new(3, 0, 5), width: 1.2, height: 1.5, sillHeight: 0.9, }) ```"
   },
   {
     "path": "design.create.referenceLines",
@@ -4970,7 +4497,7 @@
       "Make a basement slab that extrudes downward",
       "Give this room outline a 6 inch slab\n\n# Example\n```ts\nconst rect = await snaptrude.core.geom.create.profileRect(12, 10)\nconst contour = await snaptrude.core.geom.create.contourFromProfile(rect)\nconst slab = await snaptrude.design.create.slab(contour, 0.15, \"down\", \"Plinth\")\n```"
     ],
-    "argsType": "| [\n          contour: ContourHandle,\n          thickness: number,\n          direction?: \"up\" | \"down\",\n          slabType?: PluginSlabType,\n        ]\n      | [contour: ContourHandle, options: PluginFamilySlabOptions]",
+    "argsType": "ContourHandle",
     "resultType": "ComponentHandle"
   },
   {
@@ -5032,54 +4559,20 @@
     "argsType": "PluginStaircasePreset",
     "resultType": "ComponentHandle"
   },
-  {
-    "path": "design.create.void",
-    "namespace": "design.create",
-    "summary": "Cut a **void** — a hole, opening or shaft — through an existing FLAT slab, floor, roof or ceiling. The void is a selectable child object of its host (the \"Void\" of the Draw Void tool). It always cuts the full host thickness. It can be moved with `design.transform.move` (a move that would leave the host is shortened without a report) and removed with `design.delete.entities`; to resize, delete it and cut a new one (`design.update.space` refuses a void).",
-    "examplePrompts": [
-      "Cut a hole in this slab",
-      "Add a 1.2m by 2.4m stair opening in the first-floor slab",
-      "Make a 600 x 600 service penetration in the floor for the riser",
-      "Put a skylight opening through the roof",
-      "Cut a round 1m duct hole in the slab",
-      "Make a cut-out in the ceiling for the light well",
-      "Add a double-height atrium void in the level 2 floor"
-    ],
-    "argsType": "ComponentHandle",
-    "resultType": "ComponentHandle",
-    "performance": "Single-void creator. For MORE THAN ONE void, call `design.create.voids(items[])`: one host round-trip, ONE undo entry, one cut per host."
-  },
-  {
-    "path": "design.create.voids",
-    "namespace": "design.create",
-    "summary": "Cut **many voids** (holes, openings, shafts) through slabs, floors, roofs and ceilings in one undoable operation (bulk plural of {@linkcode void}). Items may share a host or use different hosts — one shaft outline on every storey's slab AND floor is one call. Validate-all-or-throw: one item whose host does not contain the outline rejects the whole batch, so pass only the hosts that contain it; `details.itemIndex` names the failing item (for two overlapping items of the batch, the earlier one). At most 50 voids per host and 200 in all per call. Same outline rules as {@linkcode void}: plan outline, 25.4 mm (0.1 SU) clearance, floor AND slab are separate hosts. Call it as `snaptrude.design.create.voids(...)`.",
-    "examplePrompts": [
-      "Cut a lift shaft through every floor slab of the core",
-      "Cut a 2m x 2m shaft through all the slabs at this location",
-      "Make stair openings in all the floors above the staircases",
-      "Make holes in the roof for these three skylights",
-      "Cut openings in each storey's slab matching this outline",
-      "Punch the same riser penetration through every floor at once"
-    ],
-    "argsType": "PluginCreateVoidItem[]",
-    "resultType": "ComponentHandle[]",
-    "performance": "ONE host round-trip, ONE undo entry, ONE cut per host. Never call `void` in a loop. Runs synchronously on the main thread: 50 voids on one host take about 1 s, and the time grows with the number of hosts (caps: 50 per host, 200 per call)."
-  },
   {
     "path": "design.create.wallRuns",
     "namespace": "design.create",
-    "summary": "Create **many wall runs** in one undoable operation (bulk plural of {@linkcode walls}). Each item is one full run — a wall per curve in that item's profile chain, mitred at shared endpoints. Junctions resolve within a run, not between runs. Each item carries its own dimensions, `wallType` and `storey`, so a single call can build a whole floor plate or several storeys at once. Per-curve `topProfiles` make raked or gabled walls (see {@linkcode PluginWallTopProfile}). Validate-all-or-throw; one command.",
+    "summary": "Create **many wall runs** in one undoable operation (bulk plural of {@linkcode walls}). Each item is one full run — a wall per curve in that item's profile chain, mitred at shared endpoints. Junctions resolve within a run, not between runs. Each item carries its own dimensions, `wallType` and `storey`, so a single call can build a whole floor plate or several storeys at once. Validate-all-or-throw; one command.",
     "examplePrompts": [
       "Draw all the walls of this floor plan at once",
       "Build every room's perimeter in one operation",
       "Bulk create wall runs from these centerlines",
       "Create the walls for both storeys in a single undo step",
-      "Turn these polylines into 200mm brick walls together",
-      "Import these raked walls with their top profiles in one go"
+      "Turn these polylines into 200mm brick walls together"
     ],
     "argsType": "PluginCreateWallRunItem[]",
     "resultType": "ComponentHandle[][]",
-    "performance": "Bulk creator — the whole batch is ONE host round-trip and ONE undo entry. Always prefer this over calling `design.create.walls` in a loop: build the full `items[]` array first (all profiles up front), then make one call. # Example ```ts const v = snaptrude.core.math.vec3 const ground = await snaptrude.core.geom.create.profileFromLinePoints([ await v.new(0, 0, 0), await v.new(8, 0, 0), await v.new(8, 0, 6), ]) const upper = await snaptrude.core.geom.create.profileFromLinePoints([ await v.new(0, 0, 0), await v.new(8, 0, 0), ]) const [groundWalls, upperWalls] = await snaptrude.design.create.wallRuns([ { profile: ground, height: 3, thickness: 0.2 }, { profile: upper, height: 3, storey: 2 }, // one gable wall: 3m at both ends, 5m ridge in the middle { profile: upper, thickness: 0.2, storey: 3, topProfiles: [[{ along: 0, height: 3 }, { along: 0.5, height: 5 }, { along: 1, height: 3 }]] }, ]) console.log(groundWalls.length, \"walls on the ground floor\") ```"
+    "performance": "Bulk creator — the whole batch is ONE host round-trip and ONE undo entry. Always prefer this over calling `design.create.walls` in a loop: build the full `items[]` array first (all profiles up front), then make one call. # Example ```ts const v = snaptrude.core.math.vec3 const ground = await snaptrude.core.geom.create.profileFromLinePoints([ await v.new(0, 0, 0), await v.new(8, 0, 0), await v.new(8, 0, 6), ]) const upper = await snaptrude.core.geom.create.profileFromLinePoints([ await v.new(0, 0, 0), await v.new(8, 0, 0), ]) const [groundWalls, upperWalls] = await snaptrude.design.create.wallRuns([ { profile: ground, height: 3, thickness: 0.2 }, { profile: upper, height: 3, storey: 2 }, ]) console.log(groundWalls.length, \"walls on the ground floor\") ```"
   },
   {
     "path": "design.create.walls",
@@ -5092,10 +4585,7 @@
       "Turn this polyline sketch into walls",
       "Add walls with mitred corners along the path",
       "Draw brick walls with plaster along this outline",
-      "Build the perimeter in exposed concrete walls",
-      "Create a raked wall that slopes from 3m to 5m",
-      "Build a gable end wall with the ridge in the middle",
-      "Draw a wall with a sloped top edge\n\n# Example\n```ts\nconst v = snaptrude.core.math.vec3\nconst centerlines = await snaptrude.core.geom.create.profileFromLinePoints([\nawait v.new(0, 0, 0),\nawait v.new(8, 0, 0),\nawait v.new(8, 0, 6),\n])\nconst walls = await snaptrude.design.create.walls(centerlines, 3, 0.2)\n// …built as a specific wall type (layers/material/thickness from the type):\nconst [brick] = await snaptrude.design.types.list(\"wall\")\nconst brickWalls = await snaptrude.design.create.walls(\ncenterlines, 3, undefined, brick.label,\n)\n// …a raked wall (3m at the start, 5m at the end) on a single centerline:\nconst run = await snaptrude.core.geom.create.profileFromCurves([\nawait snaptrude.core.geom.create.line(await v.new(0, 0, 10), await v.new(8, 0, 10)),\n])\nconst [raked] = await snaptrude.design.create.walls(run, undefined, 0.2, undefined, undefined, [\n[{ along: 0, height: 3 }, { along: 1, height: 5 }],\n])\n```"
+      "Build the perimeter in exposed concrete walls\n\n# Example\n```ts\nconst v = snaptrude.core.math.vec3\nconst centerlines = await snaptrude.core.geom.create.profileFromLinePoints([\nawait v.new(0, 0, 0),\nawait v.new(8, 0, 0),\nawait v.new(8, 0, 6),\n])\nconst walls = await snaptrude.design.create.walls(centerlines, 3, 0.2)\n// …built as a specific wall type (layers/material/thickness from the type):\nconst [brick] = await snaptrude.design.types.list(\"wall\")\nconst brickWalls = await snaptrude.design.create.walls(\ncenterlines, 3, undefined, brick.label,\n)\n```"
     ],
     "argsType": "ProfileHandle",
     "resultType": "ComponentHandle[]",
@@ -5104,7 +4594,7 @@
   {
     "path": "design.create.window",
     "namespace": "design.create",
-    "summary": "Place a parametric **window** family into a host wall.",
+    "summary": "Place a **window** from the catalog into a host wall.",
     "examplePrompts": [
       "Add a window to this wall here",
       "Place a casement window on the selected wall",
@@ -5120,17 +4610,17 @@
   {
     "path": "design.create.windows",
     "namespace": "design.create",
-    "summary": "Place **many windows** into host walls in one undoable operation (bulk plural of {@linkcode window}). Each item carries its own family id, host wall, world position, and optional `facing`, `label`, `width`, `height` and `sillHeight` — the same fields as a `\"window\"` {@linkcode PluginDesignCreateOpeningOptions}. `sillHeight` is measured from the host wall base to the BOTTOM of the window. Validate-all-or-throw; one command.",
+    "summary": "Place **many windows** into host walls in one undoable operation (bulk plural of {@linkcode window}). Each item carries its own catalog id, host wall, world position, and optional `facing`, `label`, `width`, `height` and `sillHeight` — the same fields as a `\"window\"` {@linkcode PluginDesignCreateOpeningOptions}. `sillHeight` is measured from the host wall base to the BOTTOM of the window. Validate-all-or-throw; one command.",
     "examplePrompts": [
       "Add windows along this whole facade at once",
       "Place a window in every bedroom in one operation",
       "Bulk add the windows from this schedule",
       "Put four windows on this wall in a single undo step",
-      "Add all the windows with a 0.9m sill height together\n\nA width/height (top-level, or under the family's own keys in `values`) on a family that\ntakes its size from its Type while Custom Sizes is off is never dropped: the Type within\n25 mm is chosen, else Custom Sizes is turned on and that size is built, leaving the Type\nlabel stale. `design.windows.checkPlacement` reports which as `sizing`; `customSizes: \"No\"`\nwith a size no Type matches is refused."
+      "Add all the windows with a 0.9m sill height together"
     ],
     "argsType": "PluginCreateWindowItem[]",
     "resultType": "ComponentHandle[]",
-    "performance": "Bulk creator — the whole batch is ONE host round-trip and ONE undo entry. Always prefer this over calling `design.create.window` in a loop: build the full `items[]` array first (all host walls and points up front), then make one call. # Example ```ts const v = snaptrude.core.math.vec3 const [wall] = await snaptrude.design.query.listWalls({ isSelected: true }) const [casement] = await snaptrude.design.windows.listCatalog() const placed = await snaptrude.design.create.windows([ { familyId: casement.id, hostWall: wall, position: await v.new(2, 0, 5), values: { sill: \"900mm\" } }, { familyId: casement.id, hostWall: wall, position: await v.new(5, 0, 5), values: { sill: \"900mm\" } }, ]) const currentWall = await snaptrude.design.query.getHost(placed[0]) ```"
+    "performance": "Bulk creator — the whole batch is ONE host round-trip and ONE undo entry, and each distinct catalog source loads once. Always prefer this over calling `design.create.window` in a loop: build the full `items[]` array first (all host walls and points up front), then make one call. # Example ```ts const v = snaptrude.core.math.vec3 const [wall] = await snaptrude.design.query.listWalls({ isSelected: true }) const [casement] = await snaptrude.design.windows.listCatalog() const placed = await snaptrude.design.create.windows([ { catalogId: casement.id, hostWall: wall, position: await v.new(2, 0, 5), sillHeight: 0.9 }, { catalogId: casement.id, hostWall: wall, position: await v.new(5, 0, 5), sillHeight: 0.9 }, ]) const currentWall = await snaptrude.design.query.getHost(placed[0]) ```"
   },
   {
     "path": "design.delete.entities",
@@ -5141,8 +4631,7 @@
       "Remove these walls from the model",
       "Get rid of this mass entirely",
       "Delete all the furniture I picked",
-      "Remove the door and window I just created",
-      "Remove the void I cut in this slab"
+      "Remove the door and window I just created"
     ],
     "argsType": "ComponentHandle[]",
     "resultType": "PluginDesignChangeResult",
@@ -5224,16 +4713,6 @@
     "resultType": "PluginDimensionsChangeResult",
     "performance": "Array API — one host round-trip and one undo entry for the whole set. # Example ```ts const dims = snaptrude.design.dimensions const hidden = await dims.list({ isHidden: true }) await dims.show(hidden.map((d) => d.id)) ```"
   },
-  {
-    "path": "design.doors.checkPlacement",
-    "namespace": "design.doors",
-    "summary": "Trial the native host fit and geometry rebuild, then restore the model without publishing commands. The first result uses the creation options; subsequent results use candidateWidths in input order. Widths are authored parameters, not physical envelopes or a guaranteed maximum width. No catalog save, history entry or model persistence occurs. Rerun after model edits. A failed fit leaves cut unverified. Family-host cuts are also unverified: their rebuild cannot supply a reversible, authoritative trial result. Material clearance checks evaluated parts against physical neighbours across hosts. The intended host uses native fit/cut checks. Creation repeats clearance immediately before placement; this report grants no later approval. Editing permission is required; locked hosts and an active opening tool reject. It does not say which room the door opens into: read `opensInto` from `design.validation.access()` after placement (see {@linkcode getSwingDirection}). A requested width/height on a family sized by its Type (Custom Sizes off) picks the Type within 25 mm, else turns Custom Sizes on; each result's `sizing` says which. Creation (`design.create.door(s)`) applies the same rule, so the size you pass is the size built.",
-    "examplePrompts": [
-      "Check which door widths fit this host without placing a door"
-    ],
-    "argsType": "PluginOpeningPlacementArgs",
-    "resultType": "PluginOpeningPlacementResult"
-  },
   {
     "path": "design.doors.exists",
     "namespace": "design.doors",
@@ -5263,7 +4742,7 @@
   {
     "path": "design.doors.getDimensions",
     "namespace": "design.doors",
-    "summary": "Get evaluated opening width/height and host thickness, in Snaptrude units. The opening can include allowances beyond the width/height input parameters.",
+    "summary": "Get a door's full dimensions in one call — width along the wall, vertical height, and thickness through the wall — measured in the door's local oriented space. Parity with {@linkcode PluginDesignWindowsApi.getDimensions}.",
     "examplePrompts": [
       "What are the dimensions of this door?",
       "How big is the selected door?",
@@ -5302,7 +4781,7 @@
   {
     "path": "design.doors.getSupportFloor",
     "namespace": "design.doors",
-    "summary": "Returns null for recipe doors. Room floors own doorway infill; there is no separate support-floor entity.",
+    "summary": "Get the floor a door is hosted on — the storey/level component that supports the door.",
     "examplePrompts": [
       "Which floor is this door on?",
       "What storey does the selected door belong to?",
@@ -5315,13 +4794,12 @@
   {
     "path": "design.doors.getSwingDirection",
     "namespace": "design.doors",
-    "summary": "Read the saved hand parameter. left means local -X; right means local +X. Returns null when the recipe does not declare that control.",
+    "summary": "Get a door's swing (hinge) handedness. Stand on the side the door swings open to, facing the door: `'left'` when the hinged jamb is on your left, `'right'` when it is on your right. Derived from the placed mesh's orientation (the same reflection `mirror` and the `hinge` placement option apply), not a persisted field.",
     "examplePrompts": [
       "Which way does this door swing?",
       "Is the selected door left-handed or right-handed?",
       "Check the hinge side of this door",
-      "Does the entrance door open to the left or the right?",
-      "Which room does this door open into?\n\n# Example\n```ts\nconst [door] = await snaptrude.design.query.listDoors({ isSelected: true })\nconst swing = await snaptrude.design.doors.getSwingDirection(door)\nif (swing) console.log(\"opens as a\", swing, \"hand door\")\n// Which room it opens into\nconst { topology } = await snaptrude.design.validation.access()\nconst side = topology.rooms.flatMap((r) => r.doors).find((d) => d.door === door)?.opensInto\n```"
+      "Does the entrance door open to the left or the right?\n\n# Example\n```ts\nconst [door] = await snaptrude.design.query.listDoors({ isSelected: true })\nconst swing = await snaptrude.design.doors.getSwingDirection(door)\nif (swing) console.log(\"opens as a\", swing, \"hand door\")\n```"
     ],
     "argsType": "ComponentHandle",
     "resultType": "\"left\" | \"right\" | null"
@@ -5381,7 +4859,7 @@
   {
     "path": "design.doors.mirror",
     "namespace": "design.doors",
-    "summary": "Change authored controls in one undo step: x (default) toggles swing front/back; z toggles hand left/right. The recipe must declare these enums. Axis y rejects. No mesh reflection occurs. Recipes use outputs.swingSide (1 or -1) for the adjoining room's floor ownership. A door between two room floors requires this output; a missing or invalid report rejects the cut. The same side decides `opensInto` in `design.validation.access()`; read it there to confirm which room the door now opens into.",
+    "summary": "Mirror a door about its own axes. `'x'` (default) flips the swing side — the door opens to the other side of the wall; `'z'` swaps the hinged jamb (left-hand ↔ right-hand, same swing side); `'y'` turns it upside down. Undoable as a single command.",
     "examplePrompts": [
       "Flip this door's swing",
       "Mirror the selected door",
@@ -5432,46 +4910,6 @@
     "argsType": "ComponentHandle",
     "resultType": "OffsetSplitOutcome"
   },
-  {
-    "path": "design.electrical.context",
-    "namespace": "design.electrical",
-    "summary": "Read the active proposal's architectural context before authoring. Keep one revision across pages.",
-    "examplePrompts": [],
-    "argsType": "z.input<typeof NetworkContextArgs>",
-    "resultType": "NetworkContextResult"
-  },
-  {
-    "path": "design.electrical.create",
-    "namespace": "design.electrical",
-    "summary": "Construct each node on its authored storey, with one undo command and queued project persistence. Networks can span storeys. Reuse requestId on retry; components returns the durable node mapping. Coordinates are world millimetres, Y-up; rotations are degrees. No engineering rules are inferred. Throws for stale architecture, invalid references/geometry or conflicting retries.",
-    "examplePrompts": [],
-    "argsType": "z.input<typeof NetworkCreateArgs>",
-    "resultType": "NetworkCreateResult"
-  },
-  {
-    "path": "design.electrical.get",
-    "namespace": "design.electrical",
-    "summary": "Read one saved graph in the active proposal; null on miss. IDs are durable, not worker handles.",
-    "examplePrompts": [],
-    "argsType": "z.input<typeof NetworkGetArgs>",
-    "resultType": "SavedNetworkGraph | null"
-  },
-  {
-    "path": "design.electrical.query",
-    "namespace": "design.electrical",
-    "summary": "Read bounded authored topology in graph revision. Crossings do not connect. No clash/compliance claims.",
-    "examplePrompts": [],
-    "argsType": "z.input<typeof NetworkQueryArgs>",
-    "resultType": "NetworkQueryResult"
-  },
-  {
-    "path": "design.electrical.validate",
-    "namespace": "design.electrical",
-    "summary": "Validate authored JSON, pinned families and recipe evaluation without placing or saving anything. This does not build kernel meshes or certify engineering/code compliance.",
-    "examplePrompts": [],
-    "argsType": "z.input<typeof NetworkValidateArgs>",
-    "resultType": "NetworkValidation"
-  },
   {
     "path": "design.erase.edge",
     "namespace": "design.erase",
@@ -5499,177 +4937,6 @@
     "argsType": "PluginDesignListErasableEdgesArgs",
     "resultType": "ErasableEdgeRef[]"
   },
-  {
-    "path": "design.family.create",
-    "namespace": "design.family",
-    "summary": "Save the prepared bundle to the library: the open project's team library in a team project, else the user's personal library. `teamId` picks another team, and `null` the personal library. {@linkcode PluginDesignFamilyApi.place} already saves generic components. Hosted doors/windows save without placement; they need a wall and position through `design.create.door` / `design.create.window`. For a non-hosted family with no placed instance, saving also drops one standalone sample at the current view centre on the active storey (`placed: true`). This includes architectural families: the sample does not assign a family to a native host.",
-    "examplePrompts": [
-      "Save this as a family called Vertical Louvre",
-      "Add it to my library\n\n# Example\n```ts\nconst { definitionId } = await snaptrude.design.family.create({ name: \"Louvre Screen\" })\n```"
-    ],
-    "argsType": "PluginDesignFamilyCreateArgs",
-    "resultType": "PluginFamilyCreateResult"
-  },
-  {
-    "path": "design.family.delete",
-    "namespace": "design.family",
-    "summary": "Remove a family from the library: its catalog row is archived, so it leaves the Families panel. Placed instances are untouched — in this project and every other — because archived pins keep resolving. Pass `instances: true` to ALSO delete this project's instances in one undoable command; do that only when the user asks for the instances to go.",
-    "examplePrompts": [
-      "Delete the Louvre Screen family from my library",
-      "Get rid of that bollard and every copy of it in here\n\n# Example\n```ts\nawait snaptrude.design.family.delete({ id: \"revit:steel-bollard~bef047\" })\nawait snaptrude.design.family.delete({ id: \"revit:steel-bollard~bef047\", instances: true })\n```"
-    ],
-    "argsType": "PluginDesignFamilyDeleteArgs | string",
-    "resultType": "PluginFamilyDeleteResult"
-  },
-  {
-    "path": "design.family.duplicate",
-    "namespace": "design.family",
-    "summary": "Assign one placed recipe family or parametric door/window to a new project family. Does not copy geometry, publish a library or alter native system families. Subsequent authored parameter edits no longer affect the original family. Undo restores the original family identity and name together. This is project-only. If the user requests both an independent project family and a library asset, call duplicate first, then saveToLibrary with the same component. If they request a library save later, call saveToLibrary alone; do not duplicate again.",
-    "examplePrompts": [],
-    "argsType": "PluginDesignFamilyDuplicateArgs",
-    "resultType": "PluginFamilyDuplicateResult"
-  },
-  {
-    "path": "design.family.flex",
-    "namespace": "design.family",
-    "summary": "Re-run the prepared family's recipe at new parameter values.",
-    "examplePrompts": [
-      "Change it to 6 bays",
-      "Show me what happens with 20 blades\n\n# Example\n```ts\nconst { changed } = await snaptrude.design.family.flex({ values: { bays: 6 } })\nconsole.log(`removed ${changed.removed}, rebuilt ${changed.rebuilt}`)\n```"
-    ],
-    "argsType": "PluginDesignFamilyFlexArgs",
-    "resultType": "PluginFamilyFlexResult"
-  },
-  {
-    "path": "design.family.get",
-    "namespace": "design.family",
-    "summary": "A family's spec bundle: the prepared draft's, or — to CHANGE a saved family — that family's recipe, opened as the new draft.",
-    "examplePrompts": [
-      "Make the chairs I placed 50 mm wider",
-      "Change the Louvre Screen family so its blades are deeper\n\n# Example\n```ts\nconst draft = await snaptrude.design.family.get()\nconst family = await snaptrude.design.family.get({ component })\n// family.editing → { familyId, version, name, library }\n```"
-    ],
-    "argsType": "PluginDesignFamilyGetArgs | string",
-    "resultType": "PluginFamilyGetResult | null"
-  },
-  {
-    "path": "design.family.getDefinition",
-    "namespace": "design.family",
-    "summary": "Read one saved catalog definition without opening a draft or placing geometry. Both id and version are required. The catalog checks access on every read. Length defaults and bounds are in mm, ready for network graph overrides; angle parameters retain degrees, identified by each parameter's unit. existing getParameters/place/setParameters continue to use Snaptrude units. Defaults include current catalog overrides, which can change without a new version. No scene, registry, history, or persistence state is changed. Missing/inaccessible pins and invalid recipes fail; no latest-version fallback. This metadata does not certify connectors or engineering compatibility.",
-    "examplePrompts": [],
-    "argsType": "PluginDesignFamilyGetDefinitionArgs",
-    "resultType": "PluginFamilyDefinition"
-  },
-  {
-    "path": "design.family.getExamples",
-    "namespace": "design.family",
-    "summary": "Worked example families to learn from: real, tested bundles by discipline (architecture, structure, MEP, furniture). With no `id`, returns the catalogue — each example's id, label, discipline and the patterns it teaches — filtered by `discipline` / `tag` when given. With an `id`, returns that example's full bundle. Fetch the one closest to the task before authoring and borrow its patterns; examples are patterns to combine, not templates to copy whole.",
-    "examplePrompts": [
-      "Show me an example of a structural family",
-      "How is a hosted door family written?\n\n# Example\n```ts\nconst list = await snaptrude.design.family.getExamples({ discipline: \"mep\" })\nconst ex = await snaptrude.design.family.getExamples({ id: list[0].id })\n```"
-    ],
-    "argsType": "PluginDesignFamilyGetExamplesArgs | string",
-    "resultType": "PluginFamilyExampleSummary[] | PluginFamilyExample"
-  },
-  {
-    "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",
-    "summary": "Read the family-spec DSL reference: grammar, the op table, the expression whitelist, the coordinate convention, the repair contract, and a worked example taken from a registered family.",
-    "examplePrompts": [
-      "How do I write a parametric family spec?",
-      "Show me the family DSL\n\n# Example\n```ts\nconst { reference } = await snaptrude.design.family.getReference()\n```"
-    ],
-    "argsType": "PluginDesignFamilyGetReferenceArgs | PluginFamilyReferenceSection",
-    "resultType": "PluginFamilyReference"
-  },
-  {
-    "path": "design.family.getTemplate",
-    "namespace": "design.family",
-    "summary": "Get a validated starter recipe for a door or window, with an opening contract, host wall-thickness binding and role-named parts. Edit profiles, panels, glazing, hardware and materials while preserving the contract. Use `prepare` / `flex` to check the recipe, then `create` to save it and `design.create.door(familyId, hostWall, position, { version, values }, facing)` (or `window`) to place it. Edit the resulting ParametricComponent through `getParameters` / `setParameters`, not a separate opening API.",
-    "examplePrompts": [],
-    "argsType": "PluginDesignFamilyGetTemplateArgs",
-    "resultType": "PluginFamilyTemplateResult"
-  },
-  {
-    "path": "design.family.list",
-    "namespace": "design.family",
-    "summary": "Every available parametric family, merging the session registry and catalog.",
-    "examplePrompts": [
-      "What families are available?\n\n# Example\n```ts\nconst families = await snaptrude.design.family.list()\n```"
-    ],
-    "argsType": "PluginDesignFamilyListArgs & { compact: true }",
-    "resultType": "string[]"
-  },
-  {
-    "path": "design.family.list",
-    "namespace": "design.family",
-    "summary": "",
-    "examplePrompts": [],
-    "argsType": "PluginDesignFamilyListArgs & { compact?: false }",
-    "resultType": "PluginFamilySummary[]"
-  },
-  {
-    "path": "design.family.list",
-    "namespace": "design.family",
-    "summary": "",
-    "examplePrompts": [],
-    "argsType": "PluginDesignFamilyListArgs",
-    "resultType": "PluginFamilySummary[] | string[]"
-  },
-  {
-    "path": "design.family.place",
-    "namespace": "design.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",
-      "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// on the first floor — position.y is an offset above storey 2's base\nawait snaptrude.design.family.place({ id: familyId, position: { x: 4, y: 0, z: 0 }, storey: 2 })\n\n// interactive — the user clicks\nawait snaptrude.design.family.place()\n\n// hosted — a door in a wall, near a point along it\nawait snaptrude.design.family.place({ id: doorId, host: wall, position: { x: 3, y: 0, z: 0 } })\n```"
-    ],
-    "argsType": "PluginDesignFamilyPlaceArgs",
-    "resultType": "PluginFamilyPlaceResult"
-  },
-  {
-    "path": "design.family.prepare",
-    "namespace": "design.family",
-    "summary": "Validate, compile and preview a family spec. Nothing is committed to the model or the library — call {@linkcode PluginDesignFamilyApi.place} to put it in the model, which also saves it.",
-    "examplePrompts": [
-      "Make a louvre screen with adjustable blade count and tilt",
-      "Design a curtain wall panel family with 8 bays",
-      "Create a railing family I can adjust",
-      "Make a pendant lamp family with a domed shade I can resize\n\n# Example\n```ts\nconst r = await snaptrude.design.family.prepare({ bundle })\nif (!r.ok) console.error(r.errors[0].path, r.errors[0].message)\n```"
-    ],
-    "argsType": "PluginDesignFamilyPrepareArgs",
-    "resultType": "PluginFamilyPrepareResult"
-  },
-  {
-    "path": "design.family.saveToLibrary",
-    "namespace": "design.family",
-    "summary": "Save a placed recipe family or parametric door/window's current authored configuration as a separate library asset. Does not place geometry, reassign any model component, overwrite the original library asset or publish publicly.",
-    "examplePrompts": [],
-    "argsType": "PluginDesignFamilySaveToLibraryArgs",
-    "resultType": "PluginFamilySaveToLibraryResult"
-  },
-  {
-    "path": "design.family.setParameters",
-    "namespace": "design.family",
-    "summary": "Change authored parameters across the selected component's project family. Use `duplicate({ component, name })` first for an independent project variant. This never publishes or modifies a library. Only changed authored values propagate; placement, hosting, links and relations remain local. A locked family member or host refuses a shared edit. Mixed requests containing links, relations and parameters are not one atomic transaction.",
-    "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 } })\nawait snaptrude.design.family.setParameters({ component, children: { chair: { width: \"380mm\" } } })\nawait snaptrude.design.family.setParameters({\ncomponent: railing,\nlinks: { steps: { from: stair, expr: \"steps\" }, side: { from: stair, expr: \"width - 40mm\" } },\n})\nawait snaptrude.design.family.setParameters({\ncomponent: post,\nrelations: { add: [{ kind: \"attach\", side: \"top\", to: slab, bind: { height: \"reach\" } }] },\n})\n```"
-    ],
-    "argsType": "PluginDesignFamilySetParametersArgs",
-    "resultType": "PluginFamilyInstanceParameters"
-  },
   {
     "path": "design.furniture.exists",
     "namespace": "design.furniture",
@@ -5761,51 +5028,6 @@
     "argsType": "ComponentHandle",
     "resultType": "PluginDesignChangeResult"
   },
-  {
-    "path": "design.grids.addLine",
-    "namespace": "design.grids",
-    "summary": "Insert a parallel grid line into a wing at an explicit position along the wing's spacing axis (Snaptrude units, wing-local — line 0's position can be read from its curve). Sibling lines do not shift; the wing's tag sequence is renumbered. Undoable.",
-    "examplePrompts": [
-      "Add a grid line between lines 2 and 3",
-      "Insert an extra grid line 4 metres from line A\n\n# Example\n```ts\nawait snaptrude.design.grids.addLine(grid, 0, 12.5)\n```"
-    ],
-    "argsType": "ComponentHandle",
-    "resultType": "boolean"
-  },
-  {
-    "path": "design.grids.removeLines",
-    "namespace": "design.grids",
-    "summary": "Remove grid lines by positional address, as ONE undoable step. With `tagPolicy: \"rewrite\"` (default) each affected wing renumbers its tag sequence; `\"preserve\"` keeps surviving tags unchanged. A wing emptied of lines is dropped from the group.",
-    "examplePrompts": [
-      "Delete grid line B",
-      "Remove the last two lines of this grid without renumbering\n\n# Example\n```ts\nawait snaptrude.design.grids.removeLines(grid, [{ wing: 0, line: 2 }], \"preserve\")\n```"
-    ],
-    "argsType": "ComponentHandle",
-    "resultType": "boolean"
-  },
-  {
-    "path": "design.grids.updateLines",
-    "namespace": "design.grids",
-    "summary": "Update one or more **lines** of a grid with sparse per-line entries — `tag`, `distanceToPrevious`/`distanceToNext` (typed distance to the neighbour on that side; mutually exclusive), `props` (per-line style overrides), and `visible: false` (hide). Every change routes through the exact setters the native panel uses — each changed field commits its own undoable command, identical to editing that field in the panel.",
-    "examplePrompts": [
-      "Rename grid line 2 to \"B\"",
-      "Move this grid line 4 metres from its neighbour",
-      "Hide grid line 3 on this grid\n\n# Example\n```ts\nawait snaptrude.design.grids.updateLines(grid, [\n{ wing: 0, line: 1, tag: \"B\", distanceToPrevious: 4 },\n])\n```"
-    ],
-    "argsType": "ComponentHandle",
-    "resultType": "boolean"
-  },
-  {
-    "path": "design.grids.updateWings",
-    "namespace": "design.grids",
-    "summary": "Update one or more **wings** of a grid with sparse per-wing entries — `spacing` (uniform re-space), `count` (grow/truncate + tag renumber), `spanMin`/`spanMax` (family length handles). Every change routes through the exact setters the native panel uses — each changed field commits its own undoable command, identical to editing that field in the panel.",
-    "examplePrompts": [
-      "Change this grid's spacing to 8 metres",
-      "Make this grid 10 by 12 lines\n\n# Example\n```ts\nawait snaptrude.design.grids.updateWings(grid, [{ wing: 0, spacing: 8, count: 10 }])\n```"
-    ],
-    "argsType": "ComponentHandle",
-    "resultType": "boolean"
-  },
   {
     "path": "design.isAreaLocked",
     "namespace": "design",
@@ -6076,86 +5298,6 @@
     "argsType": "ComponentHandle",
     "resultType": "PluginMaterialResult"
   },
-  {
-    "path": "design.mechanical.context",
-    "namespace": "design.mechanical",
-    "summary": "Read the active proposal's architectural context before authoring. Keep one revision across pages.",
-    "examplePrompts": [],
-    "argsType": "z.input<typeof NetworkContextArgs>",
-    "resultType": "NetworkContextResult"
-  },
-  {
-    "path": "design.mechanical.create",
-    "namespace": "design.mechanical",
-    "summary": "Construct each node on its authored storey, with one undo command and queued project persistence. Networks can span storeys. Reuse requestId on retry; components returns the durable node mapping. Coordinates are world millimetres, Y-up; rotations are degrees. No engineering rules are inferred. Throws for stale architecture, invalid references/geometry or conflicting retries.",
-    "examplePrompts": [],
-    "argsType": "z.input<typeof NetworkCreateArgs>",
-    "resultType": "NetworkCreateResult"
-  },
-  {
-    "path": "design.mechanical.get",
-    "namespace": "design.mechanical",
-    "summary": "Read one saved graph in the active proposal; null on miss. IDs are durable, not worker handles.",
-    "examplePrompts": [],
-    "argsType": "z.input<typeof NetworkGetArgs>",
-    "resultType": "SavedNetworkGraph | null"
-  },
-  {
-    "path": "design.mechanical.query",
-    "namespace": "design.mechanical",
-    "summary": "Read bounded authored topology in graph revision. Crossings do not connect. No clash/compliance claims.",
-    "examplePrompts": [],
-    "argsType": "z.input<typeof NetworkQueryArgs>",
-    "resultType": "NetworkQueryResult"
-  },
-  {
-    "path": "design.mechanical.validate",
-    "namespace": "design.mechanical",
-    "summary": "Validate authored JSON, pinned families and recipe evaluation without placing or saving anything. This does not build kernel meshes or certify engineering/code compliance.",
-    "examplePrompts": [],
-    "argsType": "z.input<typeof NetworkValidateArgs>",
-    "resultType": "NetworkValidation"
-  },
-  {
-    "path": "design.plumbing.context",
-    "namespace": "design.plumbing",
-    "summary": "Read the active proposal's architectural context before authoring. Keep one revision across pages.",
-    "examplePrompts": [],
-    "argsType": "z.input<typeof NetworkContextArgs>",
-    "resultType": "NetworkContextResult"
-  },
-  {
-    "path": "design.plumbing.create",
-    "namespace": "design.plumbing",
-    "summary": "Construct each node on its authored storey, with one undo command and queued project persistence. Networks can span storeys. Reuse requestId on retry; components returns the durable node mapping. Coordinates are world millimetres, Y-up; rotations are degrees. No engineering rules are inferred. Throws for stale architecture, invalid references/geometry or conflicting retries.",
-    "examplePrompts": [],
-    "argsType": "z.input<typeof NetworkCreateArgs>",
-    "resultType": "NetworkCreateResult"
-  },
-  {
-    "path": "design.plumbing.get",
-    "namespace": "design.plumbing",
-    "summary": "Read one saved graph in the active proposal; null on miss. IDs are durable, not worker handles.",
-    "examplePrompts": [],
-    "argsType": "z.input<typeof NetworkGetArgs>",
-    "resultType": "SavedNetworkGraph | null"
-  },
-  {
-    "path": "design.plumbing.query",
-    "namespace": "design.plumbing",
-    "summary": "Read bounded authored topology in graph revision. Crossings do not connect. No clash/compliance claims.",
-    "examplePrompts": [],
-    "argsType": "z.input<typeof NetworkQueryArgs>",
-    "resultType": "NetworkQueryResult"
-  },
-  {
-    "path": "design.plumbing.validate",
-    "namespace": "design.plumbing",
-    "summary": "Validate authored JSON, pinned families and recipe evaluation without placing or saving anything. This does not build kernel meshes or certify engineering/code compliance.",
-    "examplePrompts": [],
-    "argsType": "z.input<typeof NetworkValidateArgs>",
-    "resultType": "NetworkValidation"
-  },
   {
     "path": "design.query.exists",
     "namespace": "design.query",
@@ -6189,7 +5331,6 @@
     "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"
@@ -6214,7 +5355,7 @@
   {
     "path": "design.query.geometry.getTriangulatedMeshes",
     "namespace": "design.query.geometry",
-    "summary": "Get the **triangulated render meshes** of scene components as plain, serializable arrays — flat world-space vertex `positions` (`[x0, y0, z0, x1, …]`) and triangle `indices` (three per triangle), one record per requested component. The result is `{ meshes }`, not a bare array — destructure it before iterating.",
+    "summary": "Get the **triangulated render meshes** of scene components as plain, serializable arrays — flat world-space vertex `positions` (`[x0, y0, z0, x1, …]`) and triangle `indices` (three per triangle), one record per requested component.",
     "examplePrompts": [
       "Export the selected masses as a triangle mesh",
       "Get the raw vertices and triangles of this wall in world coordinates",
@@ -6278,13 +5419,12 @@
   {
     "path": "design.query.getHost",
     "namespace": "design.query",
-    "summary": "Get an entity's host/parent entity (e.g. the wall a door is cut into, or the slab, floor, roof or ceiling a void is cut through).",
+    "summary": "Get an entity's host/parent entity (e.g. the wall a door is cut into).",
     "examplePrompts": [
       "Which wall is this door in?",
       "Find the parent of the selected window",
       "What is this element attached to?",
-      "Which wall hosts this window?",
-      "Which slab is this shaft in?\n\n# Example\n```ts\n// From a door up to its host wall, then measure the wall\nconst [door] = await snaptrude.design.query.listDoors({ isSelected: true })\nconst hostWall = door ? await snaptrude.design.query.getHost(door) : null\nif (hostWall) {\nconst m = await snaptrude.design.query.measure(hostWall)\nconsole.log(\"wall length:\", m?.length)\n}\n```"
+      "Which wall hosts this window?\n\n# Example\n```ts\n// From a door up to its host wall, then measure the wall\nconst [door] = await snaptrude.design.query.listDoors({ isSelected: true })\nconst hostWall = door ? await snaptrude.design.query.getHost(door) : null\nif (hostWall) {\nconst m = await snaptrude.design.query.measure(hostWall)\nconsole.log(\"wall length:\", m?.length)\n}\n```"
     ],
     "argsType": "ComponentHandle",
     "resultType": "ComponentHandle | null"
@@ -6302,19 +5442,6 @@
     "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",
@@ -6343,19 +5470,6 @@
     "argsType": "ComponentHandle",
     "resultType": "PluginStaircaseParams | null"
   },
-  {
-    "path": "design.query.grids.get",
-    "namespace": "design.query.grids",
-    "summary": "Get properties of a grid by its ID.",
-    "examplePrompts": [
-      "What is the spacing of this grid?",
-      "Read the grid line tags on this structural grid",
-      "Get the geometry of every line in this grid",
-      "Which storeys is this grid hidden on?\n\n# Example\n```ts\nconst [grid] = await snaptrude.design.query.listGrids()\nconst { wings } = await snaptrude.design.query.grids.get(grid, [\"wings\"])\n// wings[0].lines[0].curve is an opaque CurveHandle in world space;\n// read its coordinates via `snaptrude.core.geom.curve`.\n```"
-    ],
-    "argsType": "string",
-    "resultType": "PluginGridGetResult"
-  },
   {
     "path": "design.query.listBeams",
     "namespace": "design.query",
@@ -6398,13 +5512,12 @@
   {
     "path": "design.query.listChildren",
     "namespace": "design.query",
-    "summary": "List an entity's direct child entities — for example the doors and windows hosted in a wall, or the voids (holes, shafts, openings) cut in a slab, floor, roof or ceiling by `design.create.void`.",
+    "summary": "List an entity's direct child entities — for example the doors and windows hosted in a wall.",
     "examplePrompts": [
       "What's inside this wall — list its doors and windows",
       "Show the child elements of the selected object",
       "Which openings belong to this wall?",
-      "List everything nested under this mass",
-      "List all holes in this slab\n\n# Example\n```ts\n// Count the openings hosted in a wall, split by kind\nconst children = await snaptrude.design.query.listChildren(wall)\nlet doors = 0\nlet windows = 0\nfor (const child of children) {\nconst kind = await snaptrude.design.query.getEntityType(child)\nif (kind === \"door\") doors++\nif (kind === \"window\") windows++\n}\n```"
+      "List everything nested under this mass\n\n# Example\n```ts\n// Count the openings hosted in a wall, split by kind\nconst children = await snaptrude.design.query.listChildren(wall)\nlet doors = 0\nlet windows = 0\nfor (const child of children) {\nconst kind = await snaptrude.design.query.getEntityType(child)\nif (kind === \"door\") doors++\nif (kind === \"window\") windows++\n}\n```"
     ],
     "argsType": "ComponentHandle",
     "resultType": "ComponentHandle[]"
@@ -6475,19 +5588,6 @@
     "argsType": "PluginEntityFilter",
     "resultType": "ComponentHandle[]"
   },
-  {
-    "path": "design.query.listGrids",
-    "namespace": "design.query",
-    "summary": "List all the structural grids (grid groups) in the project, optionally filtered by storey, building, selection state, or region.",
-    "examplePrompts": [
-      "List all the structural grids in the model",
-      "How many grids are on the ground floor?",
-      "Show the grids on this storey",
-      "Which grids are currently selected?\n\n# Example\n```ts\nconst groundFloorGrids = await snaptrude.design.query.listGrids({ storeys: [1] })\n```"
-    ],
-    "argsType": "PluginEntityFilter",
-    "resultType": "ComponentHandle[]"
-  },
   {
     "path": "design.query.listMasses",
     "namespace": "design.query",
@@ -6580,14 +5680,6 @@
     "argsType": "PluginEntityFilter",
     "resultType": "ComponentHandle[]"
   },
-  {
-    "path": "design.query.listVoids",
-    "namespace": "design.query",
-    "summary": "List Void components, excluding masses and spaces. Voids cut their hosts. Use family queries for authored parametric families with a cut relationship.",
-    "examplePrompts": [],
-    "argsType": "PluginEntityFilter",
-    "resultType": "ComponentHandle[]"
-  },
   {
     "path": "design.query.listWalls",
     "namespace": "design.query",
@@ -6778,66 +5870,6 @@
     "argsType": "PluginSelectionFilter",
     "resultType": "PluginDesignChangeResult"
   },
-  {
-    "path": "design.text.create",
-    "namespace": "design.text",
-    "summary": "Place a text, or an annotation when `options.arrowhead` is given.",
-    "examplePrompts": [
-      "Label the living room \"LIVING\" on the plan",
-      "Add an annotation pointing at this column saying \"RCC 300x300\"",
-      "Write \"NORTH ENTRY\" in red bold text at the entrance on level 2\n\n# Example\n```ts\nconst { design, core } = snaptrude\nconst v = core.math.vec3\n// A plain label on storey 1.\nawait design.text.create(await v.new(10, 0, 20), \"LIVING\", { storey: 1 })\n// An annotation whose leader points at a wall corner.\nawait design.text.create(await v.new(30, 0, 40), \"Shear wall\", {\narrowhead: await v.new(22, 0, 32),\ncolor: \"#c62828\",\nfontStyle: \"Bold\",\n})\n```"
-    ],
-    "argsType": "Vec3Handle",
-    "resultType": "ComponentHandle"
-  },
-  {
-    "path": "design.text.get",
-    "namespace": "design.text",
-    "summary": "Read one text by handle.",
-    "examplePrompts": [
-      "What does this text say?",
-      "Read the annotation I just placed\n\n# Example\n```ts\nconst t = await snaptrude.design.text.get(handle)\nif (t?.leader) console.log(t.content, \"points at\", t.leader.arrowhead)\n```"
-    ],
-    "argsType": "ComponentHandle",
-    "resultType": "PluginText | null"
-  },
-  {
-    "path": "design.text.list",
-    "namespace": "design.text",
-    "summary": "List the texts and annotations of every building in the active design option as full records (each carries its `buildingId`).",
-    "examplePrompts": [
-      "List all the text labels on level 1",
-      "Which annotations are in this model?",
-      "Find the text that says \"LOBBY\""
-    ],
-    "argsType": "{\n    storeys?: number[]\n    kind?: PluginTextKind\n    isHidden?: boolean\n  }",
-    "resultType": "PluginText[]",
-    "performance": "Array read — one host round-trip returns every record. Filter in one call rather than calling `get` per text. # Example ```ts const texts = await snaptrude.design.text.list({ storeys: [1] }) const lobby = texts.find((t) => t.content === \"LOBBY\") ```"
-  },
-  {
-    "path": "design.text.setLeader",
-    "namespace": "design.text",
-    "summary": "Point a text's leader at a new place — the same edit as dragging an annotation's arrowhead with the Edit tool. Passing `null` removes the leader (the annotation becomes a plain text); giving a plain text an arrowhead turns it into an annotation. The text itself does not move. To move the text while its arrowhead stays put, move it with `design.transform.move`, then call this with the old `leader.arrowhead`.",
-    "examplePrompts": [
-      "Point this annotation at the door instead",
-      "Remove the leader from this label\n\n# Example\n```ts\nconst { design, core } = snaptrude\nawait design.text.setLeader(handle, await core.math.vec3.new(12, 0, 8))\n```"
-    ],
-    "argsType": "ComponentHandle",
-    "resultType": "PluginText"
-  },
-  {
-    "path": "design.text.update",
-    "namespace": "design.text",
-    "summary": "Change the words, colour or font of one or more texts — the same edit as the Properties panel. Fields left out keep each text's own value. A font style the (new) family does not have falls back to `\"Regular\"`, as in the panel. One undo entry for the whole batch.",
-    "examplePrompts": [
-      "Make all the room labels bold",
-      "Change this annotation to read \"Fire exit\"",
-      "Use Roboto in blue for every text on level 2"
-    ],
-    "argsType": "ComponentHandle[]",
-    "resultType": "PluginTextChangeResult",
-    "performance": "Array API — pass the whole set in one call (one host round-trip, one undo entry). Never loop this per text. # Example ```ts const text = snaptrude.design.text const level2 = await text.list({ storeys: [2] }) await text.update(level2.map((t) => t.id), { fontFamily: \"Roboto\", color: \"#1565c0\" }) ```"
-  },
   {
     "path": "design.transform.align",
     "namespace": "design.transform",
@@ -6901,14 +5933,14 @@
   {
     "path": "design.types.get",
     "namespace": "design.types",
-    "summary": "Get one building type by its legacy id or exact native wall pin — its labelled layer stack (each layer's role, thickness and material) plus the summed total thickness.",
+    "summary": "Get one building type by its `\"<kind>:<name>\"` id — its labelled layer stack (each layer's role, thickness and material) plus the summed total thickness.",
     "examplePrompts": [
       "What layers make up this wall type?",
       "Show the construction of the exposed-concrete wall",
       "What's the total thickness of this slab type?",
-      "Which materials are in this roof assembly?\n\n# Example\n```ts\nconst [first] = await snaptrude.design.types.list(\"wall\")\nconst type = await snaptrude.design.types.get(first.nativeFamily ?? first.id)\nif (type) for (const layer of type.layers) console.log(layer.name, layer.thickness)\n```"
+      "Which materials are in this roof assembly?\n\n# Example\n```ts\nconst [first] = await snaptrude.design.types.list(\"wall\")\nconst type = await snaptrude.design.types.get(first.id)\nif (type) for (const layer of type.layers) console.log(layer.name, layer.thickness)\n```"
     ],
-    "argsType": "PluginWallType",
+    "argsType": "string",
     "resultType": "PluginBuildingType | null"
   },
   {
@@ -6950,14 +5982,6 @@
     "argsType": "ComponentHandle[]",
     "resultType": "PluginDesignChangeResult"
   },
-  {
-    "path": "design.update.beam",
-    "namespace": "design.update",
-    "summary": "Replace a native beam family while preserving its authored axis. Values use mm/degrees.",
-    "examplePrompts": [],
-    "argsType": "ComponentHandle",
-    "resultType": "PluginDesignChangeResult"
-  },
   {
     "path": "design.update.buildableEnvelope",
     "namespace": "design.update",
@@ -6983,14 +6007,6 @@
     "argsType": "ComponentHandle",
     "resultType": "PluginDesignChangeResult"
   },
-  {
-    "path": "design.update.column",
-    "namespace": "design.update",
-    "summary": "Replace a native column family while preserving its authored axis. Values use mm/degrees.",
-    "examplePrompts": [],
-    "argsType": "ComponentHandle",
-    "resultType": "PluginDesignChangeResult"
-  },
   {
     "path": "design.update.floor",
     "namespace": "design.update",
@@ -7004,66 +6020,33 @@
     "resultType": "PluginDesignChangeResult"
   },
   {
-    "path": "design.update.grid",
+    "path": "design.update.roof",
     "namespace": "design.update",
-    "summary": "Update a structural grid's **group-level** fields with a sparse patch — default line styling, absolute angle, and per-storey 2D visibility. Only provided fields change. Wing- and line-level updates live on the grids entity family: {@linkcode PluginDesignGridsApi.updateWings} / {@linkcode PluginDesignGridsApi.updateLines}.",
+    "summary": "Edit a **roof's** thickness and/or overhang — the same commands the roof panel's Thickness field and Overhang slider drive (shares the slab-family machinery). Sparse: only the fields you provide change. Undoable. Both values are in **engine units** (the `design.doors.setWidth` convention); thickness must be `> 0`, overhang is an absolute offset (negative insets the roof) and re-applying the current overhang is a no-op.",
     "examplePrompts": [
-      "Rotate the grid to 45 degrees",
-      "Make this grid's lines dashed and grey",
-      "Hide this grid on storey 3's plan\n\n# Example\n```ts\nconst [grid] = await snaptrude.design.query.listGrids()\nawait snaptrude.design.update.grid(grid, { angle: 45, props: { style: \"DASHED\" } })\n```"
+      "Make this roof 300mm thick",
+      "Set the roof slab thickness to 250",
+      "Give the roof a 600 overhang",
+      "Pull the roof overhang back to 0\n\n# Example\n```ts\nconst [roof] = await snaptrude.design.query.listRoofs()\nawait snaptrude.design.update.roof(roof, { overhang: 600 })\n```"
     ],
     "argsType": "ComponentHandle",
-    "resultType": "boolean"
+    "resultType": "PluginDesignChangeResult"
   },
   {
-    "path": "design.update.parameters",
+    "path": "design.update.setBaseOffset",
     "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.",
+    "summary": "Set a component's **base offset** — its vertical distance above its own storey's base level. Moves the component so its base lands at `storeyBase + offset`, composed over the same command-backed move machinery as {@linkcode setElevation} (undoable, persisted, per-type invariants kept in sync). Use this instead of {@linkcode setElevation} when you want an offset relative to the storey rather than an absolute world height. `offset` is in **engine units** (the `design.doors.setWidth` convention); `0` sits the base flush with the storey base. Re-applying the current offset is a no-op.",
     "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```"
+      "Lift this element 300 above its floor",
+      "Set this staircase's base offset to 0",
+      "Raise the selected mass 500 off the storey base",
+      "Offset this slab 150 above the floor level\n\n# Example\n```ts\nconst [stair] = await snaptrude.design.query.listStaircases()\nawait snaptrude.design.update.setBaseOffset(stair, 0)\n```"
     ],
     "argsType": "ComponentHandle",
-    "resultType": "MassParametersRecord"
+    "resultType": "PluginDesignChangeResult"
   },
   {
-    "path": "design.update.referenceLine",
-    "namespace": "design.update",
-    "summary": "Apply a project style through the native reference-line property command. One saved undo step; no selection or tool preference changes. Saves the legacy thickness/mode mirror too. Requires Paper Pens and an editable line in the current proposal. A no-op creates no history entry.",
-    "examplePrompts": [],
-    "argsType": "string",
-    "resultType": "PluginDesignUpdateReferenceLineResult"
-  },
-  {
-    "path": "design.update.roof",
-    "namespace": "design.update",
-    "summary": "Edit a **roof's** thickness and/or overhang — the same commands the roof panel's Thickness field and Overhang slider drive (shares the slab-family machinery). Sparse: only the fields you provide change. Undoable. Both values are in **engine units** (the `design.doors.setWidth` convention); thickness must be `> 0`, overhang is an absolute offset (negative insets the roof) and re-applying the current overhang is a no-op.",
-    "examplePrompts": [
-      "Make this roof 300mm thick",
-      "Set the roof slab thickness to 250",
-      "Give the roof a 600 overhang",
-      "Pull the roof overhang back to 0\n\n# Example\n```ts\nconst [roof] = await snaptrude.design.query.listRoofs()\nawait snaptrude.design.update.roof(roof, { overhang: 600 })\n```"
-    ],
-    "argsType": "ComponentHandle",
-    "resultType": "PluginDesignChangeResult"
-  },
-  {
-    "path": "design.update.setBaseOffset",
-    "namespace": "design.update",
-    "summary": "Set a component's **base offset** — its vertical distance above its own storey's base level. Moves the component so its base lands at `storeyBase + offset`, composed over the same command-backed move machinery as {@linkcode setElevation} (undoable, persisted, per-type invariants kept in sync). Use this instead of {@linkcode setElevation} when you want an offset relative to the storey rather than an absolute world height. `offset` is in **engine units** (the `design.doors.setWidth` convention); `0` sits the base flush with the storey base. Re-applying the current offset is a no-op.",
-    "examplePrompts": [
-      "Lift this element 300 above its floor",
-      "Set this staircase's base offset to 0",
-      "Raise the selected mass 500 off the storey base",
-      "Offset this slab 150 above the floor level\n\n# Example\n```ts\nconst [stair] = await snaptrude.design.query.listStaircases()\nawait snaptrude.design.update.setBaseOffset(stair, 0)\n```"
-    ],
-    "argsType": "ComponentHandle",
-    "resultType": "PluginDesignChangeResult"
-  },
-  {
-    "path": "design.update.setElevation",
+    "path": "design.update.setElevation",
     "namespace": "design.update",
     "summary": "Set a component's **absolute world elevation** — moves it vertically so its base (the bounding-box bottom, world Y) lands at `elevation`. Composed over the canonical command-backed move machinery, so it is undoable and persisted exactly like dragging the element up or down; per-type invariants (e.g. a staircase's base offset) stay in sync. `elevation` is in **engine units** (the `design.doors.setWidth` convention). Re-applying the current elevation is a no-op.",
     "examplePrompts": [
@@ -7088,21 +6071,6 @@
     "argsType": "ComponentHandle",
     "resultType": "boolean"
   },
-  {
-    "path": "design.update.setObjectType",
-    "namespace": "design.update",
-    "summary": "Change the **object type** of one or more masses — turn a mass into a real wall, roof, slab or floor: the properties panel's Object Type dropdown, headless. The geometry is kept exactly as it is (a wedge stays a wedge; nothing is flattened to a default thickness), so a sloped mass built with `design.create.massFromBrep` becomes a sloped roof or a raked wall. The component keeps its handle, label and storey; it gains the target type's construction layers and properties, and the type's default material when the mass still wore the default. One undoable operation for the whole list; undo turns them back into masses.",
-    "examplePrompts": [
-      "Convert this mass into a wall",
-      "Turn the sloped mass into a roof",
-      "Make these masses real slabs",
-      "Change the object type of the selection to wall",
-      "Convert the wedge I built into a raked wall",
-      "Turn this mass into a floor\n\n# Example\n```ts\nconst brep = await snaptrude.core.geom.create.brepFromFaces(wedgeFaces)\nconst wedge = await snaptrude.design.create.massFromBrep(brep, \"Gable end\")\nconst { affected } = await snaptrude.design.update.setObjectType([wedge], \"wall\")\nconsole.log(await snaptrude.design.query.getEntityType(affected[0])) // \"wall\"\n```"
-    ],
-    "argsType": "ComponentHandle[]",
-    "resultType": "PluginDesignChangeResult"
-  },
   {
     "path": "design.update.setStorey",
     "namespace": "design.update",
@@ -7116,18 +6084,6 @@
     "argsType": "ComponentHandle[]",
     "resultType": "PluginDesignChangeResult"
   },
-  {
-    "path": "design.update.siteEdge",
-    "namespace": "design.update",
-    "summary": "Change one site edge's type (front / side / rear) and/or give that edge its own setback distance, the same as editing a setback pill on the canvas. One undo step; the pills and Site Analysis sheet refresh.",
-    "examplePrompts": [
-      "Make edge 2 the front",
-      "Set just the north edge setback to 8 m",
-      "Remove the custom setback on edge 3\n\n# Example\n```ts\nconst [{ siteId }] = (await snaptrude.program.site.listEdges()).sites\nawait snaptrude.design.update.siteEdge(siteId, 2, { role: \"front\" })\nawait snaptrude.design.update.siteEdge(siteId, 3, { setback: 8, lengthUnit: \"m\" })\nawait snaptrude.design.update.siteEdge(siteId, 3, { setback: null })\n```"
-    ],
-    "argsType": "string",
-    "resultType": "PluginDesignUpdateSiteEdgeResult"
-  },
   {
     "path": "design.update.slab",
     "namespace": "design.update",
@@ -7249,16 +6205,6 @@
     "argsType": null,
     "resultType": "PluginDesignChangeResult"
   },
-  {
-    "path": "design.windows.checkPlacement",
-    "namespace": "design.windows",
-    "summary": "Trial the native host fit and geometry rebuild, then restore the model without publishing commands. The first result uses the creation options; subsequent results use candidateWidths in input order. Widths are authored parameters, not physical envelopes or a guaranteed maximum width. No catalog save, history entry or model persistence occurs. Rerun after model edits. A failed fit leaves cut unverified. Family-host cuts are also unverified: their rebuild cannot supply a reversible, authoritative trial result. Material clearance checks evaluated parts against physical neighbours across hosts. The intended host uses native fit/cut checks. Creation repeats clearance immediately before placement; this report grants no later approval. Editing permission is required; locked hosts and an active opening tool reject. A requested width/height on a family sized by its Type (Custom Sizes off) picks the Type within 25 mm, else turns Custom Sizes on; each result's `sizing` says which. Creation (`design.create.window(s)`) applies the same rule, so the size you pass is the size built.",
-    "examplePrompts": [
-      "Check whether this window fits and its host can be cut"
-    ],
-    "argsType": "PluginOpeningPlacementArgs",
-    "resultType": "PluginOpeningPlacementResult"
-  },
   {
     "path": "design.windows.exists",
     "namespace": "design.windows",
@@ -7288,7 +6234,7 @@
   {
     "path": "design.windows.getDimensions",
     "namespace": "design.windows",
-    "summary": "Get evaluated opening width/height and host thickness in Snaptrude units. The opening can differ from the width/height input parameters.",
+    "summary": "Get a window's full dimensions in one call — width along the wall, vertical height, and thickness through the wall — measured in the window's local oriented space.",
     "examplePrompts": [
       "What are the dimensions of this window?",
       "How big is the selected window?",
@@ -7794,7 +6740,7 @@
       "Add a red arrow from the title to the plan view",
       "Point an arrow at the top-left view on the cover sheet\n\n# Example\n```ts\nconst { shapeId } = await snaptrude.presentation.annotate.arrow(\n\"sheet_1\",\n{ x: 100, y: 200 },\n{ x: 300, y: 250 },\n{ color: \"red\" },\n)\n```"
     ],
-    "argsType": "string | undefined",
+    "argsType": "string",
     "resultType": "PluginPresentationAnnotateResult"
   },
   {
@@ -7806,7 +6752,7 @@
       "Put a yellow note on the cover sheet",
       "Leave a note next to the ground floor plan\n\n# Example\n```ts\nconst { shapeId } = await snaptrude.presentation.annotate.note(\n\"sheet_1\",\n\"Review this wall\",\n{ position: { x: 60, y: 120 }, color: \"yellow\" },\n)\n```"
     ],
-    "argsType": "string | undefined",
+    "argsType": "string",
     "resultType": "PluginPresentationAnnotateResult"
   },
   {
@@ -7818,7 +6764,7 @@
       "Add a red rectangle highlight to the sheet",
       "Draw an ellipse around the entrance on the cover sheet\n\n# Example\n```ts\nconst { shapeId } = await snaptrude.presentation.annotate.shape(\n\"sheet_1\",\n\"cloud\",\n{ x: 80, y: 80, w: 240, h: 160 },\n{ color: \"red\" },\n)\n```"
     ],
-    "argsType": "string | undefined",
+    "argsType": "string",
     "resultType": "PluginPresentationAnnotateResult"
   },
   {
@@ -7831,72 +6777,8 @@
       "Caption this view with \"Proposed layout\"",
       "Put a red note on the sheet\n\n# Example\n```ts\nconst { shapeId } = await snaptrude.presentation.annotate.text(\n\"sheet_1\",\n\"Ground Floor\",\n{ position: { x: 40, y: 40 }, size: \"xl\", color: \"blue\" },\n)\n```"
     ],
-    "argsType": "string | undefined",
-    "resultType": "PluginPresentationAnnotateTextResult"
-  },
-  {
-    "path": "presentation.camera.capture",
-    "namespace": "presentation.camera",
-    "summary": "Screenshot what the Present canvas currently shows.",
-    "examplePrompts": [
-      "Take a screenshot of the Present canvas",
-      "Capture what I am looking at in Present mode",
-      "Screenshot the presentation canvas as a JPEG",
-      "Grab a high-res image of the current sheet view\n\n# Example\n```ts\nconst { image, width, height } = await snaptrude.presentation.camera.capture({\nformat: \"png\",\npixelRatio: 2,\n})\n```"
-    ],
-    "argsType": "{\n    format?: PluginPresentationImageFormat\n    pixelRatio?: number\n  }",
-    "resultType": "PluginPresentationCameraCaptureResult"
-  },
-  {
-    "path": "presentation.camera.get",
-    "namespace": "presentation.camera",
-    "summary": "Read the Present camera: pan, zoom, the visible page-space rectangle and the sheet under the centre of the view.",
-    "examplePrompts": [
-      "Where is the Present canvas camera?",
-      "What zoom level is Present mode at?",
-      "Which sheet is on screen right now?",
-      "Read the visible area of the presentation canvas\n\n# Example\n```ts\nconst { zoom, sheetId } = await snaptrude.presentation.camera.get()\n```"
-    ],
-    "argsType": null,
-    "resultType": "PluginPresentationCameraState"
-  },
-  {
-    "path": "presentation.camera.set",
-    "namespace": "presentation.camera",
-    "summary": "Pan and/or zoom the Present canvas. Fields left out keep their current value, so `{ zoom: 2 }` changes only the zoom (the page point at the viewport's top-left corner stays put) and `{ x, y }` pans at the current zoom. `zoom` is clamped to the editor's range (1% to 1000%); the requested `x`/`y` are always honoured. Immediate (no animation). View-state only — not undoable.",
-    "examplePrompts": [
-      "Zoom the Present canvas to 50%",
-      "Pan the presentation canvas to the right",
-      "Restore the Present camera I saved earlier",
-      "Set the Present zoom to 200% without moving\n\n# Example\n```ts\nconst saved = await snaptrude.presentation.camera.get()\nawait snaptrude.presentation.camera.set({ zoom: 0.5 })\n// …later, restore the exact framing\nawait snaptrude.presentation.camera.set({ x: saved.x, y: saved.y, zoom: saved.zoom })\n```"
-    ],
-    "argsType": "{\n    x?: number\n    y?: number\n    zoom?: number\n  }",
-    "resultType": "PluginPresentationCameraState"
-  },
-  {
-    "path": "presentation.camera.zoomTo",
-    "namespace": "presentation.camera",
-    "summary": "Frame one shape on the Present canvas: a sheet, a placed view, a keyed shape or an annotation — any id the other `presentation` namespaces hand out. Pair with {@linkcode PluginPresentationCameraApi.capture} to screenshot a single sheet or placed view as it appears on screen. Immediate, unlike `sheets.setActive`, which animates its move over half a second. View-state only — not undoable.",
-    "examplePrompts": [
-      "Zoom in on sheet 2 in Present mode",
-      "Frame this placed view on the Present canvas",
-      "Go to the cover sheet and screenshot it",
-      "Centre the presentation view on that table\n\n# Example\n```ts\nconst { sheets } = await snaptrude.presentation.sheets.list()\nawait snaptrude.presentation.camera.zoomTo(sheets[1].id)\nconst { image } = await snaptrude.presentation.camera.capture()\n```"
-    ],
     "argsType": "string",
-    "resultType": "PluginPresentationCameraState"
-  },
-  {
-    "path": "presentation.camera.zoomToFit",
-    "namespace": "presentation.camera",
-    "summary": "Frame everything on the Present canvas — every sheet and loose shape — the Present-mode \"zoom to fit\". View-state only — not undoable.",
-    "examplePrompts": [
-      "Zoom out to see all the sheets",
-      "Fit the whole presentation in the Present view",
-      "Zoom to fit in Present mode\n\n# Example\n```ts\nawait snaptrude.presentation.camera.zoomToFit()\n```"
-    ],
-    "argsType": null,
-    "resultType": "PluginPresentationCameraState"
+    "resultType": "PluginPresentationAnnotateTextResult"
   },
   {
     "path": "presentation.diagrams.generateProgram",
@@ -7934,413 +6816,20 @@
     "argsType": "string",
     "resultType": "PluginPresentationDiagramsPlaceResult"
   },
-  {
-    "path": "presentation.drawings.applyPreset",
-    "namespace": "presentation.drawings",
-    "summary": "Bind a native kernel plan to a view preset and clear its declared overrides, so it takes the preset's styles. Local title, proposal and building text is kept. One Present undo step. Presets apply only to drawings whose `getCapabilities(drawingId).presets` is `true`.",
-    "examplePrompts": [
-      "Apply the presentation plan preset to this drawing",
-      "Use the Planning Issue style on every plan drawing",
-      "Make this drawing look like the other plans\n\n# Example\n```ts\nconst presets = await snaptrude.presentation.viewPresets.list()\nconst preset = presets.find((each) => each.name === \"Planning Issue\")\nif (preset) await snaptrude.presentation.drawings.applyPreset(drawing.id, preset.id)\n```"
-    ],
-    "argsType": "string",
-    "resultType": "PluginDrawing"
-  },
-  {
-    "path": "presentation.drawings.copy",
-    "namespace": "presentation.drawings",
-    "summary": "Duplicate a drawing with its labels and annotations (native duplication, offset slightly from the original). One Present undo step. The copy keeps the original's source view, scale, crop, styles and preset binding.",
-    "examplePrompts": [
-      "Duplicate this drawing",
-      "Make a copy of the ground floor plan drawing",
-      "Copy this drawing so I can try a different style\n\n# Example\n```ts\nconst copy = await snaptrude.presentation.drawings.copy(drawing.id)\nawait snaptrude.presentation.drawings.rename(copy.id, \"Ground Floor (option B)\")\n```"
-    ],
-    "argsType": "string",
-    "resultType": "PluginDrawing"
-  },
-  {
-    "path": "presentation.drawings.create",
-    "namespace": "presentation.drawings",
-    "summary": "Generate a drawing from a saved view. Creates the drawing beside its source view on the canvas, never on a sheet; to put a drawing on a sheet use `presentation.sheets.place(sheetId, viewId)` (fits it to the sheet) or `presentation.sheets.placeDrawing(sheetId, drawingId)` (moves this drawing onto the sheet, scaled down to fit). Omit `position` unless the user asked for a specific place: the host puts the new drawing next to its source view, clear of other drawings. An explicit `position` (page coordinates, the drawing's centre) is kept and can land on top of an existing drawing. The user's selection is left as it was. Changes the drawing, not the Present camera. The Present view may follow the drawing as a courtesy to a user watching (never zooming in, not while the camera is locked); to look at it, call `presentation.camera.zoomTo(drawing.id)` then `presentation.camera.capture()`. `scale` must be a standard architectural scale denominator (100 means 1:100) in the project's unit system; any other value is rejected. Metric: 10, 20, 50, 100, 150, 200, 250, 500, 1000. Imperial detail: 12, 16, 24, 32, 48, 64, 96, 128, 192, 384, 768, 1536 (1\" = 1' to 1/128\" = 1'; 48 is 1/4\" = 1', 96 is 1/8\" = 1'). Imperial site: 120, 240, 360, 480, 600, 1200, 2400, 3600, 4800 (1\" = 10' to 1\" = 400'). Pick the LARGEST standard scale (smallest denominator) at which the view still fits its frame or sheet and its room labels stay readable: for a building floor plan that is usually 1:50 to 1:200 (1/4\" = 1' to 1/16\" = 1'). Never use a site-sized scale (1:500 and up, 1/64\" = 1' (768) and smaller, 1\" = 20' (240) and up) for a single building plan unless the user asked for it. `scale` applies to plans, site plans and elevations; leave it out for a 3D view. After creating, read `labels.getLayout(drawingId)`: when labels are unplaced and carry a `suggestedScale`, move to that larger scale with `setScale`. To apply a preset, create first and then call `applyPreset`.",
-    "examplePrompts": [
-      "Create a drawing from the ground floor view",
-      "Make a 1:100 plan drawing of level 2",
-      "Draw the north elevation at 1/8\" = 1'",
-      "Put the site plan view on the Present canvas as a drawing\n\n# Example\n```ts\nconst { views } = await snaptrude.presentation.views.list()\nconst plan = views.find((view) => view.kind === \"plan\")!\nconst drawing = await snaptrude.presentation.drawings.create(plan.id, { scale: 100 })\nawait snaptrude.presentation.camera.zoomTo(drawing.id)\nconst { image } = await snaptrude.presentation.camera.capture()\n// To put it on a sheet: await snaptrude.presentation.sheets.placeDrawing(sheet.id, drawing.id)\n```"
-    ],
-    "argsType": "string",
-    "resultType": "PluginDrawing"
-  },
-  {
-    "path": "presentation.drawings.delete",
-    "namespace": "presentation.drawings",
-    "summary": "Delete a drawing with its labels and annotations, as one Present undo step. The source saved view is not deleted.",
-    "examplePrompts": [
-      "Delete this drawing",
-      "Remove the old elevation drawing from the canvas",
-      "Get rid of the duplicate plan drawing\n\n# Example\n```ts\nawait snaptrude.presentation.drawings.delete(drawing.id)\n```"
-    ],
-    "argsType": "string",
-    "resultType": "void"
-  },
-  {
-    "path": "presentation.drawings.export",
-    "namespace": "presentation.drawings",
-    "summary": "Export one drawing, with its labels and annotations, without a sheet. PDF size follows the drawing's canvas bounds; SVG and PDF keep vector content, raster fallbacks stay raster. `resolution` applies to raster formats. It does not wait for the canvas to paint, so it works while the user is on another browser tab. `download: true` starts a browser download and returns metadata only (never send large base64 to an agent); otherwise `files` carry `dataBase64`. `downloadStarted` means initiated, not proof of an OS-saved file. Layout warnings are returned. `fileName` is a base name WITHOUT an extension (\"Floor Pattern View\", never \"Floor Pattern View.pdf\"): the host appends .pdf/.svg/.png/.jpg for the format, and a name ending in .pdf, .svg, .png, .jpg or .jpeg, a dot or a space is rejected.",
-    "examplePrompts": [
-      "Export this drawing as a PDF",
-      "Download the ground floor plan drawing as an SVG",
-      "Save this drawing as a high-resolution PNG\n\n# Example\n```ts\nawait snaptrude.presentation.drawings.getStatus(drawing.id, { waitMs: 10_000 })\nconst result = await snaptrude.presentation.drawings.export(drawing.id, \"pdf\", {\nfileName: \"Ground Floor Plan\",\ndownload: true,\n})\n```"
-    ],
-    "argsType": "string",
-    "resultType": "PluginDrawingExportResult"
-  },
-  {
-    "path": "presentation.drawings.get",
-    "namespace": "presentation.drawings",
-    "summary": "Read one drawing by its stable id.",
-    "examplePrompts": [
-      "Does the ground floor drawing still exist?",
-      "What preset is this drawing using?",
-      "Read the scale and crop of this drawing\n\n# Example\n```ts\nconst current = await snaptrude.presentation.drawings.get(drawing.id)\nif (current) console.log(current.scale, current.presetId)\n```"
-    ],
-    "argsType": "string",
-    "resultType": "PluginDrawing | null"
-  },
-  {
-    "path": "presentation.drawings.getCapabilities",
-    "namespace": "presentation.drawings",
-    "summary": "Read what a drawing supports: its actual renderer, whether it takes presets (native kernel plans only), label layout and an architectural scale, the standard scales for this project, and its export formats. Read this before preset, scale, label-layout, style or export writes instead of inferring support from the source view.",
-    "examplePrompts": [
-      "What editing capabilities does this drawing support?",
-      "Can I apply a preset to this drawing?",
-      "Which scales can this drawing use?\n\n# Example\n```ts\nconst capabilities = await snaptrude.presentation.drawings.getCapabilities(drawing.id)\nif (capabilities.presets) {\nawait snaptrude.presentation.drawings.applyPreset(drawing.id, preset.id)\n}\n```"
-    ],
-    "argsType": "string",
-    "resultType": "PluginDrawingCapabilities"
-  },
-  {
-    "path": "presentation.drawings.getStatus",
-    "namespace": "presentation.drawings",
-    "summary": "Read a drawing's generation, label-layout and asset-upload state, optionally waiting up to `waitMs` (0 by default, at most 30,000) for it to become export-ready and uploaded. A timeout is not an error: the current state is returned. Read this before export or before closing Present mode.",
-    "examplePrompts": [
-      "Is this drawing ready to export?",
-      "Wait for the new drawing to finish generating",
-      "Has the drawing been uploaded yet?\n\n# Example\n```ts\nconst status = await snaptrude.presentation.drawings.getStatus(drawing.id, {\nwaitMs: 10_000,\n})\nif (!status.exportReady) console.warn(status.warnings)\n```"
-    ],
-    "argsType": "string",
-    "resultType": "PluginDrawingStatus"
-  },
-  {
-    "path": "presentation.drawings.getStyles",
-    "namespace": "presentation.drawings",
-    "summary": "Read a drawing's effective style categories (preset plus its own overrides) and the controls each category accepts. Always read this before {@linkcode PluginPresentationDrawingsApi.updateStyles}: accepted categories and controls depend on the drawing, and an `absent` category rejects writes. Do not echo a whole `settings` record as a patch (legacy reads may include the read-only `disable` flag and `-1` for unset opacity).",
-    "examplePrompts": [
-      "Show the editable styles for this drawing",
-      "What line weight are the walls drawn with?",
-      "Which categories can I restyle on this plan?\n\n# Example\n```ts\nconst styles = await snaptrude.presentation.drawings.getStyles(drawing.id)\nconst editable = styles.categories.filter((row) => !row.absent)\n```"
-    ],
-    "argsType": "string",
-    "resultType": "PluginDrawingStyles"
-  },
-  {
-    "path": "presentation.drawings.labels.getLayout",
-    "namespace": "presentation.drawings.labels",
-    "summary": "Read the label-layout diagnostics of a drawing: labels that could not be placed cleanly (each with a `suggestedScale` at which it would fit), pinned labels, merged duplicates and dropped rows. Reading never hides a label: an unplaced label is still shown at a best-effort position.",
-    "examplePrompts": [
-      "Check this drawing for overlapping labels",
-      "Do all the room names fit on the ground floor drawing?",
-      "Which scale would make the labels on this plan readable?\n\n# Example\n```ts\nconst layout = await snaptrude.presentation.drawings.labels.getLayout(drawing.id)\nconst suggested = layout.unplaced.find((row) => row.suggestedScale)?.suggestedScale\nif (suggested) await snaptrude.presentation.drawings.setScale(drawing.id, suggested)\n```"
-    ],
-    "argsType": "string",
-    "resultType": "PluginDrawingLabelLayout"
-  },
-  {
-    "path": "presentation.drawings.labels.list",
-    "namespace": "presentation.drawings.labels",
-    "summary": "List every text label on a drawing, including labels the user or the layout has hidden. An agent's own annotations under the drawing are not labels and are not listed.",
-    "examplePrompts": [
-      "List all labels in this drawing",
-      "Which room labels are hidden on the ground floor drawing?",
-      "Show me the text of every label on this plan\n\n# Example\n```ts\nconst labels = await snaptrude.presentation.drawings.labels.list(drawing.id)\nconst hidden = labels.filter((label) => label.hidden)\n```"
-    ],
-    "argsType": "string",
-    "resultType": "PluginPlacedViewLabel[]"
-  },
-  {
-    "path": "presentation.drawings.labels.move",
-    "namespace": "presentation.drawings.labels",
-    "summary": "Move a label within its drawing. A room label keeps the new position as a native pin at the drawing's current architectural scale; other labels move as plain text shapes. One Present undo step.",
-    "examplePrompts": [
-      "Move the Kitchen label up a little",
-      "Put the living room name in the middle of the room",
-      "Nudge this label to the left\n\n# Example\n```ts\nconst [label] = await snaptrude.presentation.drawings.labels.list(drawing.id)\nawait snaptrude.presentation.drawings.labels.move(label.labelId, {\nx: label.position.x,\ny: label.position.y - 20,\n})\n```"
-    ],
-    "argsType": "string",
-    "resultType": "PluginPlacedViewLabel"
-  },
-  {
-    "path": "presentation.drawings.labels.place",
-    "namespace": "presentation.drawings.labels",
-    "summary": "Pin a room label that could not be placed cleanly at the best position the native layout solver finds, at the current architectural scale. May wait up to ten seconds for a reloaded drawing's fit data. One Present undo step.",
-    "examplePrompts": [
-      "Place the labels that do not fit",
-      "Pin the Kitchen label where it fits best",
-      "Fix the overlapping room names on this drawing\n\n# Example\n```ts\nconst { unplaced } = await snaptrude.presentation.drawings.labels.getLayout(drawing.id)\nfor (const row of unplaced) {\nawait snaptrude.presentation.drawings.labels.place(row.labelId)\n}\n```"
-    ],
-    "argsType": "string",
-    "resultType": "boolean"
-  },
-  {
-    "path": "presentation.drawings.labels.reset",
-    "namespace": "presentation.drawings.labels",
-    "summary": "Clear room-label pins (from `move`, `place` or the user) so the native layout places those labels again: at the current architectural scale by default, or at every scale with `{ scope: \"all\" }`. One Present undo step.",
-    "examplePrompts": [
-      "Reset the label positions on this drawing",
-      "Undo all my label moves at every scale",
-      "Let the room labels lay themselves out again\n\n# Example\n```ts\nconst cleared = await snaptrude.presentation.drawings.labels.reset(drawing.id, {\nscope: \"all\",\n})\n```"
-    ],
-    "argsType": "string",
-    "resultType": "number"
-  },
-  {
-    "path": "presentation.drawings.labels.setHidden",
-    "namespace": "presentation.drawings.labels",
-    "summary": "Hide or show a label. This is the user's own visibility, independent of labels the layout or a crop hides. One Present undo step.",
-    "examplePrompts": [
-      "Hide the Store label on this drawing",
-      "Show the corridor label again",
-      "Turn off the label for the plant room\n\n# Example\n```ts\nconst labels = await snaptrude.presentation.drawings.labels.list(drawing.id)\nconst store = labels.find((label) => label.text.startsWith(\"Store\"))\nif (store) await snaptrude.presentation.drawings.labels.setHidden(store.labelId, true)\n```"
-    ],
-    "argsType": "string",
-    "resultType": "PluginPlacedViewLabel"
-  },
-  {
-    "path": "presentation.drawings.list",
-    "namespace": "presentation.drawings",
-    "summary": "List the drawings on the current Present page, loose or on sheets.",
-    "examplePrompts": [
-      "List all drawings in this presentation",
-      "Which drawings are not on a sheet yet?",
-      "What scale is each plan drawing at?\n\n# Example\n```ts\nconst drawings = await snaptrude.presentation.drawings.list()\nconst loose = drawings.filter((drawing) => !drawing.sheetId)\n```"
-    ],
-    "argsType": null,
-    "resultType": "PluginDrawing[]"
-  },
-  {
-    "path": "presentation.drawings.listFonts",
-    "namespace": "presentation.drawings",
-    "summary": "List the font families drawing text can use, from the native catalog (`\"DEFAULT\"` first). Use these names in a style patch's `fontFamily` instead of inventing one.",
-    "examplePrompts": [
-      "Which fonts can I use for drawing labels?",
-      "Is Inter available as a drawing font?",
-      "List the fonts for the title block\n\n# Example\n```ts\nconst fonts = await snaptrude.presentation.drawings.listFonts()\nconst family = fonts.includes(\"Inter\") ? \"Inter\" : \"DEFAULT\"\n```"
-    ],
-    "argsType": null,
-    "resultType": "string[]"
-  },
-  {
-    "path": "presentation.drawings.listPatterns",
-    "namespace": "presentation.drawings",
-    "summary": "List the hatch patterns the native pattern catalog offers. Use these ids in a style patch's `pattern.id` instead of inventing one.",
-    "examplePrompts": [
-      "What hatch patterns can I use?",
-      "List the brick and concrete patterns",
-      "Which fill patterns are available for rooms?\n\n# Example\n```ts\nconst patterns = await snaptrude.presentation.drawings.listPatterns()\nconst brick = patterns.find((pattern) => pattern.label.toLowerCase().includes(\"brick\"))\n```"
-    ],
-    "argsType": null,
-    "resultType": "{ id: string; label: string; group: string }[]"
-  },
-  {
-    "path": "presentation.drawings.rename",
-    "namespace": "presentation.drawings",
-    "summary": "Set the drawing's own title text. The source saved view keeps its name. One Present undo step.",
-    "examplePrompts": [
-      "Rename this drawing to Ground Floor Plan",
-      "Change the title of the elevation drawing",
-      "Call this drawing Level 2 General Arrangement\n\n# Example\n```ts\nawait snaptrude.presentation.drawings.rename(drawing.id, \"Ground Floor Plan\")\n```"
-    ],
-    "argsType": "string",
-    "resultType": "PluginDrawing"
-  },
-  {
-    "path": "presentation.drawings.resetOverrides",
-    "namespace": "presentation.drawings",
-    "summary": "Drop a kernel plan's own style overrides so it matches its bound preset again. Local title, proposal and building text is kept. One Present undo step.",
-    "examplePrompts": [
-      "Reset this drawing to its preset styles",
-      "Undo my style changes on the ground floor plan",
-      "Clear the overrides on this drawing\n\n# Example\n```ts\nawait snaptrude.presentation.drawings.resetOverrides(drawing.id)\n```"
-    ],
-    "argsType": "string",
-    "resultType": "PluginDrawing"
-  },
-  {
-    "path": "presentation.drawings.setCrop",
-    "namespace": "presentation.drawings",
-    "summary": "Crop a drawing to a window of itself, or pass `null` to remove the crop. Crop corners are 0–1 fractions of the uncropped drawing and must satisfy `topLeft < bottomRight` on both axes. One Present undo step. A loose drawing that grows over a neighbour it did not cover before (for example when the crop is removed) moves to the nearest free spot, which `placedViews.setCrop` does not do; an overlap the user made stays, and a drawing on a sheet never moves. Changes the drawing, not the Present camera. The Present view may follow the drawing as a courtesy to a user watching (never zooming in, not while the camera is locked); to look at it, call `presentation.camera.zoomTo(drawing.id)` then `presentation.camera.capture()`.",
-    "examplePrompts": [
-      "Crop this drawing to the left half",
-      "Remove the crop from the site plan drawing",
-      "Show only the top-right corner of this plan\n\n# Example\n```ts\nawait snaptrude.presentation.drawings.setCrop(drawing.id, {\ntopLeft: { x: 0, y: 0 },\nbottomRight: { x: 0.5, y: 1 },\n})\nawait snaptrude.presentation.drawings.setCrop(drawing.id, null)\n```"
-    ],
-    "argsType": "string",
-    "resultType": "PluginDrawing"
-  },
-  {
-    "path": "presentation.drawings.setScale",
-    "namespace": "presentation.drawings",
-    "summary": "Set a drawing's architectural scale; perspective/isometric drawings reject this. `scale` must be a standard architectural scale denominator (100 means 1:100) in the project's unit system; any other value is rejected. Metric: 10, 20, 50, 100, 150, 200, 250, 500, 1000. Imperial detail: 12, 16, 24, 32, 48, 64, 96, 128, 192, 384, 768, 1536 (1\" = 1' to 1/128\" = 1'; 48 is 1/4\" = 1', 96 is 1/8\" = 1'). Imperial site: 120, 240, 360, 480, 600, 1200, 2400, 3600, 4800 (1\" = 10' to 1\" = 400'). Pick the LARGEST standard scale (smallest denominator) at which the view still fits its frame or sheet and its room labels stay readable: for a building floor plan that is usually 1:50 to 1:200 (1/4\" = 1' to 1/16\" = 1'). Never use a site-sized scale (1:500 and up, 1/64\" = 1' (768) and smaller, 1\" = 20' (240) and up) for a single building plan unless the user asked for it. A loose drawing that grows over a neighbour it did not cover before moves to the nearest free spot, which `placedViews.setScale` does not do; an overlap the user made stays, and a drawing on a sheet never moves. Changes the drawing, not the Present camera. The Present view may follow the drawing as a courtesy to a user watching (never zooming in, not while the camera is locked); to look at it, call `presentation.camera.zoomTo(drawing.id)` then `presentation.camera.capture()`.",
-    "examplePrompts": [
-      "Set this drawing to 1:50",
-      "Change the plan drawing scale to 1/4\" = 1'",
-      "Make the ground floor drawing bigger so the labels fit\n\n# Example\n```ts\nconst layout = await snaptrude.presentation.drawings.labels.getLayout(drawing.id)\nconst suggested = layout.unplaced.find((row) => row.suggestedScale)?.suggestedScale\nawait snaptrude.presentation.drawings.setScale(drawing.id, suggested ?? 50)\n```"
-    ],
-    "argsType": "string",
-    "resultType": "PluginDrawing"
-  },
-  {
-    "path": "presentation.drawings.updateContent",
-    "namespace": "presentation.drawings",
-    "summary": "Regenerate one to 100 drawings from their source views, after the model or the view changed. Waits for the update to finish.",
-    "examplePrompts": [
-      "Update this drawing with my latest model changes",
-      "Refresh all the drawings",
-      "Regenerate the ground floor plan drawing\n\n# Example\n```ts\nconst drawings = await snaptrude.presentation.drawings.list()\nconst results = await snaptrude.presentation.drawings.updateContent(\ndrawings.map((drawing) => drawing.id),\n)\n```"
-    ],
-    "argsType": "string[]",
-    "resultType": "{ drawingId: string; updated: boolean }[]"
-  },
-  {
-    "path": "presentation.drawings.updateStyles",
-    "namespace": "presentation.drawings",
-    "summary": "Merge a sparse style patch into one category of a drawing, as one Present undo step. Nested objects merge rather than replace the row. Line and outline weights are paper millimetres (0–2.11); opacity is 0–100; colours are `#rrggbb`. On a kernel plan the patch becomes the drawing's own overrides of its preset; other drawings take the legacy placed-view category patch. An absent category, an unsupported field or an invalid value rejects the whole write.",
-    "examplePrompts": [
-      "Make the walls on this drawing thicker",
-      "Fill the rooms at 60% opacity with a larger hatch",
-      "Turn off the door tags on this plan\n\n# Example\n```ts\nconst styles = await snaptrude.presentation.drawings.getStyles(drawing.id)\nconst space = styles.categories.find((row) => row.category === \"Space\")\nif (space && !space.absent && space.controls.some((control) => control.key === \"opacity\")) {\nawait snaptrude.presentation.drawings.updateStyles(drawing.id, \"Space\", {\nopacity: 60,\npattern: { scale: 1.5 },\n})\n}\n```"
-    ],
-    "argsType": "string",
-    "resultType": "PluginDrawingStyles"
-  },
   {
     "path": "presentation.export",
     "namespace": "presentation",
-    "summary": "Export the presentation's layout sheets to a downloadable file (PDF / PNG / JPG). Return base64 by default; `download: true` initiates browser downloads and returns metadata without base64. Requires Present mode to be open. `fileName` is a base name WITHOUT an extension (\"Floor Pattern View\", never \"Floor Pattern View.pdf\"): the host appends the extension for the format, and a name ending in .pdf, .svg, .png, .jpg or .jpeg, a dot or a space is rejected.",
+    "summary": "Export the presentation's layout sheets to a downloadable file (PDF / PNG / JPG) and return the encoded bytes as base64. Wraps the Present-mode Export dialog pipeline headlessly. Requires Present mode to be open.",
     "examplePrompts": [
       "Export the presentation as a PDF",
       "Download all sheets as a single PDF",
       "Export sheet 1 as a PNG",
       "Save the presentation sheets as JPG images",
-      "Export these sheets to PDF at high resolution\n\n# Example\n```ts\nconst { files } = await snaptrude.presentation.export(\"pdf\")\nconst download = await snaptrude.presentation.export(\"pdf\", { download: true })\n```"
+      "Export these sheets to PDF at high resolution\n\n# Example\n```ts\nconst { files } = await snaptrude.presentation.export(\"pdf\")\n```"
     ],
     "argsType": "PluginPresentationExportFormat",
     "resultType": "PluginPresentationExportResult"
   },
-  {
-    "path": "presentation.export",
-    "namespace": "presentation",
-    "summary": "",
-    "examplePrompts": [],
-    "argsType": "PluginPresentationExportFormat",
-    "resultType": "PluginPresentationExportDownloadResult"
-  },
-  {
-    "path": "presentation.export",
-    "namespace": "presentation",
-    "summary": "",
-    "examplePrompts": [],
-    "argsType": "PluginPresentationExportFormat",
-    "resultType": "PluginPresentationExportResult | PluginPresentationExportDownloadResult"
-  },
-  {
-    "path": "presentation.graphics.disableThinLines",
-    "namespace": "presentation.graphics",
-    "summary": "Disable the viewer's Thin Lines preference. No model save, undo or peer change.",
-    "examplePrompts": [],
-    "argsType": null,
-    "resultType": "boolean"
-  },
-  {
-    "path": "presentation.graphics.enableThinLines",
-    "namespace": "presentation.graphics",
-    "summary": "Enable the viewer's Thin Lines preference. No model save, undo or peer change. capture_view and exported images deliberately suspend it and use real weights.",
-    "examplePrompts": [],
-    "argsType": null,
-    "resultType": "boolean"
-  },
-  {
-    "path": "presentation.graphics.get",
-    "namespace": "presentation.graphics",
-    "summary": "Read a view's scale denominator, detail and category overrides.",
-    "examplePrompts": [
-      "What scale is this plan drawn at?"
-    ],
-    "argsType": "PluginGraphicsViewId",
-    "resultType": "PluginViewGraphics | null"
-  },
-  {
-    "path": "presentation.graphics.isEnabled",
-    "namespace": "presentation.graphics",
-    "summary": "Whether Paper Pens is enabled on this viewer. Never changes the feature flag.",
-    "examplePrompts": [],
-    "argsType": null,
-    "resultType": "boolean"
-  },
-  {
-    "path": "presentation.graphics.isThinLinesEnabled",
-    "namespace": "presentation.graphics",
-    "summary": "Read the remembered Thin Lines preference. A disabled feature or capture suspension can make the renderer ignore a true preference temporarily.",
-    "examplePrompts": [],
-    "argsType": null,
-    "resultType": "boolean"
-  },
-  {
-    "path": "presentation.graphics.listScales",
-    "namespace": "presentation.graphics",
-    "summary": "List the chip's scale choices for the project units, in the same order. Custom denominators need not be listed: any integer 1–24000 is valid.",
-    "examplePrompts": [],
-    "argsType": "PluginGraphicsViewId",
-    "resultType": "PluginGraphicsScaleOption[]"
-  },
-  {
-    "path": "presentation.graphics.reset",
-    "namespace": "presentation.graphics",
-    "summary": "Clear one category or all category overrides, as one saved undoable step. The view's scale and detail level are preserved.",
-    "examplePrompts": [],
-    "argsType": "PluginGraphicsResetOptions",
-    "resultType": "PluginViewGraphics"
-  },
-  {
-    "path": "presentation.graphics.setDetailLevel",
-    "namespace": "presentation.graphics",
-    "summary": "Set the active plan's Coarse/Fine drawing detail through the native setter. Fine draws wall layers; this does not enable the project's Detailed View take-off setting. Saved for a saved view, not a model undo step; unsaved current views are transient.",
-    "examplePrompts": [
-      "Show this plan in Fine detail"
-    ],
-    "argsType": "PluginGraphicsDetailLevel",
-    "resultType": "PluginViewGraphics"
-  },
-  {
-    "path": "presentation.graphics.setScale",
-    "namespace": "presentation.graphics",
-    "summary": "Set a paper view's denominator through the same path as the scale chip. A saved view persists this change; it is not a model undo step. Without a saved current view, only viewer state changes. Does not switch the camera. An inactive target refuses NOT_ACTIVE_VIEW.",
-    "examplePrompts": [
-      "Set this plan to 1:50"
-    ],
-    "argsType": "number",
-    "resultType": "PluginViewGraphics"
-  },
-  {
-    "path": "presentation.graphics.update",
-    "namespace": "presentation.graphics",
-    "summary": "Change only supplied category fields, as one saved and undoable step. Does not edit project standards. Requires a saved view.",
-    "examplePrompts": [
-      "Halftone the furniture in this view"
-    ],
-    "argsType": "PluginGraphicsOverrides",
-    "resultType": "PluginViewGraphics"
-  },
   {
     "path": "presentation.import.image",
     "namespace": "presentation.import",
@@ -8606,7 +7095,7 @@
   {
     "path": "presentation.placedViews.setScale",
     "namespace": "presentation.placedViews",
-    "summary": "Set a placed view's architectural scale. `scale` must be a standard architectural scale denominator (100 means 1:100) in the project's unit system; any other value is rejected. Metric: 10, 20, 50, 100, 150, 200, 250, 500, 1000. Imperial detail: 12, 16, 24, 32, 48, 64, 96, 128, 192, 384, 768, 1536 (1\" = 1' to 1/128\" = 1'; 48 is 1/4\" = 1', 96 is 1/8\" = 1'). Imperial site: 120, 240, 360, 480, 600, 1200, 2400, 3600, 4800 (1\" = 10' to 1\" = 400'). Pick the LARGEST standard scale (smallest denominator) at which the view still fits its frame or sheet and its room labels stay readable: for a building floor plan that is usually 1:50 to 1:200 (1/4\" = 1' to 1/16\" = 1'). Never use a site-sized scale (1:500 and up, 1/64\" = 1' (768) and smaller, 1\" = 20' (240) and up) for a single building plan unless the user asked for it.",
+    "summary": "Set a placed view's architectural scale.",
     "examplePrompts": [
       "Set the plan to 1:100",
       "Change the placed floor plan to 1:50 scale",
@@ -8641,99 +7130,6 @@
     "argsType": "string",
     "resultType": "PluginPlacedViewCategoryStyles"
   },
-  {
-    "path": "presentation.sections.create",
-    "namespace": "presentation.sections",
-    "summary": "Draw a section line from `start` to `end` on the plan. The section looks along the line's direction turned a quarter turn — a line drawn toward +x looks toward +z; flip it with `update(id, { isFlipped: true })`. Its slice defaults to the building's full height and its depth to the far side of the model. Write-gated; one undo step.",
-    "examplePrompts": [
-      "Cut a section through the middle of the building, east to west",
-      "Add a section across the stair core",
-      "Draw a longitudinal section and open it\n\n# Example\n```ts\nconst section = await snaptrude.presentation.sections.create(\n{ x: -40, z: 10 },\n{ x: 40, z: 10 },\n{ name: \"Longitudinal\", isActive: true },\n)\n```"
-    ],
-    "argsType": "PluginSectionPoint",
-    "resultType": "PluginSection"
-  },
-  {
-    "path": "presentation.sections.delete",
-    "namespace": "presentation.sections",
-    "summary": "Delete a section. Closes its view first if it is open. Write-gated; one undo step.",
-    "examplePrompts": [
-      "Delete Section B\n\n# Example\n```ts\nawait snaptrude.presentation.sections.delete(sectionId)\n```"
-    ],
-    "argsType": "string",
-    "resultType": "boolean"
-  },
-  {
-    "path": "presentation.sections.get",
-    "namespace": "presentation.sections",
-    "summary": "Get one section by id.",
-    "examplePrompts": [
-      "Where does Section A run?",
-      "How deep is this section?\n\n# Example\n```ts\nconst section = await snaptrude.presentation.sections.get(sectionId)\nconsole.log(section?.start, section?.end)\n```"
-    ],
-    "argsType": "string",
-    "resultType": "PluginSection | null"
-  },
-  {
-    "path": "presentation.sections.getActive",
-    "namespace": "presentation.sections",
-    "summary": "Get the section whose view is open.",
-    "examplePrompts": [
-      "Which section am I looking at?\n\n# Example\n```ts\nconst open = await snaptrude.presentation.sections.getActive()\n```"
-    ],
-    "argsType": null,
-    "resultType": "PluginSection | null"
-  },
-  {
-    "path": "presentation.sections.getCut",
-    "namespace": "presentation.sections",
-    "summary": "What a section cuts: every element its cutting plane passes through within the section's extents, with the cut's area, outline length and extent on the plane, largest first. Computed from the model, not from the drawing, so it needs no open view and works however the section is shown; furniture is left out, as in the drawing, and so is anything hidden in the model. Areas are exact for closed solids. Repeated calls reuse the cuts of elements that have not changed. Read-only.",
-    "examplePrompts": [
-      "Which walls does Section A cut?",
-      "How thick is the slab where the section crosses it?",
-      "Does this section go through the stair?",
-      "What is the floor-to-floor height in this section?\n\n# Example\n```ts\nconst cut = await snaptrude.presentation.sections.getCut(sectionId)\nconst walls = cut.elements.filter((element) => element.type === \"wall\")\nconst thickest = walls[0]\nconsole.log(thickest.extent.uMax - thickest.extent.uMin)\n```"
-    ],
-    "argsType": "string",
-    "resultType": "PluginSectionCut"
-  },
-  {
-    "path": "presentation.sections.list",
-    "namespace": "presentation.sections",
-    "summary": "List the project's sections, in Views panel order.",
-    "examplePrompts": [
-      "Which sections are there?",
-      "List the section lines in this project",
-      "Is there a section through the stair?\n\n# Example\n```ts\nconst sections = await snaptrude.presentation.sections.list()\n```"
-    ],
-    "argsType": null,
-    "resultType": "PluginSection[]"
-  },
-  {
-    "path": "presentation.sections.setActive",
-    "namespace": "presentation.sections",
-    "summary": "Open a section's view, or close the open one with `null`. Opening frames the section's saved camera, or a straight-on view when it has none. Closing returns to 3D; with no section view open, `null` does nothing. Not an edit: nothing is added to the undo history.",
-    "examplePrompts": [
-      "Open Section A",
-      "Show me the section through the atrium",
-      "Close the section view\n\n# Example\n```ts\nawait snaptrude.presentation.sections.setActive(section.sectionId)\nawait snaptrude.presentation.sections.setActive(null)\n```"
-    ],
-    "argsType": "string | null",
-    "resultType": "PluginSection | null"
-  },
-  {
-    "path": "presentation.sections.update",
-    "namespace": "presentation.sections",
-    "summary": "Change a section. Only the given fields change; the whole patch is one undo step. Flipping without a `depth` carries the depth to the far side of the model in the new direction, as `create` does. Write-gated.",
-    "examplePrompts": [
-      "Make Section A look the other way",
-      "Only show the ground floor in this section",
-      "Rename the section to \"Through atrium\"",
-      "Move the section line 5 m north\n\n# Example\n```ts\nawait snaptrude.presentation.sections.update(sectionId, {\nisFlipped: true,\ndepth: 60,\n})\n```"
-    ],
-    "argsType": "string",
-    "resultType": "PluginSection"
-  },
   {
     "path": "presentation.shapes.list",
     "namespace": "presentation.shapes",
@@ -8836,31 +7232,17 @@
   {
     "path": "presentation.sheets.place",
     "namespace": "presentation.sheets",
-    "summary": "Place a saved view onto a sheet. This is the call that puts a view on a sheet (`presentation.drawings.create` makes a drawing beside its source view, not on a sheet). When `scale` is omitted the view is fitted to the target sheet: a 2D or site-plan view is placed at the largest standard scale at which it fits inside the target sheet's margin, and never at a larger scale than the normal view drop would pick; a 3D view has no scale, so it is shrunk evenly to fit instead. This is the same fit as `placeDrawing`. Omit `position` unless the user asked for a specific place. Without a `position` the drawing goes to the sheet centre when that is free, otherwise to the nearest free spot to the centre inside the margin, beside the drawings already there; when there is no free spot it is centred anyway and the result has `overlaps: true`. With a `position` it is placed as given, and the result has `overlaps: true` when it covers another drawing, but it is not moved. In both cases only other drawings count (placed views and their title blocks and labels): text, images and other shapes on the sheet are ignored. Each call fits one view to the whole sheet, so a second fitted view often has no free spot: when several views should share a sheet, pass a `scale` small enough for all of them; otherwise use `sheets.create` per view. When the result's `overlaps` is true, move the drawing or put it on its own sheet. An explicit `scale` is always kept, even when the drawing (title block included) does not fit inside the sheet's margin at that scale; the result then has `overflows: true`. When it is true, pass a smaller scale (larger denominator), omit `scale` to fit, or use a larger sheet. `scale` must be a standard architectural scale denominator (100 means 1:100) in the project's unit system; any other value is rejected. Metric: 10, 20, 50, 100, 150, 200, 250, 500, 1000. Imperial detail: 12, 16, 24, 32, 48, 64, 96, 128, 192, 384, 768, 1536 (1\" = 1' to 1/128\" = 1'; 48 is 1/4\" = 1', 96 is 1/8\" = 1'). Imperial site: 120, 240, 360, 480, 600, 1200, 2400, 3600, 4800 (1\" = 10' to 1\" = 400'). Pick the LARGEST standard scale (smallest denominator) at which the view still fits its frame or sheet and its room labels stay readable: for a building floor plan that is usually 1:50 to 1:200 (1/4\" = 1' to 1/16\" = 1'). Never use a site-sized scale (1:500 and up, 1/64\" = 1' (768) and smaller, 1\" = 20' (240) and up) for a single building plan unless the user asked for it.",
+    "summary": "Place a saved view onto a sheet.",
     "examplePrompts": [
       "Place the floor plan on Sheet 1",
       "Add this 3D view to the cover sheet",
       "Drop the site plan onto the layout sheet at 100, 200",
       "Put the Ground Floor view on sheet_1 at 1:100 scale",
-      "Place the plan on the cover sheet at quarter-inch scale",
-      "Add a floor plan drawing of each storey to this sheet\n\n# Example\n```ts\nconst { shapeId } = await snaptrude.presentation.sheets.place(\"sheet_1\", \"view_123\", {\nscale: 100, // 1:100 (metric project)\n})\n```"
+      "Place the plan on the cover sheet at quarter-inch scale\n\n# Example\n```ts\nconst { shapeId } = await snaptrude.presentation.sheets.place(\"sheet_1\", \"view_123\", {\nscale: 100, // 1:100 (metric project)\n})\n```"
     ],
     "argsType": "string",
     "resultType": "PluginPresentationSheetsPlaceResult"
   },
-  {
-    "path": "presentation.sheets.placeDrawing",
-    "namespace": "presentation.sheets",
-    "summary": "Move an existing drawing onto a sheet without copying or regenerating it, scaled down to fit the sheet when it is too big. `presentation.drawings.create` leaves a drawing beside its source view, not on a sheet; this is the call that puts it on one. To place a saved view on a sheet in one call, use `sheets.place(sheetId, viewId)`, which fits it the same way. By default (`fit` true or omitted) a drawing larger than the sheet's drawable area (the sheet inside its margin) is moved to the LARGEST standard architectural scale at which it fits; a drawing that already fits keeps its scale, and a drawing is never scaled up. A 3D drawing has no architectural scale, so it is shrunk uniformly to fit instead. With `fit: false` the scale is kept and a drawing that does not fit is rejected with an error naming the drawing, the sheet and the scale, and saying to call `placeDrawing` without `fit: false` to fit it, or use a larger sheet. When even the smallest standard scale does not fit, the call is rejected with an error suggesting a larger sheet size. Without a `position` the drawing goes to the sheet centre when that is free, otherwise to the nearest free spot to the centre inside the margin, beside the drawings already there; when there is no free spot it is centred anyway and the result has `overlaps: true`. With a `position` it is placed as given, and the result has `overlaps: true` when it covers another drawing, but it is not moved. In both cases only other drawings count (placed views and their title blocks and labels): text, images and other shapes on the sheet are ignored. Each call fits one drawing to the whole sheet, so a second fitted drawing often has no free spot: when several drawings should share a sheet, give them scales small enough for all of them; otherwise use `sheets.create` per drawing. The position is sheet-local. The drawing's stable id remains unchanged; `shapeId` therefore identifies the moved drawing. The result reports the architectural scale the drawing has on the sheet and whether this call changed it; a host that reports it also says whether the drawing `overlaps` another drawing on the sheet (move it or put it on its own sheet when true).",
-    "examplePrompts": [
-      "Move this drawing onto the cover sheet",
-      "Place drawing_1 at the center of sheet_2",
-      "Put the level 2 plan drawing on the Level 2 Plan sheet",
-      "Add the floor plan drawings to this sheet\n\n# Example\n```ts\nconst { scale, rescaled } = await snaptrude.presentation.sheets.placeDrawing(\nsheet.id,\ndrawing.id,\n)\n```"
-    ],
-    "argsType": "string",
-    "resultType": "PluginPresentationSheetsPlaceDrawingResult"
-  },
   {
     "path": "presentation.sheets.rename",
     "namespace": "presentation.sheets",
@@ -8971,62 +7353,6 @@
     "argsType": null,
     "resultType": "PluginPresentationSlideshowState"
   },
-  {
-    "path": "presentation.standards.export",
-    "namespace": "presentation.standards",
-    "summary": "Serialize the native standard-file format. No browser download or save. The file includes its stock/version and stores widths in paper mm.",
-    "examplePrompts": [
-      "Export the line standard"
-    ],
-    "argsType": null,
-    "resultType": "string"
-  },
-  {
-    "path": "presentation.standards.get",
-    "namespace": "presentation.standards",
-    "summary": "Read the stored sparse standard; omitted fields inherit stock values.",
-    "examplePrompts": [],
-    "argsType": null,
-    "resultType": "PluginGraphicStandard"
-  },
-  {
-    "path": "presentation.standards.getResolved",
-    "namespace": "presentation.standards",
-    "summary": "Read the actual native resolution, including applicable view overrides. No camera, view, preference or project data changes.",
-    "examplePrompts": [
-      "How thick are the wall cut lines at 1:50?"
-    ],
-    "argsType": "PluginGraphicStandardResolveOptions",
-    "resultType": "PluginResolvedGraphicStandard | null"
-  },
-  {
-    "path": "presentation.standards.import",
-    "namespace": "presentation.standards",
-    "summary": "Import native standard-file JSON exactly as the dialog does, replacing the project standard in one saved undo step. Never edits team preferences.",
-    "examplePrompts": [
-      "Match the line weights in this standard file"
-    ],
-    "argsType": "string",
-    "resultType": "PluginGraphicStandard"
-  },
-  {
-    "path": "presentation.standards.reset",
-    "namespace": "presentation.standards",
-    "summary": "Reset an editable tab, or all tabs, through the native reset functions. One saved undo step; stock retention/pruning follows the native commit.",
-    "examplePrompts": [],
-    "argsType": "PluginGraphicStandardTab",
-    "resultType": "PluginGraphicStandard"
-  },
-  {
-    "path": "presentation.standards.update",
-    "namespace": "presentation.standards",
-    "summary": "Apply only supplied fields as one saved, undoable native commit. Validate the whole patch first; invalid fields never leave a partial edit behind.",
-    "examplePrompts": [
-      "Make wall cut lines heavier throughout the project"
-    ],
-    "argsType": "PluginGraphicStandardPatch",
-    "resultType": "PluginGraphicStandard"
-  },
   {
     "path": "presentation.tables.place",
     "namespace": "presentation.tables",
@@ -9040,90 +7366,6 @@
     "argsType": "string",
     "resultType": "PluginCanvasShape"
   },
-  {
-    "path": "presentation.viewPresets.copy",
-    "namespace": "presentation.viewPresets",
-    "summary": "Duplicate a preset under a native-generated unique name. Drawing bindings do not change. Not undoable (catalog write). Built-ins can be copied.",
-    "examplePrompts": [
-      "Duplicate this preset",
-      "Make an editable copy of the built-in preset",
-      "Copy the Planning Issue preset so I can change it\n\n# Example\n```ts\nconst copy = await snaptrude.presentation.viewPresets.copy(preset.id)\nawait snaptrude.presentation.viewPresets.rename(copy.id, \"Planning Issue B\")\n```"
-    ],
-    "argsType": "string",
-    "resultType": "PluginViewPreset"
-  },
-  {
-    "path": "presentation.viewPresets.create",
-    "namespace": "presentation.viewPresets",
-    "summary": "Save a kernel-plan drawing's effective styles as a new custom preset and bind that drawing to it. Not undoable (catalog write).",
-    "examplePrompts": [
-      "Save this drawing's styles as a new preset",
-      "Make a preset called Planning Issue from this plan",
-      "Turn my restyled drawing into a reusable style\n\n# Example\n```ts\nconst capabilities = await snaptrude.presentation.drawings.getCapabilities(drawing.id)\nif (capabilities.presets) {\nconst preset = await snaptrude.presentation.viewPresets.create(\"Planning Issue\", {\nfromDrawingId: drawing.id,\n})\n}\n```"
-    ],
-    "argsType": "string",
-    "resultType": "PluginViewPreset"
-  },
-  {
-    "path": "presentation.viewPresets.delete",
-    "namespace": "presentation.viewPresets",
-    "summary": "Delete a custom preset and rebind its drawings to another existing preset. Built-ins cannot be deleted. Not undoable (catalog write).",
-    "examplePrompts": [
-      "Delete this preset",
-      "Remove the old style preset and switch its drawings to the default",
-      "Get rid of the Planning Issue B preset\n\n# Example\n```ts\nconst presets = await snaptrude.presentation.viewPresets.list()\nconst replacement = presets.find((each) => each.builtIn)!\nawait snaptrude.presentation.viewPresets.delete(customPreset.id, {\nreplacementId: replacement.id,\n})\n```"
-    ],
-    "argsType": "string",
-    "resultType": "void"
-  },
-  {
-    "path": "presentation.viewPresets.get",
-    "namespace": "presentation.viewPresets",
-    "summary": "Read one preset by id.",
-    "examplePrompts": [
-      "Which preset is this drawing using?",
-      "Is this preset a built-in one?",
-      "Read the preset bound to the ground floor plan\n\n# Example\n```ts\nconst drawing = await snaptrude.presentation.drawings.get(drawingId)\nconst preset = drawing?.presetId\n? await snaptrude.presentation.viewPresets.get(drawing.presetId)\n: null\n```"
-    ],
-    "argsType": "string",
-    "resultType": "PluginViewPreset | null"
-  },
-  {
-    "path": "presentation.viewPresets.list",
-    "namespace": "presentation.viewPresets",
-    "summary": "List the preset catalog: built-ins first, then custom presets by name.",
-    "examplePrompts": [
-      "List the available drawing style presets",
-      "Which custom presets does this presentation have?",
-      "Is there a Planning Issue preset?\n\n# Example\n```ts\nconst presets = await snaptrude.presentation.viewPresets.list()\nconst custom = presets.filter((preset) => !preset.builtIn)\n```"
-    ],
-    "argsType": null,
-    "resultType": "PluginViewPreset[]"
-  },
-  {
-    "path": "presentation.viewPresets.rename",
-    "namespace": "presentation.viewPresets",
-    "summary": "Rename a custom preset. Names must stay unique; built-ins cannot be renamed. Not undoable (catalog write).",
-    "examplePrompts": [
-      "Rename this preset to Client Review",
-      "Call the copied preset Planning Issue B",
-      "Change the name of my custom drawing style\n\n# Example\n```ts\nawait snaptrude.presentation.viewPresets.rename(preset.id, \"Client Review\")\n```"
-    ],
-    "argsType": "string",
-    "resultType": "PluginViewPreset"
-  },
-  {
-    "path": "presentation.viewPresets.update",
-    "namespace": "presentation.viewPresets",
-    "summary": "Replace a custom preset's values with the effective styles of a drawing already bound to it, then refresh every bound drawing. Built-ins cannot be updated. Not undoable (catalog write).",
-    "examplePrompts": [
-      "Update this preset from the current drawing styles",
-      "Push my style changes to every drawing using this preset",
-      "Save these overrides into the Planning Issue preset\n\n# Example\n```ts\nawait snaptrude.presentation.viewPresets.update(drawing.presetId!, {\nfromDrawingId: drawing.id,\n})\n```"
-    ],
-    "argsType": "string",
-    "resultType": "PluginViewPreset"
-  },
   {
     "path": "presentation.views.capture",
     "namespace": "presentation.views",
@@ -9195,9 +7437,7 @@
       "What color mode is the Ground Floor view using?",
       "Get the display settings for this view",
       "Does the site plan view show axes and labels?",
-      "Read the background color of the active view",
-      "What is the cut height of this plan?",
-      "How deep does this plan look below the cut?\n\n# Example\n```ts\nconst settings = await snaptrude.presentation.views.getSettings(\"view_123\")\nif (settings) console.log(settings.colorMode, settings.backgroundColor)\n```"
+      "Read the background color of the active view\n\n# Example\n```ts\nconst settings = await snaptrude.presentation.views.getSettings(\"view_123\")\nif (settings) console.log(settings.colorMode, settings.backgroundColor)\n```"
     ],
     "argsType": "string",
     "resultType": "PluginPresentationViewsGetSettingsResult"
@@ -9208,7 +7448,7 @@
     "summary": "List the saved views in the active project.",
     "examplePrompts": [
       "List all the saved views",
-      "What plan, 3D, and elevation views are in this project?",
+      "What 2D and 3D views are in this project?",
       "Which view is currently active?",
       "Get the names of every presentation view",
       "Show me the 3D views I can put on a sheet\n\n# Example\n```ts\nconst { views } = await snaptrude.presentation.views.list()\nconst active = views.find((v) => v.isActive)\nconst plans = views.filter((v) => v.type === \"2d\")\n```"
@@ -9251,240 +7491,11 @@
       "Set the background of the active view to white",
       "Show area labels on this view",
       "Enable hidden-line mode for the section view",
-      "Make the 3D view orthographic instead of perspective",
-      "Raise the cut plane of the Ground Floor plan to 1.8 m",
-      "Show the basement below in this plan",
-      "Hide the overhead objects in this plan\n\n# Example\n```ts\nawait snaptrude.presentation.views.updateSettings(\"view_123\", {\ncolorMode: \"monochrome\",\nshowAxis: false,\n})\n// switch a 3D view to an isometric (orthographic) projection\nawait snaptrude.presentation.views.updateSettings(\"view_123\", {\nviewMode: \"isometric\",\n})\n// set a plan's range: cut 1.2 m up, show the basement below, no overhead\nawait snaptrude.presentation.views.updateSettings(\"plan_1\", {\ncutPlaneHeight: 4.72,\nviewDepthStorey: -1,\nshowOverheadObjects: false,\n})\n```"
+      "Make the 3D view orthographic instead of perspective\n\n# Example\n```ts\nawait snaptrude.presentation.views.updateSettings(\"view_123\", {\ncolorMode: \"monochrome\",\nshowAxis: false,\n})\n// switch a 3D view to an isometric (orthographic) projection\nawait snaptrude.presentation.views.updateSettings(\"view_123\", {\nviewMode: \"isometric\",\n})\n```"
     ],
     "argsType": "string",
     "resultType": "PluginPresentationViewsUpdateSettingsResult"
   },
-  {
-    "path": "presentation.walkthroughs.cancelJob",
-    "namespace": "presentation.walkthroughs",
-    "summary": "Cancel an export job. The recording stops and nothing is placed; a job that has already finished is returned unchanged. Write-gated.",
-    "examplePrompts": [
-      "Cancel the video export\n\n# Example\n```ts\nawait snaptrude.presentation.walkthroughs.cancelJob(jobId)\n```"
-    ],
-    "argsType": "string",
-    "resultType": "PluginWalkthroughExportJob"
-  },
-  {
-    "path": "presentation.walkthroughs.capture",
-    "namespace": "presentation.walkthroughs",
-    "summary": "Capture frames of a walkthrough as one contact-sheet image: a grid of views at evenly spaced moments (or at `options.timesInSeconds`), read left to right and top to bottom. The camera goes back to where it was afterwards. Switches from 2D plan view to 3D first.",
-    "examplePrompts": [
-      "Show me what the walkthrough looks like",
-      "Capture six frames of the fly-over\n\n# Example\n```ts\nconst { image } = await snaptrude.presentation.walkthroughs.capture(walkthroughId, {\ncount: 6,\n})\n```"
-    ],
-    "argsType": "string",
-    "resultType": "PluginWalkthroughCaptureResult"
-  },
-  {
-    "path": "presentation.walkthroughs.create",
-    "namespace": "presentation.walkthroughs",
-    "summary": "Create a walkthrough from full keyframes: where the camera stands at each and how it looks there (ahead along the path, at a target, or in a fixed direction). A keyframe that follows the floor stands at the walkthrough's eye height above the floor, stair, terrain or ground at or below its `eye`, and the path between two such keyframes climbs stairs and ramps. The new walkthrough opens in the walkthrough dock. Write-gated; one undo step.",
-    "examplePrompts": [
-      "Make a walkthrough through these three viewpoints",
-      "Create a camera path that looks at the atrium the whole way\n\n# Example\n```ts\nconst walkthrough = await snaptrude.presentation.walkthroughs.create(\n[\n{ eye: { x: 0, y: 30, z: 80 }, look: { mode: \"target\", target: { x: 0, y: 10, z: 0 } } },\n{ eye: { x: 60, y: 30, z: 0 }, look: { mode: \"target\", target: { x: 0, y: 10, z: 0 } } },\n],\n{ name: \"Approach\", durationInSeconds: 10 },\n)\n```"
-    ],
-    "argsType": "PluginWalkthroughKeyframeInput[]",
-    "resultType": "PluginWalkthrough"
-  },
-  {
-    "path": "presentation.walkthroughs.createFromPoints",
-    "namespace": "presentation.walkthroughs",
-    "summary": "Create a walkthrough that walks through points on the floor, the way the Walkthrough tool draws a route: the camera stands at eye height above the floor, stair, terrain or ground at each point, climbs stairs and ramps between them, and looks ahead along the path, or at `options.lookAt` the whole way. Write-gated; one undo step.",
-    "examplePrompts": [
-      "Walk from the entrance through the lobby to the stairs",
-      "Make a walkthrough that visits every room on this floor",
-      "Create a loop around the courtyard\n\n# Example\n```ts\nawait snaptrude.presentation.walkthroughs.createFromPoints(\n[{ x: 0, y: 0, z: 0 }, { x: 40, y: 0, z: 0 }, { x: 40, y: 0, z: 30 }],\n{ name: \"Ground floor tour\" },\n)\n```"
-    ],
-    "argsType": "Vec3Components[]",
-    "resultType": "PluginWalkthrough"
-  },
-  {
-    "path": "presentation.walkthroughs.createFromPreset",
-    "namespace": "presentation.walkthroughs",
-    "summary": "Create a walkthrough from a camera move around a subject, as the Walkthrough button's menu does: `orbit` circles it facing its middle, `flyOver` passes above it looking ahead and down, `pushIn` and `pullBack` move toward and away from it, and `rise` cranes up from eye level. The subject is `options.subject`, else the selection, else the visible model without its terrain; the move is sized to fit it in view and starts on the side the camera is on. While the walkthrough is still a preset, {@linkcode PluginPresentationWalkthroughsApi.update} can change its distance, height and direction; editing a keyframe makes it ordinary. Write-gated; one undo step.",
-    "examplePrompts": [
-      "Orbit around the selected building",
-      "Make a drone fly-over of the site",
-      "Push in slowly toward the entrance",
-      "Crane up to reveal the whole campus\n\n# Example\n```ts\nawait snaptrude.presentation.walkthroughs.createFromPreset(\"orbit\", {\nsubject: [towerId],\nheightInDegrees: 35,\ndurationInSeconds: 20,\n})\n```"
-    ],
-    "argsType": "PluginWalkthroughPresetKind",
-    "resultType": "PluginWalkthrough"
-  },
-  {
-    "path": "presentation.walkthroughs.createKeyframe",
-    "namespace": "presentation.walkthroughs",
-    "summary": "Add a keyframe to a walkthrough at `index` (0 to the keyframe count; default: the end). A preset walkthrough becomes ordinary. Write-gated; one undo step.",
-    "examplePrompts": [
-      "Add a stop in the kitchen after the second point\n\n# Example\n```ts\nawait snaptrude.presentation.walkthroughs.createKeyframe(\nwalkthroughId,\n{ eye: { x: 12, y: 0, z: 30 }, followsFloor: true, holdInSeconds: 2 },\n2,\n)\n```"
-    ],
-    "argsType": "string",
-    "resultType": "PluginWalkthrough"
-  },
-  {
-    "path": "presentation.walkthroughs.delete",
-    "namespace": "presentation.walkthroughs",
-    "summary": "Delete a walkthrough. Write-gated; one undo step.",
-    "examplePrompts": [
-      "Delete the old walkthrough\n\n# Example\n```ts\nawait snaptrude.presentation.walkthroughs.delete(walkthroughId)\n```"
-    ],
-    "argsType": "string",
-    "resultType": "boolean"
-  },
-  {
-    "path": "presentation.walkthroughs.deleteKeyframe",
-    "namespace": "presentation.walkthroughs",
-    "summary": "Remove a keyframe; the path then runs straight from the keyframe before it to the one after. Removing the last keyframe deletes the walkthrough. A preset walkthrough becomes ordinary. Write-gated; one undo step.",
-    "examplePrompts": [
-      "Remove the third stop from the walkthrough\n\n# Example\n```ts\nawait snaptrude.presentation.walkthroughs.deleteKeyframe(walkthroughId, keyframeId)\n```"
-    ],
-    "argsType": "string",
-    "resultType": "PluginWalkthrough | null"
-  },
-  {
-    "path": "presentation.walkthroughs.export",
-    "namespace": "presentation.walkthroughs",
-    "summary": "Record a walkthrough as a video and place it on the Present canvas, as an asynchronous job: this resolves at once with the queued job, and {@linkcode PluginPresentationWalkthroughsApi.getJob} reports it until it completes, fails or is cancelled. Recording plays the walkthrough in real time at the chosen size, so it takes about as long as the walkthrough plus the upload; the editor switches to Present mode to place the video, which keeps playing muted in a loop there. Only one export runs at a time. Write-gated.",
-    "examplePrompts": [
-      "Export the walkthrough as a video",
-      "Put a 1080p video of the orbit on a sheet\n\n# Example\n```ts\nconst walkthroughs = snaptrude.presentation.walkthroughs\nlet job = await walkthroughs.export(walkthroughId, { quality: \"1080p\" })\nwhile (job.status === \"queued\" || job.status === \"running\") {\nawait new Promise((resolve) => setTimeout(resolve, 2000))\njob = (await walkthroughs.getJob(job.jobId))!\n}\nconsole.log(job.result?.shapeId)\n```"
-    ],
-    "argsType": "string",
-    "resultType": "PluginWalkthroughExportJob"
-  },
-  {
-    "path": "presentation.walkthroughs.get",
-    "namespace": "presentation.walkthroughs",
-    "summary": "Get one walkthrough by id.",
-    "examplePrompts": [
-      "Show me the keyframes of the orbit walkthrough",
-      "How long does this walkthrough take?\n\n# Example\n```ts\nconst walkthrough = await snaptrude.presentation.walkthroughs.get(walkthroughId)\nconsole.log(walkthrough?.durationInSeconds)\n```"
-    ],
-    "argsType": "string",
-    "resultType": "PluginWalkthrough | null"
-  },
-  {
-    "path": "presentation.walkthroughs.getJob",
-    "namespace": "presentation.walkthroughs",
-    "summary": "Get an export job by id.",
-    "examplePrompts": [
-      "Is the video export done yet?\n\n# Example\n```ts\nconst job = await snaptrude.presentation.walkthroughs.getJob(jobId)\n```"
-    ],
-    "argsType": "string",
-    "resultType": "PluginWalkthroughExportJob | null"
-  },
-  {
-    "path": "presentation.walkthroughs.getState",
-    "namespace": "presentation.walkthroughs",
-    "summary": "Read the playback state: which walkthrough is playing or paused, and how far through it.",
-    "examplePrompts": [
-      "Is the walkthrough still playing?\n\n# Example\n```ts\nconst { status, timeInSeconds } = await snaptrude.presentation.walkthroughs.getState()\n```"
-    ],
-    "argsType": null,
-    "resultType": "PluginWalkthroughPlaybackState"
-  },
-  {
-    "path": "presentation.walkthroughs.list",
-    "namespace": "presentation.walkthroughs",
-    "summary": "List the open project's walkthroughs, oldest first.",
-    "examplePrompts": [
-      "Which walkthroughs are there?",
-      "List the camera paths in this project\n\n# Example\n```ts\nconst { walkthroughs } = await snaptrude.presentation.walkthroughs.list()\n```"
-    ],
-    "argsType": null,
-    "resultType": "PluginWalkthroughsListResult"
-  },
-  {
-    "path": "presentation.walkthroughs.listIssues",
-    "namespace": "presentation.walkthroughs",
-    "summary": "Find places where a walkthrough's camera passes through the model: through anything walking would stop at, such as a wall, glazing, a column, a slab or a roof, which would show the inside of the geometry on screen. Doors, furniture and room masses don't count, as walking passes through them. Each issue gives the first moment and point of one pass. The camera itself does not move.",
-    "examplePrompts": [
-      "Does the walkthrough go through any walls?",
-      "Check the camera path for clashes and fix them\n\n# Example\n```ts\nconst { issues } = await snaptrude.presentation.walkthroughs.listIssues(walkthroughId)\nfor (const issue of issues) console.log(issue.timeInSeconds, issue.componentId)\n```"
-    ],
-    "argsType": "string",
-    "resultType": "PluginWalkthroughListIssuesResult"
-  },
-  {
-    "path": "presentation.walkthroughs.listJobs",
-    "namespace": "presentation.walkthroughs",
-    "summary": "List export jobs, newest first: running ones and those that finished in the last 30 minutes.",
-    "examplePrompts": [
-      "Which video exports are running?\n\n# Example\n```ts\nconst { jobs } = await snaptrude.presentation.walkthroughs.listJobs()\n```"
-    ],
-    "argsType": null,
-    "resultType": "PluginWalkthroughListJobsResult"
-  },
-  {
-    "path": "presentation.walkthroughs.reorderKeyframe",
-    "namespace": "presentation.walkthroughs",
-    "summary": "Move a keyframe to position `index` in the walkthrough's order (the `presentation.sheets.reorder` convention). A preset walkthrough becomes ordinary. Write-gated; one undo step.",
-    "examplePrompts": [
-      "Visit the terrace before the living room\n\n# Example\n```ts\nawait snaptrude.presentation.walkthroughs.reorderKeyframe(walkthroughId, keyframeId, 0)\n```"
-    ],
-    "argsType": "string",
-    "resultType": "PluginWalkthrough"
-  },
-  {
-    "path": "presentation.walkthroughs.sample",
-    "namespace": "presentation.walkthroughs",
-    "summary": "Sample where the camera is and which way it looks at given moments of a walkthrough's playback, without moving the camera.",
-    "examplePrompts": [
-      "Where is the camera halfway through the walkthrough?",
-      "Check how high the camera flies over the roof\n\n# Example\n```ts\nconst walkthrough = await snaptrude.presentation.walkthroughs.get(walkthroughId)\nconst { samples } = await snaptrude.presentation.walkthroughs.sample(walkthroughId, [\n0,\nwalkthrough!.durationInSeconds / 2,\n])\n```"
-    ],
-    "argsType": "string",
-    "resultType": "PluginWalkthroughSampleResult"
-  },
-  {
-    "path": "presentation.walkthroughs.start",
-    "namespace": "presentation.walkthroughs",
-    "summary": "Play a walkthrough in the viewport, from the start or `options.fromTimeInSeconds`. Arrow-key navigation pauses while it plays; {@linkcode PluginPresentationWalkthroughsApi.stop} puts the camera back where it was. Switches from 2D plan view to 3D first. Resolves once playback has started; a walkthrough that is already playing keeps playing.",
-    "examplePrompts": [
-      "Play the walkthrough",
-      "Show me the orbit\n\n# Example\n```ts\nawait snaptrude.presentation.walkthroughs.start(walkthroughId)\n```"
-    ],
-    "argsType": "string",
-    "resultType": "PluginWalkthroughPlaybackState"
-  },
-  {
-    "path": "presentation.walkthroughs.stop",
-    "namespace": "presentation.walkthroughs",
-    "summary": "Stop playback and put the camera back where it was before it started. A no-op when nothing is playing.",
-    "examplePrompts": [
-      "Stop the walkthrough\n\n# Example\n```ts\nawait snaptrude.presentation.walkthroughs.stop()\n```"
-    ],
-    "argsType": null,
-    "resultType": "PluginWalkthroughPlaybackState"
-  },
-  {
-    "path": "presentation.walkthroughs.update",
-    "namespace": "presentation.walkthroughs",
-    "summary": "Change a walkthrough: only the fields given change. Speed and duration are two ways to set one thing, so give at most one of them. `preset` changes a preset walkthrough's camera move and makes its keyframes again, keeping its duration; changing `isLoop` of a preset walkthrough makes it ordinary. Write-gated; one undo step.",
-    "examplePrompts": [
-      "Slow the walkthrough down to 30 seconds",
-      "Rename it to \"Evening approach\"",
-      "Make the orbit go the other way round and higher up\n\n# Example\n```ts\nawait snaptrude.presentation.walkthroughs.update(walkthroughId, {\ndurationInSeconds: 30,\nisRepeating: true,\n})\n```"
-    ],
-    "argsType": "string",
-    "resultType": "PluginWalkthrough"
-  },
-  {
-    "path": "presentation.walkthroughs.updateKeyframe",
-    "namespace": "presentation.walkthroughs",
-    "summary": "Change a keyframe: only the fields given change. A preset walkthrough becomes ordinary. Write-gated; one undo step.",
-    "examplePrompts": [
-      "Pause for three seconds at the second point",
-      "Make the last point look at the fireplace\n\n# Example\n```ts\nawait snaptrude.presentation.walkthroughs.updateKeyframe(walkthroughId, keyframeId, {\nlook: { mode: \"target\", target: { x: 5, y: 4, z: 10 } },\n})\n```"
-    ],
-    "argsType": "string",
-    "resultType": "PluginWalkthrough"
-  },
   {
     "path": "program.adjacency.compute",
     "namespace": "program.adjacency",