@snaptrude/plugin-core 0.7.1 → 0.8.0

package/api-manifest.json

@@ -1,4 +1,244 @@
 [
+  {
+    "path": "analysis.heatmaps.isActive",
+    "namespace": "analysis.heatmaps",
+    "summary": "Is a plugin heatmap currently showing?",
+    "examplePrompts": [
+      "Is my heatmap still showing?",
+      "Check whether the custom heatmap is active",
+      "Do I need to re-render the wind overlay?\n\n# Example\n```ts\nif (!(await snaptrude.analysis.heatmaps.isActive())) {\nawait snaptrude.analysis.heatmaps.renderGrid(cells, 2)\n}\n```"
+    ],
+    "argsType": null,
+    "resultType": "boolean"
+  },
+  {
+    "path": "analysis.heatmaps.renderGrid",
+    "namespace": "analysis.heatmaps",
+    "summary": "Render a grid heatmap — a coloured mesh from point samples.",
+    "examplePrompts": [
+      "Overlay my CFD wind simulation results on the site",
+      "Render a noise-level grid around the building",
+      "Show these sampled microclimate values as a colored grid\n\n# Example\n```ts\n// World coordinates are y-up: a ground-level field varies in x/z at y = 0.\nawait snaptrude.analysis.heatmaps.renderGrid(\nsamples.map((s) => ({ position: { x: s.x, y: 0, z: s.z }, value: s.windSpeed })),\n2, // 2-unit square cells\n{ title: \"Wind speed\", unit: \"m/s\", colors: [\"#0000ff\", \"#00ff00\", \"#ff0000\"] },\n)\n```"
+    ],
+    "argsType": "PluginAnalysisHeatmapGridCell[]",
+    "resultType": "PluginAnalysisHeatmapsRenderResult"
+  },
+  {
+    "path": "analysis.heatmaps.renderSpaces",
+    "namespace": "analysis.heatmaps",
+    "summary": "Render a per-space heatmap — one flat colour per space's top face.",
+    "examplePrompts": [
+      "Color each room by its occupancy count",
+      "Show my energy simulation results as a heatmap per space",
+      "Paint the rooms red to blue by temperature\n\n# Example\n```ts\nconst spaces = await snaptrude.design.query.listSpaces()\nawait snaptrude.analysis.heatmaps.renderSpaces(\nspaces.map((space) => ({ space, value: occupancy[space] ?? 0 })),\n{ title: \"Occupancy\", unit: \"people\", min: 0, max: 50 },\n)\n```"
+    ],
+    "argsType": "PluginAnalysisHeatmapSpaceEntry[]",
+    "resultType": "PluginAnalysisHeatmapsRenderResult"
+  },
+  {
+    "path": "analysis.heatmaps.reset",
+    "namespace": "analysis.heatmaps",
+    "summary": "Clear the plugin heatmap from the scene.",
+    "examplePrompts": [
+      "Clear my custom heatmap",
+      "Remove the wind overlay from the model",
+      "Reset the plugin heatmap view\n\n# Example\n```ts\nawait snaptrude.analysis.heatmaps.reset()\n```"
+    ],
+    "argsType": null,
+    "resultType": "boolean"
+  },
+  {
+    "path": "analysis.illuminance.cancel",
+    "namespace": "analysis.illuminance",
+    "summary": "Cancel the in-flight illuminance run.",
+    "examplePrompts": [
+      "Cancel the illuminance analysis",
+      "Stop the running daylight computation",
+      "Abort the lux study\n\n# Example\n```ts\nawait snaptrude.analysis.illuminance.cancel()\n```"
+    ],
+    "argsType": null,
+    "resultType": "boolean"
+  },
+  {
+    "path": "analysis.illuminance.compute",
+    "namespace": "analysis.illuminance",
+    "summary": "Start a daylight-illuminance run for a date range.",
+    "examplePrompts": [
+      "Run a daylight illuminance analysis for December",
+      "Compute the lux levels inside the building for winter",
+      "How much daylight do the interior floors get?\n\n# Example\n```ts\nconst { success } = await snaptrude.analysis.illuminance.compute(\n\"2026-12-01\",\n\"2026-12-31\",\n)\n// poll until the heatmap is rendered\nlet job = await snaptrude.analysis.illuminance.get()\nwhile (job?.status === \"running\") {\nawait new Promise((r) => setTimeout(r, 5000))\njob = await snaptrude.analysis.illuminance.get()\n}\n```"
+    ],
+    "argsType": "string",
+    "resultType": "PluginAnalysisComputeResult"
+  },
+  {
+    "path": "analysis.illuminance.get",
+    "namespace": "analysis.illuminance",
+    "summary": "Get the state of the illuminance study.",
+    "examplePrompts": [
+      "Is the illuminance analysis done?",
+      "Check the status of the daylight lux run",
+      "What date range was the illuminance heatmap computed for?\n\n# Example\n```ts\nconst job = await snaptrude.analysis.illuminance.get()\nif (job?.status === \"active\") console.log(job.startDate, job.endDate)\n```"
+    ],
+    "argsType": null,
+    "resultType": "PluginAnalysisJobStateResult"
+  },
+  {
+    "path": "analysis.illuminance.reset",
+    "namespace": "analysis.illuminance",
+    "summary": "Clear the illuminance heatmap from the scene.",
+    "examplePrompts": [
+      "Clear the illuminance heatmap",
+      "Remove the daylight lux colours from the model",
+      "Reset the illuminance analysis view\n\n# Example\n```ts\nawait snaptrude.analysis.illuminance.reset()\n```"
+    ],
+    "argsType": null,
+    "resultType": "boolean"
+  },
+  {
+    "path": "analysis.shadows.disable",
+    "namespace": "analysis.shadows",
+    "summary": "Turn real-time sun shadows OFF.",
+    "examplePrompts": [
+      "Turn off shadows",
+      "Hide the sun shadows",
+      "Disable shadow rendering in the scene\n\n# Example\n```ts\nawait snaptrude.analysis.shadows.disable()\n```"
+    ],
+    "argsType": null,
+    "resultType": "boolean"
+  },
+  {
+    "path": "analysis.shadows.enable",
+    "namespace": "analysis.shadows",
+    "summary": "Turn real-time sun shadows ON, optionally at a specific date and time.",
+    "examplePrompts": [
+      "Turn on shadows",
+      "Show the shadows at 3pm on June 21st",
+      "Enable sun shadows for the summer solstice afternoon\n\n# Example\n```ts\nawait snaptrude.analysis.shadows.enable({ dateTime: \"2026-06-21T15:00\" })\n```"
+    ],
+    "argsType": "PluginAnalysisShadowsEnableOptions",
+    "resultType": "boolean"
+  },
+  {
+    "path": "analysis.shadows.getDateTime",
+    "namespace": "analysis.shadows",
+    "summary": "Get the sun's current date and time.",
+    "examplePrompts": [
+      "What date and time are the shadows set to?",
+      "Get the current sun position date",
+      "Which time of day is the shadow study showing?\n\n# Example\n```ts\nconst dateTime = await snaptrude.analysis.shadows.getDateTime()\n```"
+    ],
+    "argsType": null,
+    "resultType": "PluginAnalysisShadowsDateTimeResult"
+  },
+  {
+    "path": "analysis.shadows.isEnabled",
+    "namespace": "analysis.shadows",
+    "summary": "Whether real-time sun shadows are currently enabled.",
+    "examplePrompts": [
+      "Are shadows on?",
+      "Check whether sun shadows are enabled",
+      "Is the scene showing shadows right now?\n\n# Example\n```ts\nconst on = await snaptrude.analysis.shadows.isEnabled()\n```"
+    ],
+    "argsType": null,
+    "resultType": "boolean"
+  },
+  {
+    "path": "analysis.shadows.setDateTime",
+    "namespace": "analysis.shadows",
+    "summary": "Move the sun to a specific date and time.",
+    "examplePrompts": [
+      "Set the shadow time to 9:30 am on the winter solstice",
+      "Move the sun to noon on March 1st",
+      "Change the shadow study date to December 21\n\n# Example\n```ts\nconst applied = await snaptrude.analysis.shadows.setDateTime(\"2026-12-21T09:30\")\nconsole.log(applied) // \"2026-12-21T09:30\" (snapped to the half-hour grid)\n```"
+    ],
+    "argsType": "string",
+    "resultType": "PluginAnalysisShadowsDateTimeResult"
+  },
+  {
+    "path": "analysis.sunlightHours.cancel",
+    "namespace": "analysis.sunlightHours",
+    "summary": "Cancel the in-flight sunlight-hours run.",
+    "examplePrompts": [
+      "Cancel the sunlight analysis",
+      "Stop the running sunlight hours computation",
+      "Abort the sun study\n\n# Example\n```ts\nawait snaptrude.analysis.sunlightHours.cancel()\n```"
+    ],
+    "argsType": null,
+    "resultType": "boolean"
+  },
+  {
+    "path": "analysis.sunlightHours.compute",
+    "namespace": "analysis.sunlightHours",
+    "summary": "Start a direct-sunlight-hours run for a date range.",
+    "examplePrompts": [
+      "Run a sunlight hours analysis for June",
+      "Compute direct sunlight hours between March and September",
+      "How much sun does my building get over the summer?\n\n# Example\n```ts\nconst { success } = await snaptrude.analysis.sunlightHours.compute(\n\"2026-06-01\",\n\"2026-06-30\",\n)\n// poll until the heatmap is rendered\nlet job = await snaptrude.analysis.sunlightHours.get()\nwhile (job?.status === \"running\") {\nawait new Promise((r) => setTimeout(r, 5000))\njob = await snaptrude.analysis.sunlightHours.get()\n}\n```"
+    ],
+    "argsType": "string",
+    "resultType": "PluginAnalysisComputeResult"
+  },
+  {
+    "path": "analysis.sunlightHours.get",
+    "namespace": "analysis.sunlightHours",
+    "summary": "Get the state of the sunlight-hours study.",
+    "examplePrompts": [
+      "Is the sunlight analysis done?",
+      "Check the status of the sunlight hours run",
+      "What date range was the sunlight heatmap computed for?\n\n# Example\n```ts\nconst job = await snaptrude.analysis.sunlightHours.get()\nif (job?.status === \"active\") console.log(job.startDate, job.endDate)\n```"
+    ],
+    "argsType": null,
+    "resultType": "PluginAnalysisJobStateResult"
+  },
+  {
+    "path": "analysis.sunlightHours.reset",
+    "namespace": "analysis.sunlightHours",
+    "summary": "Clear the sunlight-hours heatmap from the scene.",
+    "examplePrompts": [
+      "Clear the sunlight heatmap",
+      "Remove the sun hours colours from the model",
+      "Reset the sunlight analysis view\n\n# Example\n```ts\nawait snaptrude.analysis.sunlightHours.reset()\n```"
+    ],
+    "argsType": null,
+    "resultType": "boolean"
+  },
+  {
+    "path": "analysis.sunpath.disable",
+    "namespace": "analysis.sunpath",
+    "summary": "Turn the sun-path diagram overlay OFF.",
+    "examplePrompts": [
+      "Hide the sun path diagram",
+      "Turn off the sunpath overlay",
+      "Remove the sun trajectory arcs from the scene\n\n# Example\n```ts\nawait snaptrude.analysis.sunpath.disable()\n```"
+    ],
+    "argsType": null,
+    "resultType": "boolean"
+  },
+  {
+    "path": "analysis.sunpath.enable",
+    "namespace": "analysis.sunpath",
+    "summary": "Turn the sun-path diagram overlay ON.",
+    "examplePrompts": [
+      "Show the sun path diagram",
+      "Turn on the sunpath overlay",
+      "Visualize the sun's trajectory over my building\n\n# Example\n```ts\nawait snaptrude.analysis.sunpath.enable()\nconst active = await snaptrude.analysis.sunpath.isActive() // true\n```"
+    ],
+    "argsType": null,
+    "resultType": "boolean"
+  },
+  {
+    "path": "analysis.sunpath.isActive",
+    "namespace": "analysis.sunpath",
+    "summary": "Whether the sun-path diagram overlay is currently active.",
+    "examplePrompts": [
+      "Is the sun path diagram on?",
+      "Check whether the sunpath overlay is active",
+      "Am I looking at the sun trajectory right now?\n\n# Example\n```ts\nif (!(await snaptrude.analysis.sunpath.isActive())) {\nawait snaptrude.analysis.sunpath.enable()\n}\n```"
+    ],
+    "argsType": null,
+    "resultType": "boolean"
+  },
   {
     "path": "core.buildings.copy",
     "namespace": "core.buildings",
@@ -107,6 +347,71 @@
     "argsType": "string",
     "resultType": "PluginCoreBuildingsUpdateResult"
   },
+  {
+    "path": "core.camera.getProjection",
+    "namespace": "core.camera",
+    "summary": "Read the camera's current projection: `\"perspective\"` (the default 3D view) or `\"orthographic\"`. In 2D (plan) mode this always reports `\"orthographic\"` — a plan is an orthographic projection.",
+    "examplePrompts": [
+      "Is the camera in perspective or orthographic?",
+      "What projection is the 3D view using?",
+      "Check whether perspective is on\n\n# Example\n```ts\nconst projection = await snaptrude.core.camera.getProjection()\nconsole.log(projection) // \"perspective\" | \"orthographic\"\n```"
+    ],
+    "argsType": null,
+    "resultType": "PluginCameraProjection"
+  },
+  {
+    "path": "core.camera.lookFrom",
+    "namespace": "core.camera",
+    "summary": "Point the camera: place its eye at `eye` looking toward `target` (world coordinates, internal `babylon` units). View-state only — not undoable.",
+    "examplePrompts": [
+      "Look at the model from above the north-east corner",
+      "Position the camera at (50, 30, 50) looking at the origin",
+      "Point the camera at the centre of the building from the side",
+      "Set the eye to this point and aim it at that point\n\n# Example\n```ts\nconst { vec3 } = snaptrude.core.math\nawait snaptrude.core.camera.lookFrom(vec3.new(50, 30, 50), vec3.new(0, 0, 0))\n```"
+    ],
+    "argsType": "Vec3Handle",
+    "resultType": "boolean"
+  },
+  {
+    "path": "core.camera.setMode",
+    "namespace": "core.camera",
+    "summary": "Toggle the modelling mode between `2d` (plan) and `3d`. Mirrors the canvas 2D/3D toggle: `3d` enters the isometric perspective view, `2d` drops to the orthographic plan of the active storey. View-state only — not undoable.",
+    "examplePrompts": [
+      "Switch to 3D view",
+      "Drop into 2D plan mode",
+      "Go back to 3D",
+      "Show the floor plan in 2D\n\n# Example\n```ts\nawait snaptrude.core.camera.setMode(\"3d\")\n```"
+    ],
+    "argsType": "PluginCameraMode",
+    "resultType": "boolean"
+  },
+  {
+    "path": "core.camera.setProjection",
+    "namespace": "core.camera",
+    "summary": "Switch the 3D camera between `\"perspective\"` and `\"orthographic\"` projection — the Perspective/Orthographic control in the Design tab's View Settings panel. Like {@linkcode PluginCameraApi.setMode}, this is a transient view-state change: not write-gated, not undoable.",
+    "examplePrompts": [
+      "Switch the camera to orthographic",
+      "Turn perspective off",
+      "Give me a perspective view of the model",
+      "Make the 3D view orthographic like an axonometric drawing\n\n# Example\n```ts\nawait snaptrude.core.camera.setProjection(\"orthographic\")\nconst projection = await snaptrude.core.camera.getProjection() // \"orthographic\"\n```"
+    ],
+    "argsType": "PluginCameraProjection",
+    "resultType": "boolean"
+  },
+  {
+    "path": "core.camera.setStandardView",
+    "namespace": "core.camera",
+    "summary": "Snap the camera to a standard view — the five orthographic elevations (`top` / `front` / `back` / `left` / `right`) or the 3D `iso` (isometric perspective) view. Mirrors the canvas view menu. View-state only — not undoable. The orthographic presets exit 2D mode first if needed.",
+    "examplePrompts": [
+      "Switch to the top view",
+      "Show me the front elevation",
+      "Go to the isometric view",
+      "Look at the model from the left",
+      "Give me a plan view from the top\n\n# Example\n```ts\nawait snaptrude.core.camera.setStandardView(\"top\")\n```"
+    ],
+    "argsType": "PluginStandardView",
+    "resultType": "boolean"
+  },
   {
     "path": "core.comment.create",
     "namespace": "core.comment",
@@ -133,6 +438,19 @@
     "argsType": "CommentHandle",
     "resultType": "boolean"
   },
+  {
+    "path": "core.comment.get",
+    "namespace": "core.comment",
+    "summary": "Read a comment's full detail — its text, author, pin location, resolved state, and reply thread. Comments are otherwise write-only; this is the read side. Pass a top-level comment handle or a reply handle (a reply has an empty `thread`). Returns `null` if the handle doesn't match a live comment.",
+    "examplePrompts": [
+      "Read the comment on this wall and tell me what it says",
+      "Who left this comment and where is it pinned?",
+      "Show me the full thread for this comment",
+      "Get the text and author of the selected comment\n\n# Example\n```ts\nconst [first] = await snaptrude.core.comment.list()\nconst details = await snaptrude.core.comment.get(first)\nconsole.log(details?.content, \"by\", details?.author?.name)\nconsole.log(`${details?.thread.length ?? 0} replies`)\n```"
+    ],
+    "argsType": "CommentHandle",
+    "resultType": "PluginCommentDetails | null"
+  },
   {
     "path": "core.comment.isResolved",
     "namespace": "core.comment",
@@ -172,6 +490,19 @@
     "argsType": "CommentHandle",
     "resultType": "boolean"
   },
+  {
+    "path": "core.comment.reply",
+    "namespace": "core.comment",
+    "summary": "Reply to a comment — posts a new comment threaded under `comment` (which must be a top-level comment, not itself a reply). Notifies the thread's participants, mirroring the sidebar Reply action.",
+    "examplePrompts": [
+      "Reply to this comment saying I fixed the wall height",
+      "Add a reply to the review note confirming it's done",
+      "Respond to the comment about the door with \"looks good now\"",
+      "Post a follow-up on the selected comment thread\n\n# Example\n```ts\nconst [thread] = await snaptrude.core.comment.list()\nconst reply = await snaptrude.core.comment.reply(thread, \"Fixed 👍\")\n```"
+    ],
+    "argsType": "CommentHandle",
+    "resultType": "CommentHandle"
+  },
   {
     "path": "core.comment.resolve",
     "namespace": "core.comment",
@@ -1783,6 +2114,46 @@
     "argsType": "string",
     "resultType": "PluginCoreGroupsUpdateResult"
   },
+  {
+    "path": "core.handles.beginScope",
+    "namespace": "core.handles",
+    "summary": "Open a mint-recording scope: every arena handle MINTED after this call (fresh mints only — identity-deduped re-registrations of pre-existing objects are not captured) is freed when the matching {@linkcode endScope} runs. Scopes nest, up to 64 deep — always pair begin/end in try/finally.",
+    "examplePrompts": [],
+    "argsType": null,
+    "resultType": "ScopeToken"
+  },
+  {
+    "path": "core.handles.endScope",
+    "namespace": "core.handles",
+    "summary": "Close a scope by its token and free every handle it recorded, except those listed in `retain`. Retained handles are promoted to the enclosing scope (if any), so nesting composes like block scopes. Closing is token-addressed: an out-of-order close (interleaved async tasks) frees only that scope's mints and leaves other open scopes intact. Always pair begin/end in try/finally so a thrown body cannot leak the scope.",
+    "examplePrompts": [],
+    "argsType": "ScopeToken",
+    "resultType": "void"
+  },
+  {
+    "path": "core.handles.release",
+    "namespace": "core.handles",
+    "summary": "Free arena handles in bulk. Unknown, foreign, or already-released ids are silent no-ops — there is no per-id result and no count, so responses can never be used as an existence oracle.",
+    "examplePrompts": [],
+    "argsType": "ReadonlyArray<AnyArenaHandle>",
+    "resultType": "void"
+  },
+  {
+    "path": "core.handles.releaseAll",
+    "namespace": "core.handles",
+    "summary": "Free every live arena handle of one kind, or ALL arena handles when the kind is omitted. Useful at batch boundaries — e.g. a poll loop that mints a fresh footprint contour per tick.",
+    "examplePrompts": [],
+    "argsType": "ArenaKind",
+    "resultType": "void"
+  },
+  {
+    "path": "core.handles.stats",
+    "namespace": "core.handles",
+    "summary": "Live handle-registry statistics for the calling plugin, plus the host page's JS heap usage (when the browser exposes it). Diagnostic surface for verifying that releases actually shrink host memory.",
+    "examplePrompts": [],
+    "argsType": null,
+    "resultType": "PluginHandlesStatsResult"
+  },
   {
     "path": "core.history.redo",
     "namespace": "core.history",
@@ -1811,112 +2182,551 @@
     "resultType": "PluginHistoryStepResult"
   },
   {
-    "path": "core.layers.get",
-    "namespace": "core.layers",
-    "summary": "Get a single drawing layer by id.",
+    "path": "core.io.export.model",
+    "namespace": "core.io.export",
+    "summary": "Export the model to a 3D file and return its bytes as base64.",
     "examplePrompts": [
-      "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```"
+      "Export the model as a GLB",
+      "Give me the whole scene as an OBJ file",
+      "Export just my selection to GLB",
+      "Download the model as an FBX file",
+      "Export the scene to 3DS for 3ds Max\n\n# Example\n```ts\nconst file = await snaptrude.core.io.export.model(\"glb\")\n// decode base64 → bytes and save/download in the plugin UI\nconst bytes = Uint8Array.from(atob(file.dataBase64), (c) => c.charCodeAt(0))\nconst blob = new Blob([bytes], { type: file.mimeType })\n// ...offer blob for download as file.fileName\n\n// Only the current selection, as OBJ text:\nconst obj = await snaptrude.core.io.export.model(\"obj\", \"selection\")\nconst text = atob(obj.dataBase64)\n```"
     ],
-    "argsType": "string",
-    "resultType": "PluginCoreLayersGetResult"
+    "argsType": "ExportModelFormat",
+    "resultType": "ExportedFile"
   },
   {
-    "path": "core.layers.getActive",
-    "namespace": "core.layers",
-    "summary": "Get the active drawing layer of a storey.",
+    "path": "core.io.import.cadJson",
+    "namespace": "core.io.import",
+    "summary": "Sketch a CAD underlay from **already-parsed CAD JSON** — synchronous, with no server round-trip. Use this when you hold parsed CAD data (e.g. produced by your own converter); use {@link PluginCoreIoImportApi.dwg} for raw `.dwg` files.",
     "examplePrompts": [
-      "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```"
+      "Sketch this parsed CAD JSON onto the active storey",
+      "Draw these CAD curves as an underlay on storey 2",
+      "Create a CAD sketch from this geometry data",
+      "Import my converted CAD JSON onto the ground floor\n\n# Example\n```ts\nconst cad = await snaptrude.core.io.import.cadJson(\n{ unit: \"mm\", geometry: [{ type: \"line\", layer: \"WALLS\", ... }] },\n1,\n)\n```"
+    ],
+    "argsType": "CadJsonInput",
+    "resultType": "UnderlayHandle"
+  },
+  {
+    "path": "core.io.import.dwg",
+    "namespace": "core.io.import",
+    "summary": "Import a **DWG** CAD drawing as a scene underlay. `.dwg` only (no DXF).",
+    "examplePrompts": [
+      "Import this DWG floor plan onto storey 1",
+      "Bring in a CAD drawing as an underlay and tell me when it's ready",
+      "Start importing this CAD file onto the ground floor\n\n# Example\n```ts\nconst job = await snaptrude.core.io.import.dwg(\"https://example.com/plan.dwg\", 1)\n// Poll until the server-side conversion finishes — always with a timeout\n// (a UI-cancelled import stays \"processing\" forever).\nconst deadline = Date.now() + 5 * 60_000\nwhile (!(await snaptrude.core.io.job.isComplete(job))) {\nif (Date.now() > deadline) throw new Error(\"DWG import timed out\")\nawait new Promise((r) => setTimeout(r, 2000))\n}\n// The DWG lands as a CAD underlay. CAD scaling isn't supported; manage it\n// (list / fade / delete) via core.io.underlay.*.\nconst cad = await snaptrude.core.io.job.getResult(job)\nif (cad) console.log(\"DWG imported as CAD underlay:\", cad)\n```"
     ],
     "argsType": "string",
-    "resultType": "PluginCoreLayersGetActiveResult"
+    "resultType": "ImportJobHandle"
   },
   {
-    "path": "core.layers.list",
-    "namespace": "core.layers",
-    "summary": "List the drawing layers of a storey.",
+    "path": "core.io.import.image",
+    "namespace": "core.io.import",
+    "summary": "Import a raster image as a scene **underlay** — a flat, textured reference plane placed on a storey that you can trace over.",
     "examplePrompts": [
-      "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```"
+      "Import this floor plan image onto the ground floor to trace over",
+      "Drop this survey PNG in as a reference underlay at 30% opacity",
+      "Add a site plan image on storey 2",
+      "Bring in a sketch to trace, faded to half opacity\n\n# Example\n```ts\n// Place a floor plan on storey 1, then calibrate it to a real-world size.\nconst plan = await snaptrude.core.io.import.image(\n\"https://example.com/floorplan.png\",\n1,           // storey\nundefined,   // scale\n0.4,         // opacity\n\"Ground floor plan\",\n)\n// Make the plan's longest side exactly 40 project-units:\nawait snaptrude.core.io.underlay.setScale(plan, { planSize: 40 })\n```"
     ],
     "argsType": "string",
-    "resultType": "PluginCoreLayersListResult"
+    "resultType": "UnderlayHandle"
   },
   {
-    "path": "core.layers.setActive",
-    "namespace": "core.layers",
-    "summary": "Make a drawing layer the active layer of its storey.",
+    "path": "core.io.import.model",
+    "namespace": "core.io.import",
+    "summary": "Import a **3D model** file and place it in the scene as a component.",
     "examplePrompts": [
-      "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```"
+      "Import this SketchUp model onto storey 1",
+      "Bring in this OBJ file and place it at the origin",
+      "Add this 3D model to the ground floor\n\n# Example\n```ts\nconst model = await snaptrude.core.io.import.model(\n\"https://example.com/tree.skp\",\n1,        // storey\n\"skp\",\n)\n```"
     ],
     "argsType": "string",
-    "resultType": "PluginCoreLayersSetActiveResult"
+    "resultType": "ComponentHandle"
   },
   {
-    "path": "core.layers.update",
-    "namespace": "core.layers",
-    "summary": "Update a drawing layer's visibility.",
+    "path": "core.io.import.pdf",
+    "namespace": "core.io.import",
+    "summary": "Import one page of a PDF as a scene **underlay** (a traceable reference plane).",
     "examplePrompts": [
-      "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```"
+      "Import page 1 of this PDF floor plan onto storey 1",
+      "Bring in the second page of this PDF as an underlay at 1:50",
+      "Add this PDF plan to the ground floor to trace over",
+      "Place page 3 of the drawing set on storey 3\n\n# Example\n```ts\nconst sheet = await snaptrude.core.io.import.pdf(\n\"https://example.com/plans.pdf\",\n1,        // storey\n2,        // page\n\"1:100\",  // drawing scale\n)\n```"
     ],
     "argsType": "string",
-    "resultType": "PluginCoreLayersUpdateResult"
+    "resultType": "UnderlayHandle"
   },
   {
-    "path": "core.math.quat.components",
-    "namespace": "core.math.quat",
-    "summary": "Read the primitive `{ x, y, z, w }` components of a quaternion handle.",
-    "examplePrompts": [],
-    "argsType": "QuatHandle",
-    "resultType": "QuatComponents"
+    "path": "core.io.import.terrain",
+    "namespace": "core.io.import",
+    "summary": "Import **site terrain** for a location — Mapbox topography (elevation + satellite/streets imagery, optional neighborhood buildings and parcels).",
+    "examplePrompts": [
+      "Import the site terrain for this location, about 500m across",
+      "Load the topography at 40.7128, -74.0060 for a 300 by 300 meter site",
+      "Bring in satellite terrain for the site with the surrounding buildings",
+      "Add site elevation for a 1km by 1km area at these coordinates\n\n# Example\n```ts\n// 300m × 300m site with elevation + satellite imagery.\nconst terrain = await snaptrude.core.io.import.terrain(\n40.7128,  // lat\n-74.006,  // lng\n300,      // width  (metres)\n300,      // length (metres)\ntrue,     // elevation\ntrue,     // satellite\n)\n```"
+    ],
+    "argsType": "number",
+    "resultType": "TerrainHandle"
   },
   {
-    "path": "core.math.quat.conjugate",
-    "namespace": "core.math.quat",
-    "summary": "Compute the conjugate of a quaternion (negated vector part).",
-    "examplePrompts": [],
-    "argsType": "QuatHandle",
-    "resultType": "QuatHandle"
+    "path": "core.io.job.getError",
+    "namespace": "core.io.job",
+    "summary": "The failure message if the job's status is `\"failed\"`; otherwise `null`.",
+    "examplePrompts": [
+      "Why did my DWG import fail?",
+      "What went wrong with the CAD import?",
+      "Show the error from the failed import job",
+      "Did the import error out, and why?\n\n# Example\n```ts\nconst job = await snaptrude.core.io.import.dwg(url, 1)\nif ((await snaptrude.core.io.job.getStatus(job)) === \"failed\") {\nconsole.error(await snaptrude.core.io.job.getError(job))\n}\n```"
+    ],
+    "argsType": "ImportJobHandle",
+    "resultType": "string | null"
   },
   {
-    "path": "core.math.quat.dot",
-    "namespace": "core.math.quat",
-    "summary": "Compute the dot product of two quaternions.",
-    "examplePrompts": [],
-    "argsType": "QuatHandle",
-    "resultType": "number"
+    "path": "core.io.job.getResult",
+    "namespace": "core.io.job",
+    "summary": "The imported result once the job is complete — the placed {@linkcode UnderlayHandle}. Returns `null` while the job is still pending/processing or if it failed (check {@link PluginCoreIoJobApi.getError}).",
+    "examplePrompts": [
+      "Get the underlay from my finished DWG import",
+      "Give me the result of the CAD import job",
+      "Fetch the imported CAD sketch once it's ready",
+      "Return the handle for the completed import\n\n# Example\n```ts\nconst job = await snaptrude.core.io.import.dwg(url, 1)\nconst deadline = Date.now() + 5 * 60_000\nwhile (!(await snaptrude.core.io.job.isComplete(job))) {\nif (Date.now() > deadline) throw new Error(\"DWG import timed out\")\nawait new Promise((r) => setTimeout(r, 2000))\n}\n// DWG results are CAD underlays (CAD scaling isn't supported); manage them\n// via core.io.underlay.* (list / setOpacity / delete).\nconst cad = await snaptrude.core.io.job.getResult(job)\nif (cad) console.log(\"import complete:\", cad)\n```"
+    ],
+    "argsType": "ImportJobHandle",
+    "resultType": "UnderlayHandle | null"
   },
   {
-    "path": "core.math.quat.equals",
-    "namespace": "core.math.quat",
-    "summary": "Test whether two quaternions have exactly equal components.",
-    "examplePrompts": [],
-    "argsType": "QuatHandle",
-    "resultType": "boolean"
+    "path": "core.io.job.getStatus",
+    "namespace": "core.io.job",
+    "summary": "Read a job's current status: `\"pending\"` (queued), `\"processing\"` (running), `\"complete\"` (result ready), or `\"failed\"`.",
+    "examplePrompts": [
+      "What's the status of my DWG import?",
+      "Is the CAD import still processing?",
+      "Check where the import job is up to",
+      "Did the import job fail?\n\n# Example\n```ts\nconst job = await snaptrude.core.io.import.dwg(url, 1)\nconsole.log(await snaptrude.core.io.job.getStatus(job)) // \"processing\"\n```"
+    ],
+    "argsType": "ImportJobHandle",
+    "resultType": "ImportJobStatus"
   },
   {
-    "path": "core.math.quat.equalsApprox",
-    "namespace": "core.math.quat",
-    "summary": "Test whether two quaternions are equal within a tolerance `epsilon` (default `1e-6`).",
-    "examplePrompts": [],
-    "argsType": "QuatHandle",
+    "path": "core.io.job.isComplete",
+    "namespace": "core.io.job",
+    "summary": "Whether the job has finished successfully (status is `\"complete\"` and a result is ready). Returns `false` while pending/processing and on failure.",
+    "examplePrompts": [
+      "Is the DWG import done yet?",
+      "Has the CAD import finished?",
+      "Tell me when the import job completes",
+      "Is my import ready?\n\n# Example\n```ts\nconst job = await snaptrude.core.io.import.dwg(url, 1)\nconst deadline = Date.now() + 5 * 60_000 // cap the poll — see getStatus limitation\nwhile (!(await snaptrude.core.io.job.isComplete(job))) {\nif (Date.now() > deadline) throw new Error(\"DWG import timed out\")\nawait new Promise((r) => setTimeout(r, 2000))\n}\n```"
+    ],
+    "argsType": "ImportJobHandle",
     "resultType": "boolean"
   },
   {
-    "path": "core.math.quat.fromAxisAngle",
-    "namespace": "core.math.quat",
-    "summary": "Build a quaternion from a rotation axis and an angle in radians.",
-    "examplePrompts": [],
-    "argsType": "Vec3Handle",
-    "resultType": "QuatHandle"
+    "path": "core.io.query.getPdfPageCount",
+    "namespace": "core.io.query",
+    "summary": "Count the pages of a PDF without importing it. `null` if the source can't be read as a PDF.",
+    "examplePrompts": [
+      "How many pages does this PDF have?",
+      "Count the pages in the drawing set before importing",
+      "Get the PDF page count",
+      "Is this a multi-page PDF, and how many?\n\n# Example\n```ts\nconst pages = await snaptrude.core.io.query.getPdfPageCount(url)\nfor (let p = 1; p <= (pages ?? 0); p++) {\nawait snaptrude.core.io.import.pdf(url, p, p) // one page per storey\n}\n```"
+    ],
+    "argsType": "string",
+    "resultType": "number | null"
+  },
+  {
+    "path": "core.io.query.listCadLayers",
+    "namespace": "core.io.query",
+    "summary": "List the distinct CAD layer names tagged on a parsed CAD JSON's entities. Read-only inspection: imports always bring in **every** layer (there is no layer filter on {@link core.io.import.dwg} / {@link core.io.import.cadJson}) — use the names to decide whether to import at all, or what to tell the user.",
+    "examplePrompts": [
+      "What CAD layers are in this drawing?",
+      "List the layers before importing the CAD",
+      "Show the DWG layer names so I can pick which to import",
+      "Enumerate the CAD JSON layers\n\n# Example\n```ts\nconst layers = await snaptrude.core.io.query.listCadLayers(cad)\nif (layers.some((l) => l.toUpperCase().includes(\"WALL\"))) {\nawait snaptrude.core.io.import.cadJson(cad, 1) // all layers import together\n}\n```"
+    ],
+    "argsType": "CadJsonInput",
+    "resultType": "string[]"
+  },
+  {
+    "path": "core.io.terrain.delete",
+    "namespace": "core.io.terrain",
+    "summary": "Delete the site terrain. Undoable.",
+    "examplePrompts": [
+      "Delete the site terrain",
+      "Remove the topography",
+      "Clear the imported site",
+      "Get rid of the terrain"
+    ],
+    "argsType": null,
+    "resultType": "void"
+  },
+  {
+    "path": "core.io.terrain.disableElevation",
+    "namespace": "core.io.terrain",
+    "summary": "Turn terrain elevation OFF — flatten to a plane. Undoable.",
+    "examplePrompts": [
+      "Flatten the terrain",
+      "Turn off site elevation",
+      "Disable the heightmap",
+      "Make the terrain flat"
+    ],
+    "argsType": null,
+    "resultType": "void"
+  },
+  {
+    "path": "core.io.terrain.disableSatellite",
+    "namespace": "core.io.terrain",
+    "summary": "Turn satellite imagery OFF. Undoable.",
+    "examplePrompts": [
+      "Hide the satellite imagery",
+      "Turn off the aerial texture",
+      "Disable satellite on the site",
+      "Remove the satellite drape"
+    ],
+    "argsType": null,
+    "resultType": "void"
+  },
+  {
+    "path": "core.io.terrain.enableElevation",
+    "namespace": "core.io.terrain",
+    "summary": "Turn terrain elevation (DEM height) ON — a real 3D topography surface. Undoable.",
+    "examplePrompts": [
+      "Turn on terrain elevation",
+      "Enable the site heightmap",
+      "Make the terrain 3D",
+      "Show the topography relief"
+    ],
+    "argsType": null,
+    "resultType": "void"
+  },
+  {
+    "path": "core.io.terrain.enableSatellite",
+    "namespace": "core.io.terrain",
+    "summary": "Turn satellite imagery ON. Undoable.",
+    "examplePrompts": [
+      "Show satellite imagery on the site",
+      "Enable the satellite texture",
+      "Turn on aerial imagery",
+      "Drape satellite over the terrain"
+    ],
+    "argsType": null,
+    "resultType": "void"
+  },
+  {
+    "path": "core.io.terrain.exists",
+    "namespace": "core.io.terrain",
+    "summary": "Whether the project has a site terrain.",
+    "examplePrompts": [
+      "Does this project have site terrain?",
+      "Is there a terrain imported?",
+      "Check if the site topography exists",
+      "Has a terrain been added yet?\n\n# Example\n```ts\nif (!(await snaptrude.core.io.terrain.exists())) {\nawait snaptrude.core.io.import.terrain(40.7128, -74.006, 300, 300)\n}\n```"
+    ],
+    "argsType": null,
+    "resultType": "boolean"
+  },
+  {
+    "path": "core.io.terrain.get",
+    "namespace": "core.io.terrain",
+    "summary": "Resolve the project's terrain handle, or `null` if there is none. The same handle {@link core.io.import.terrain} returns — use it to obtain the handle without re-importing.",
+    "examplePrompts": [
+      "Get the terrain handle",
+      "Give me the site terrain",
+      "Fetch the current terrain",
+      "Return the topography handle if it exists"
+    ],
+    "argsType": null,
+    "resultType": "TerrainHandle | null"
+  },
+  {
+    "path": "core.io.terrain.getDatum",
+    "namespace": "core.io.terrain",
+    "summary": "Read the terrain's current vertical position (world Y, internal units). `null` if there is no terrain. Import places the terrain so its highest point sits at `y = 0`, so a never-shifted terrain reads a negative baseline, not `0`; each {@link PluginCoreIoTerrainApi.setDatum} shift moves this value.",
+    "examplePrompts": [
+      "What's the terrain's datum?",
+      "Read the current site elevation reference",
+      "Get the terrain vertical offset",
+      "How far has the datum been shifted?"
+    ],
+    "argsType": null,
+    "resultType": "number | null"
+  },
+  {
+    "path": "core.io.terrain.getOpacity",
+    "namespace": "core.io.terrain",
+    "summary": "Read the terrain opacity, `0`..`1`, or `null` if no terrain.",
+    "examplePrompts": [],
+    "argsType": null,
+    "resultType": "number | null"
+  },
+  {
+    "path": "core.io.terrain.getReport",
+    "namespace": "core.io.terrain",
+    "summary": "The terrain cut/fill earthwork report — cut, fill, and net volumes — or `null` if there is no terrain.",
+    "examplePrompts": [
+      "What are the cut and fill volumes for the site?",
+      "Get the terrain earthwork report",
+      "How much cut and fill does the grading need?",
+      "Show the net volume of the terrain edits\n\n# Example\n```ts\nconst r = await snaptrude.core.io.terrain.getReport()\nif (r) console.log(`cut ${r.cutVolume}, fill ${r.fillVolume}, net ${r.netVolume}`)\n```"
+    ],
+    "argsType": null,
+    "resultType": "TerrainReport | null"
+  },
+  {
+    "path": "core.io.terrain.isElevationEnabled",
+    "namespace": "core.io.terrain",
+    "summary": "Whether terrain elevation (DEM height) is on. `null` if no terrain.",
+    "examplePrompts": [],
+    "argsType": null,
+    "resultType": "boolean | null"
+  },
+  {
+    "path": "core.io.terrain.isSatelliteEnabled",
+    "namespace": "core.io.terrain",
+    "summary": "Whether satellite imagery is draped on the terrain. `null` if no terrain.",
+    "examplePrompts": [],
+    "argsType": null,
+    "resultType": "boolean | null"
+  },
+  {
+    "path": "core.io.terrain.setDatum",
+    "namespace": "core.io.terrain",
+    "summary": "Shift the terrain's **datum** — move the whole terrain vertically DOWN by `offset` (internal units) from its current position; pass a negative value to raise it. Undoable.",
+    "examplePrompts": [
+      "Shift the terrain datum down by 12",
+      "Lower the site terrain by 10",
+      "Raise the terrain a little",
+      "Nudge the terrain datum down\n\n# Example\n```ts\nawait snaptrude.core.io.terrain.setDatum(12)   // shift terrain down by 12 (relative)\n```"
+    ],
+    "argsType": "number",
+    "resultType": "void"
+  },
+  {
+    "path": "core.io.terrain.setOpacity",
+    "namespace": "core.io.terrain",
+    "summary": "Set the terrain opacity (`0` transparent .. `1` opaque). Undoable.",
+    "examplePrompts": [
+      "Fade the terrain to 50%",
+      "Make the site semi-transparent",
+      "Set terrain opacity to 0.3",
+      "Dim the topography\n\n# Example\n```ts\nawait snaptrude.core.io.terrain.setOpacity(0.5)\n```"
+    ],
+    "argsType": "number",
+    "resultType": "void"
+  },
+  {
+    "path": "core.io.underlay.delete",
+    "namespace": "core.io.underlay",
+    "summary": "Delete an underlay from the scene (and its backend record). Applies to image, PDF, and CAD underlays.",
+    "examplePrompts": [
+      "Delete this floor plan underlay",
+      "Remove the imported PDF from the scene",
+      "Get rid of the CAD sketch I traced over",
+      "Clear the reference image off storey 1\n\n# Example\n```ts\nconst [first] = await snaptrude.core.io.underlay.list(1)\nif (first) await snaptrude.core.io.underlay.delete(first)\n```"
+    ],
+    "argsType": "UnderlayHandle",
+    "resultType": "void"
+  },
+  {
+    "path": "core.io.underlay.getBounds",
+    "namespace": "core.io.underlay",
+    "summary": "Read an underlay's world-space bounding box (image, PDF, or CAD). `null` if the underlay no longer resolves or has no measurable mesh. Useful for fitting drawn geometry to a reference, or computing a plan size before scaling.",
+    "examplePrompts": [
+      "How big is this floor plan in the scene?",
+      "Get the bounding box of the underlay",
+      "What's the extent of the imported PDF?",
+      "Measure the CAD sketch's size\n\n# Example\n```ts\nconst bb = await snaptrude.core.io.underlay.getBounds(plan)\nif (bb) console.log(`width ${bb.max.x - bb.min.x}`)\n```"
+    ],
+    "argsType": "UnderlayHandle",
+    "resultType": "BBoxComponents | null"
+  },
+  {
+    "path": "core.io.underlay.getOpacity",
+    "namespace": "core.io.underlay",
+    "summary": "Read an underlay's opacity (`0`..`1`), or `null` if it has no material.",
+    "examplePrompts": [
+      "How transparent is this underlay?",
+      "Get the opacity of the floor plan",
+      "What's the fade level on the reference image?",
+      "Read the underlay's opacity\n\n# Example\n```ts\nconst o = await snaptrude.core.io.underlay.getOpacity(plan)\n```"
+    ],
+    "argsType": "UnderlayHandle",
+    "resultType": "number | null"
+  },
+  {
+    "path": "core.io.underlay.getScale",
+    "namespace": "core.io.underlay",
+    "summary": "Read an underlay's scale. Works for **image and PDF** underlays. Returns `null` for CAD (scaling not supported) or if the handle no longer resolves.",
+    "examplePrompts": [
+      "What scale is this floor plan set to?",
+      "Get the current and original scale of the underlay",
+      "How much has this image been scaled since import?",
+      "Read the scale factor of the reference plan\n\n# Example\n```ts\nconst s = await snaptrude.core.io.underlay.getScale(plan)\nif (s) console.log(`scale ${s.scaleFactor} (was ${s.initialScaleFactor})`)\n```"
+    ],
+    "argsType": "UnderlayHandle",
+    "resultType": "{ scaleFactor: number; initialScaleFactor: number } | null"
+  },
+  {
+    "path": "core.io.underlay.list",
+    "namespace": "core.io.underlay",
+    "summary": "List the underlays in the scene, optionally limited to one storey.",
+    "examplePrompts": [
+      "List all the reference underlays in the model",
+      "What underlays are on the ground floor?",
+      "Show every imported floor plan and PDF",
+      "How many trace-over images are on storey 2?\n\n# Example\n```ts\nconst underlays = await snaptrude.core.io.underlay.list(1)\nconsole.log(`${underlays.length} underlays on storey 1`)\n```"
+    ],
+    "argsType": "number",
+    "resultType": "UnderlayHandle[]"
+  },
+  {
+    "path": "core.io.underlay.resetScale",
+    "namespace": "core.io.underlay",
+    "summary": "Reset an underlay's scale back to its import-time size (image or PDF; CAD scaling is not supported — throws). Equivalent to `setScale(underlay, 1)`.",
+    "examplePrompts": [
+      "Reset this floor plan's scale to how it was imported",
+      "Undo the scaling on the underlay",
+      "Put the reference image back to its original size",
+      "Restore the plan's default scale\n\n# Example\n```ts\nawait snaptrude.core.io.underlay.resetScale(plan)\n```"
+    ],
+    "argsType": "UnderlayHandle",
+    "resultType": "{ scaleFactor: number }"
+  },
+  {
+    "path": "core.io.underlay.setOpacity",
+    "namespace": "core.io.underlay",
+    "summary": "Set an underlay's opacity (`0` = transparent .. `1` = opaque). Undoable. The engine keeps underlays faintly visible: values below `0.01` clamp to `0.01`, so `setOpacity(u, 0)` reads back as `0.01`, not `0`.",
+    "examplePrompts": [
+      "Fade this floor plan to 30% so I can see through it",
+      "Make the underlay half transparent",
+      "Set the reference image opacity to 0.2",
+      "Dim the trace-over plan\n\n# Example\n```ts\nawait snaptrude.core.io.underlay.setOpacity(plan, 0.3)\n```"
+    ],
+    "argsType": "UnderlayHandle",
+    "resultType": "void"
+  },
+  {
+    "path": "core.io.underlay.setScale",
+    "namespace": "core.io.underlay",
+    "summary": "Set an underlay's scale — the **calibration** step after import. Works for **image and PDF** underlays (CAD scaling is not supported — throws).",
+    "examplePrompts": [
+      "Scale this floor plan so it's 50 meters across",
+      "Set the plan size to 30m — it's imported too small",
+      "Make the reference image twice its imported size",
+      "Calibrate the PDF: the site is 120 meters long\n\n# Example\n```ts\n// Absolute factor — set the underlay to 2× its imported size:\nawait snaptrude.core.io.underlay.setScale(plan, 2)\n\n// Fit to a real-world size — make the plan's longest side 50 project-units:\nawait snaptrude.core.io.underlay.setScale(plan, { planSize: 50 })\n```"
+    ],
+    "argsType": "UnderlayHandle",
+    "resultType": "{ scaleFactor: number }"
+  },
+  {
+    "path": "core.layers.get",
+    "namespace": "core.layers",
+    "summary": "Get a single drawing layer by id.",
+    "examplePrompts": [
+      "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"
+  },
+  {
+    "path": "core.layers.getActive",
+    "namespace": "core.layers",
+    "summary": "Get the active drawing layer of a storey.",
+    "examplePrompts": [
+      "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": "string",
+    "resultType": "PluginCoreLayersGetActiveResult"
+  },
+  {
+    "path": "core.layers.list",
+    "namespace": "core.layers",
+    "summary": "List the drawing layers of a storey.",
+    "examplePrompts": [
+      "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": "PluginCoreLayersListResult"
+  },
+  {
+    "path": "core.layers.setActive",
+    "namespace": "core.layers",
+    "summary": "Make a drawing layer the active layer of its storey.",
+    "examplePrompts": [
+      "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"
+  },
+  {
+    "path": "core.layers.update",
+    "namespace": "core.layers",
+    "summary": "Update a drawing layer's visibility.",
+    "examplePrompts": [
+      "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"
+  },
+  {
+    "path": "core.math.quat.components",
+    "namespace": "core.math.quat",
+    "summary": "Read the primitive `{ x, y, z, w }` components of a quaternion handle.",
+    "examplePrompts": [],
+    "argsType": "QuatHandle",
+    "resultType": "QuatComponents"
+  },
+  {
+    "path": "core.math.quat.conjugate",
+    "namespace": "core.math.quat",
+    "summary": "Compute the conjugate of a quaternion (negated vector part).",
+    "examplePrompts": [],
+    "argsType": "QuatHandle",
+    "resultType": "QuatHandle"
+  },
+  {
+    "path": "core.math.quat.dot",
+    "namespace": "core.math.quat",
+    "summary": "Compute the dot product of two quaternions.",
+    "examplePrompts": [],
+    "argsType": "QuatHandle",
+    "resultType": "number"
+  },
+  {
+    "path": "core.math.quat.equals",
+    "namespace": "core.math.quat",
+    "summary": "Test whether two quaternions have exactly equal components.",
+    "examplePrompts": [],
+    "argsType": "QuatHandle",
+    "resultType": "boolean"
+  },
+  {
+    "path": "core.math.quat.equalsApprox",
+    "namespace": "core.math.quat",
+    "summary": "Test whether two quaternions are equal within a tolerance `epsilon` (default `1e-6`).",
+    "examplePrompts": [],
+    "argsType": "QuatHandle",
+    "resultType": "boolean"
+  },
+  {
+    "path": "core.math.quat.fromAxisAngle",
+    "namespace": "core.math.quat",
+    "summary": "Build a quaternion from a rotation axis and an angle in radians.",
+    "examplePrompts": [],
+    "argsType": "Vec3Handle",
+    "resultType": "QuatHandle"
   },
   {
     "path": "core.math.quat.fromEuler",
@@ -2370,8 +3180,117 @@
       "Make the cursor snap every 6 inches when drawing",
       "Adjust the snapping increment for lengths\n\n# Example\n```ts\n// the threshold only applies while dimension snapping is on\nawait snaptrude.core.project.settings.snaps.setDimension(100)\nawait snaptrude.core.project.settings.snaps.enableDimension()\n```"
     ],
-    "argsType": "number",
-    "resultType": "boolean"
+    "argsType": "number",
+    "resultType": "boolean"
+  },
+  {
+    "path": "core.proposals.create",
+    "namespace": "core.proposals",
+    "summary": "Create a new design option (proposal) — blank, or configured from a base proposal (the New Proposal modal's two paths).",
+    "examplePrompts": [
+      "Create a design option called Scheme B",
+      "Add a new proposal named Option 2",
+      "Duplicate the current proposal as Scheme C",
+      "Create a design option based on Proposal 1 that shares its site layer\n\n# Example\n```ts\n// blank design option\nconst { id } = await snaptrude.core.proposals.create(\"Scheme B\")\n\n// configured from the active proposal: duplicate every layer\nconst base = await snaptrude.core.proposals.getActive()\nif (base) {\nconst { id: dup } = await snaptrude.core.proposals.create(\"Scheme C\", {\nbaseProposalId: base.id,\n})\n// …or share one layer and leave the rest behind\nconst { id: shared } = await snaptrude.core.proposals.create(\"Scheme D\", {\nbaseProposalId: base.id,\nlayers: [{ bucketId: base.defaultBucketId, action: \"share\" }],\n})\n}\n```"
+    ],
+    "argsType": "string",
+    "resultType": "PluginCoreProposalsCreateResult"
+  },
+  {
+    "path": "core.proposals.delete",
+    "namespace": "core.proposals",
+    "summary": "Delete a proposal.",
+    "examplePrompts": [
+      "Delete proposal prop_2 and everything in it",
+      "Remove this design option and destroy its geometry",
+      "Merge prop_2's layers into prop_1 and delete prop_2\n\n# Example\n```ts\n// destroy the proposal and its exclusive geometry\nawait snaptrude.core.proposals.delete(\"prop_2\", { deleteObjects: true })\n// …or keep the geometry by transferring its buckets to prop_1 first\nawait snaptrude.core.proposals.delete(\"prop_2\", { targetProposalId: \"prop_1\" })\n```"
+    ],
+    "argsType": "string",
+    "resultType": "PluginCoreProposalsDeleteResult"
+  },
+  {
+    "path": "core.proposals.get",
+    "namespace": "core.proposals",
+    "summary": "Get a single proposal by id.",
+    "examplePrompts": [
+      "Get the proposal with id prop_1",
+      "Look up a single design option by its id",
+      "Which buckets belong to proposal prop_2?\n\n# Example\n```ts\nconst proposal = await snaptrude.core.proposals.get(\"prop_1\")\nif (proposal) console.log(proposal.name, proposal.bucketIds)\n```"
+    ],
+    "argsType": "string",
+    "resultType": "PluginCoreProposalsGetResult"
+  },
+  {
+    "path": "core.proposals.getActive",
+    "namespace": "core.proposals",
+    "summary": "Get the active proposal.",
+    "examplePrompts": [
+      "Which design option is active?",
+      "Get the current proposal",
+      "What proposal am I working in?\n\n# Example\n```ts\nconst active = await snaptrude.core.proposals.getActive()\nif (active) console.log(active.id, active.name)\n```"
+    ],
+    "argsType": null,
+    "resultType": "PluginCoreProposalsGetActiveResult"
+  },
+  {
+    "path": "core.proposals.isActive",
+    "namespace": "core.proposals",
+    "summary": "Test whether a proposal is the active one.",
+    "examplePrompts": [
+      "Is proposal prop_2 the active one?",
+      "Check whether this design option is currently shown",
+      "Am I working in proposal prop_1?\n\n# Example\n```ts\nif (await snaptrude.core.proposals.isActive(\"prop_1\")) {\nconsole.log(\"prop_1 is active\")\n}\n```"
+    ],
+    "argsType": "string",
+    "resultType": "boolean"
+  },
+  {
+    "path": "core.proposals.list",
+    "namespace": "core.proposals",
+    "summary": "List the design options (proposals) in the active project.",
+    "examplePrompts": [
+      "List all the design options in this project",
+      "How many proposals does this project have?",
+      "Show every design variant with its name\n\n# Example\n```ts\nconst { proposals } = await snaptrude.core.proposals.list()\nfor (const p of proposals) console.log(p.id, p.name, p.isActive)\n```"
+    ],
+    "argsType": null,
+    "resultType": "PluginCoreProposalsListResult"
+  },
+  {
+    "path": "core.proposals.listForComponent",
+    "namespace": "core.proposals",
+    "summary": "List the proposals a component belongs to.",
+    "examplePrompts": [
+      "Which design options is this component part of?",
+      "List the proposals that contain this wall",
+      "Is this element shared across multiple design variants?\n\n# Example\n```ts\nconst { proposals } = await snaptrude.core.proposals.listForComponent(wall)\nconsole.log(`shared across ${proposals.length} proposals`)\n```"
+    ],
+    "argsType": "ComponentHandle",
+    "resultType": "PluginCoreProposalsListForComponentResult"
+  },
+  {
+    "path": "core.proposals.rename",
+    "namespace": "core.proposals",
+    "summary": "Rename a proposal.",
+    "examplePrompts": [
+      "Rename proposal prop_1 to Final Scheme",
+      "Change the name of this design option",
+      "Call proposal prop_2 \"Option A\"\n\n# Example\n```ts\nconst proposal = await snaptrude.core.proposals.rename(\"prop_1\", \"Final Scheme\")\n```"
+    ],
+    "argsType": "string",
+    "resultType": "PluginCoreProposalsRenameResult"
+  },
+  {
+    "path": "core.proposals.setActive",
+    "namespace": "core.proposals",
+    "summary": "Switch the active proposal.",
+    "examplePrompts": [
+      "Switch to proposal prop_2",
+      "Make Scheme B the active design option",
+      "Show me the other proposal\n\n# Example\n```ts\nawait snaptrude.core.proposals.setActive(\"prop_2\")\n```"
+    ],
+    "argsType": "string",
+    "resultType": "PluginCoreProposalsSetActiveResult"
   },
   {
     "path": "core.tags.assign",
@@ -2606,6 +3525,19 @@
     "argsType": "PUnitType",
     "resultType": "boolean"
   },
+  {
+    "path": "core.user.getLocale",
+    "namespace": "core.user",
+    "summary": "Get the viewer's locale: IANA timezone and BCP-47 language tag, resolved from the browser (`Intl.DateTimeFormat().resolvedOptions().timeZone` and `navigator.language`). Locale only — no precise location.",
+    "examplePrompts": [
+      "What timezone is the user in?",
+      "Get the viewer's language for localized labels",
+      "Format the report date in the user's local timezone",
+      "Which locale should I use for this plugin's UI?\n\n# Example\n```ts\nconst { timezone, language } = await snaptrude.core.user.getLocale()\n```"
+    ],
+    "argsType": null,
+    "resultType": "PluginUserLocale"
+  },
   {
     "path": "core.zoom.extents",
     "namespace": "core.zoom",
@@ -2677,7 +3609,7 @@
   {
     "path": "design.create.beam",
     "namespace": "design.create",
-    "summary": "Create a **beam** by extruding a cross-section contour along `direction` by `length`.",
+    "summary": "Create a **beam** by extruding a cross-section contour along `direction` by `length`. Matches the Snaptrude beam tool's semantics: the beam body hangs BELOW the plane the section is authored on.",
     "examplePrompts": [
       "Add a beam spanning 6 metres between the columns",
       "Create a horizontal beam along the X axis",
@@ -2703,7 +3635,7 @@
   {
     "path": "design.create.column",
     "namespace": "design.create",
-    "summary": "Create a **column** by extruding a cross-section contour upward by `height` from a base `position`.",
+    "summary": "Create a **column** by extruding a cross-section contour upward by `height` from a base `position`. The column is built to EXACTLY `height` — unlike the interactive draw tool, no slab-thickness deduction is applied.",
     "examplePrompts": [
       "Add a 3m tall column at this point",
       "Place a column at the grid intersection",
@@ -2727,6 +3659,21 @@
     "argsType": "ComponentHandle[]",
     "resultType": "ComponentHandle[]"
   },
+  {
+    "path": "design.create.door",
+    "namespace": "design.create",
+    "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",
+      "Put a door from the catalog at this point on the wall",
+      "Insert the entrance door into this wall",
+      "Add a door to the wall and call it Entry-01",
+      "Add a door that opens into the living room\n\n# Example\n```ts\nconst [wall] = await snaptrude.design.query.listWalls({ isSelected: true })\nconst [entry] = await snaptrude.design.doors.listCatalog()\nconst door = await snaptrude.design.create.door(\nentry.id,\nwall,\nawait snaptrude.core.math.vec3.new(3, 0, 5),\n{ label: \"Entry-01\" },\n)\n// …facing a specific side of the wall (pass a point inside that room):\nconst intoKitchen = await snaptrude.design.create.door(\nentry.id,\nwall,\nawait snaptrude.core.math.vec3.new(3, 0, 5),\nundefined,\nawait snaptrude.core.math.vec3.new(3, 0, 9),\n)\n```"
+    ],
+    "argsType": "string",
+    "resultType": "ComponentHandle"
+  },
   {
     "path": "design.create.floor",
     "namespace": "design.create",
@@ -2749,7 +3696,8 @@
       "Add a sofa from the furniture catalog to the living room",
       "Drop a desk into the scene at 3, 0, 5",
       "Insert the uploaded bed model in the bedroom",
-      "Put a table from my project library here and name it Table-01\n\n# Example\n```ts\nconst chair = await snaptrude.design.create.furniture(\n\"6620f1a…\",             // from design.furniture.listCatalog()\nawait snaptrude.core.math.vec3.new(3, 0, 5),\n{ label: \"Chair-01\" },\n)\n```"
+      "Put a table from my project library here and name it Table-01",
+      "Place a chair here rotated 90 degrees\n\n# Example\n```ts\nconst chair = await snaptrude.design.create.furniture(\n\"6620f1a…\",             // from design.furniture.listCatalog()\nawait snaptrude.core.math.vec3.new(3, 0, 5),\n{ label: \"Chair-01\" },\n)\n// …placed already turned 90° about the vertical axis:\nconst turned = await snaptrude.design.create.furniture(\n\"6620f1a…\",\nawait snaptrude.core.math.vec3.new(3, 0, 5),\nundefined,\n90,\n)\n```"
     ],
     "argsType": "string",
     "resultType": "ComponentHandle"
@@ -2808,6 +3756,20 @@
     "argsType": "ContourHandle",
     "resultType": "ComponentHandle"
   },
+  {
+    "path": "design.create.smartLayout",
+    "namespace": "design.create",
+    "summary": "Place a **smart layout** — clone an in-scene template cluster (walls, furniture, doors, windows, floors) into one or more target ROOM/DEPARTMENT spaces, adapting orientation and fit to each target.",
+    "examplePrompts": [
+      "Copy this room's layout into the selected rooms",
+      "Apply this furniture arrangement to the other offices",
+      "Replicate this template into these two spaces",
+      "Place this desk cluster into every meeting room",
+      "Use this room as a template for the rooms I selected but keep them visible\n\n# Example\n```ts\nconst [templateRoom, ...targets] = await snaptrude.design.query.listSpaces({ isSelected: true })\nconst result = await snaptrude.design.create.smartLayout({\ntemplateComponents: [templateRoom],\ntargets,\n})\nconsole.log(\"placed walls:\", result.created.walls.length, \"skipped:\", result.skippedWalls)\n\n// …or clone a saved group by its id (from core.groups.list)\nconst { groups } = await snaptrude.core.groups.list()\nawait snaptrude.design.create.smartLayout({ templateGroup: groups[0].id, targets })\n```"
+    ],
+    "argsType": "PluginSmartLayoutArgs",
+    "resultType": "PluginSmartLayoutResult"
+  },
   {
     "path": "design.create.space",
     "namespace": "design.create",
@@ -2817,7 +3779,8 @@
       "Add a new space on the current storey using this footprint",
       "Make a bedroom here and assign it to the Residential department",
       "Extrude this closed outline into a 10 foot high room",
-      "Can you create a Kitchen space from the sketch I just drew?\n\n# Example\n```ts\nconst v = snaptrude.core.math.vec3\nconst outer = await snaptrude.core.geom.create.profileFromLinePoints([\nawait v.new(0, 0, 0),\nawait v.new(10, 0, 0),\nawait v.new(10, 0, 8),\nawait v.new(0, 0, 8),\n])\nconst contour = await snaptrude.core.geom.create.contourFromProfile(outer)\nconst space = await snaptrude.design.create.space(contour, 3, \"Living\")\n```"
+      "Can you create a Kitchen space from the sketch I just drew?",
+      "Create a bedroom on the second floor from this outline\n\n# Example\n```ts\nconst v = snaptrude.core.math.vec3\nconst outer = await snaptrude.core.geom.create.profileFromLinePoints([\nawait v.new(0, 0, 0),\nawait v.new(10, 0, 0),\nawait v.new(10, 0, 8),\nawait v.new(0, 0, 8),\n])\nconst contour = await snaptrude.core.geom.create.contourFromProfile(outer)\nconst space = await snaptrude.design.create.space(contour, 3, \"Living\")\n// …place one directly on the second floor (no setActive dance):\nconst upstairs = await snaptrude.design.create.space(\ncontour, 3, \"Bedroom\", undefined, undefined, undefined, undefined, 2,\n)\n```"
     ],
     "argsType": "ContourHandle",
     "resultType": "ComponentHandle"
@@ -2825,12 +3788,13 @@
   {
     "path": "design.create.spaces",
     "namespace": "design.create",
-    "summary": "Create **many spaces** in one undoable operation (bulk plural of {@linkcode space}). Migrated from the removed `entity.space.bulkCreate`. Each item extrudes a contour footprint up `height`. Validate-all-or-throw; one command. For a rectangular (box) space, build the footprint with `core.geom.create.profileRect` → `contourFromProfile`, then pass it as an item.",
+    "summary": "Create **many spaces** in one undoable operation (bulk plural of {@linkcode space}). Migrated from the removed `entity.space.bulkCreate`. Each item extrudes a contour footprint up `height`. Validate-all-or-throw; one command. For a rectangular (box) space, build the footprint with `core.geom.create.profileRect` → `contourFromProfile`, then pass it as an item. Each item may carry its own `storey` (see {@linkcode PluginCreateSpaceItem}) so a single call can populate several floors at once.",
     "examplePrompts": [
       "Create several rooms at once from these footprints",
       "Generate all the bedrooms in one operation",
       "Bulk create the spaces for this floor plan",
-      "Add three rooms with different heights in a single undo step\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 [a, b] = await snaptrude.design.create.spaces([\n{ contour, height: 3, label: \"R1\" },\n{ contour, height: 4, label: \"R2\", position: await vec3.new(10, 0, 0) },\n])\n```"
+      "Add three rooms with different heights in a single undo step",
+      "Create one room on the ground floor and one on the first floor\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 [a, b] = await snaptrude.design.create.spaces([\n{ contour, height: 3, label: \"R1\" },\n{ contour, height: 4, label: \"R2\", position: await vec3.new(10, 0, 0) },\n])\n```"
     ],
     "argsType": "PluginCreateSpaceItem[]",
     "resultType": "ComponentHandle[]"
@@ -2858,11 +3822,28 @@
       "Create 3m high, 200mm thick walls from these points",
       "Build a wall run around the room outline",
       "Turn this polyline sketch into walls",
-      "Add walls with mitred corners along the path\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```"
+      "Add walls with mitred corners along the path",
+      "Draw brick walls with plaster along this outline",
+      "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[]"
   },
+  {
+    "path": "design.create.window",
+    "namespace": "design.create",
+    "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",
+      "Put a window from the catalog at this point on the wall",
+      "Insert a window into the living room wall",
+      "Add a window to the wall and name it Win-01",
+      "Add a casement window opening toward the garden side\n\n# Example\n```ts\nconst [wall] = await snaptrude.design.query.listWalls({ isSelected: true })\nconst [entry] = await snaptrude.design.windows.listCatalog()\nconst window = await snaptrude.design.create.window(\nentry.id,\nwall,\nawait snaptrude.core.math.vec3.new(3, 0, 5),\n{ label: \"Win-01\" },\n)\n```"
+    ],
+    "argsType": "string",
+    "resultType": "ComponentHandle"
+  },
   {
     "path": "design.delete.entities",
     "namespace": "design.delete",
@@ -2877,6 +3858,45 @@
     "argsType": "ComponentHandle[]",
     "resultType": "PluginDesignChangeResult"
   },
+  {
+    "path": "design.doors.exists",
+    "namespace": "design.doors",
+    "summary": "Test whether a door catalog item exists for the given library id.",
+    "examplePrompts": [
+      "Is this door still in the library?",
+      "Check whether a door catalog item with this id exists",
+      "Does my team library have this door?",
+      "Verify the door is available before placing it\n\n# Example\n```ts\nconst [entry] = await snaptrude.design.doors.listCatalog()\nconst stillAvailable = await snaptrude.design.doors.exists(entry.id)\nconsole.log(stillAvailable ? \"safe to place\" : \"removed from library\")\n```"
+    ],
+    "argsType": "string",
+    "resultType": "boolean"
+  },
+  {
+    "path": "design.doors.getCatalogItem",
+    "namespace": "design.doors",
+    "summary": "Get a single door catalog item by its library id.",
+    "examplePrompts": [
+      "Get the details of this door from the library",
+      "Look up the catalog entry for this door id",
+      "What is the cost of this door item?",
+      "Show me the family name of this door in the catalog\n\n# Example\n```ts\nconst [entry] = await snaptrude.design.doors.listCatalog()\nconst item = await snaptrude.design.doors.getCatalogItem(entry.id)\nif (item) console.log(item.name, item.source, item.dbType)\n```"
+    ],
+    "argsType": "string",
+    "resultType": "PluginObjectCatalogItem | null"
+  },
+  {
+    "path": "design.doors.getDimensions",
+    "namespace": "design.doors",
+    "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?",
+      "Give me the width, height and depth of this door",
+      "Measure the entrance door including its thickness through the wall\n\n# Example\n```ts\nconst [door] = await snaptrude.design.query.listDoors({ isSelected: true })\nconst dims = await snaptrude.design.doors.getDimensions(door)\nif (dims) console.log(dims.width, dims.height, dims.thickness)\n```"
+    ],
+    "argsType": "ComponentHandle",
+    "resultType": "PluginDoorDimensions | null"
+  },
   {
     "path": "design.doors.getFamily",
     "namespace": "design.doors",
@@ -2955,6 +3975,32 @@
     "argsType": "ComponentHandle",
     "resultType": "number | null"
   },
+  {
+    "path": "design.doors.listCatalog",
+    "namespace": "design.doors",
+    "summary": "List the placeable door catalog (team + general libraries), optionally restricted to one group by its `dbType` token.",
+    "examplePrompts": [
+      "What doors can I place in this project?",
+      "List every door in the library",
+      "Show me the sliding doors I can add",
+      "Browse the door catalog\n\n# Example\n```ts\nconst [group] = await snaptrude.design.doors.listCatalogGroups()\nconst items = await snaptrude.design.doors.listCatalog(group?.dbType)\nfor (const item of items) console.log(item.id, item.name, item.thumbnailUrl)\n```"
+    ],
+    "argsType": "string",
+    "resultType": "PluginObjectCatalogItem[]"
+  },
+  {
+    "path": "design.doors.listCatalogGroups",
+    "namespace": "design.doors",
+    "summary": "List the door catalog **groups** — the placement families (Swing, Sliding, Folding, Pivot, …), built-in groups merged with any team-custom types.",
+    "examplePrompts": [
+      "What kinds of doors can I place?",
+      "List the door groups in the catalog",
+      "Show me the door families available in this project",
+      "Which door types does this project support?\n\n# Example\n```ts\nconst groups = await snaptrude.design.doors.listCatalogGroups()\nfor (const g of groups) console.log(g.dbType, g.label, g.source)\n```"
+    ],
+    "argsType": null,
+    "resultType": "PluginObjectCatalogGroup[]"
+  },
   {
     "path": "design.doors.mirror",
     "namespace": "design.doors",
@@ -3062,20 +4108,71 @@
     "argsType": "string",
     "resultType": "PluginFurnitureCatalogItem | null"
   },
+  {
+    "path": "design.furniture.getDimensions",
+    "namespace": "design.furniture",
+    "summary": "Get the dimensions of a PLACED furniture item — `length` (along the object), `width` (across it) and `height` (vertical), in engine units. Mirrors the Length/Width/Height fields of the furniture properties panel.",
+    "examplePrompts": [
+      "How big is this sofa?",
+      "What are the dimensions of the selected furniture?",
+      "Measure the length, width and height of this table",
+      "Get the size of the chair I just placed\n\n# Example\n```ts\nconst [item] = await snaptrude.design.query.listFurniture({ isSelected: true })\nconst dims = await snaptrude.design.furniture.getDimensions(item)\nif (dims) console.log(dims.length, dims.width, dims.height)\n```"
+    ],
+    "argsType": "ComponentHandle",
+    "resultType": "PluginFurnitureDimensions | null"
+  },
   {
     "path": "design.furniture.listCatalog",
     "namespace": "design.furniture",
-    "summary": "List the placeable furniture catalog (team + general libraries).",
+    "summary": "List the placeable furniture catalog (team + general libraries), optionally filtered by library `source` and/or `category`.",
     "examplePrompts": [
       "What furniture can I place in this project?",
       "Show me all the furniture available in the library",
       "List the chairs and tables I can add to the model",
       "Which furniture items are in my team's library?",
-      "Browse the furniture catalog\n\n# Example\n```ts\nconst teamItems = await snaptrude.design.furniture.listCatalog(\"team\")\nfor (const item of teamItems) console.log(item.id, item.name, item.cost)\n```"
+      "Show me the bedroom furniture I can place\n\n# Example\n```ts\nconst bedroom = await snaptrude.design.furniture.listCatalog(\"team\", \"bedroom\")\nfor (const item of bedroom) console.log(item.id, item.name, item.thumbnailUrl)\n```"
     ],
     "argsType": "\"team\" | \"general\"",
     "resultType": "PluginFurnitureCatalogItem[]"
   },
+  {
+    "path": "design.furniture.listCategories",
+    "namespace": "design.furniture",
+    "summary": "List the categories (Living, Bedroom, Kitchen, …) that organize the furniture catalog — the picker taxonomy, merged from built-in categories, team types, and backend user types. Pass a value to {@linkcode PluginDesignFurnitureApi.listCatalog}'s `category` filter.",
+    "examplePrompts": [
+      "What furniture categories are available?",
+      "List the furniture categories",
+      "Show me the furniture groups like living and bedroom",
+      "Which furniture categories can I filter by?\n\n# Example\n```ts\nconst categories = await snaptrude.design.furniture.listCategories()\nconst [first] = categories\nconst items = await snaptrude.design.furniture.listCatalog(undefined, first)\nconsole.log(first, \"→\", items.length, \"items\")\n```"
+    ],
+    "argsType": null,
+    "resultType": "string[]"
+  },
+  {
+    "path": "design.furniture.setDimensions",
+    "namespace": "design.furniture",
+    "summary": "Resize a PLACED furniture item along one or more axes — `length`, `width` and/or `height` (engine units). Omitted axes are left unchanged. Each supplied axis is an undoable command, mirroring editing the furniture properties panel.",
+    "examplePrompts": [
+      "Make this table 1.8m long",
+      "Resize the selected sofa to 2000 wide",
+      "Set this furniture to 800mm tall",
+      "Change the desk to 1500 long and 700 deep\n\n# Example\n```ts\nconst [item] = await snaptrude.design.query.listFurniture({ isSelected: true })\nconst { affected } = await snaptrude.design.furniture.setDimensions(item, {\nlength: 1800,\nheight: 750\n})\n```"
+    ],
+    "argsType": "ComponentHandle",
+    "resultType": "PluginDesignChangeResult"
+  },
+  {
+    "path": "design.isAreaLocked",
+    "namespace": "design",
+    "summary": "Test whether a space's footprint area is locked. A read — never throws; returns `false` for non-space handles and when the `area_lock` feature is off.",
+    "examplePrompts": [
+      "Is the area of this room locked?",
+      "Check whether this department's footprint is pinned",
+      "Tell me if the selected space has its area locked\n\n# Example\n```ts\nconst [room] = await snaptrude.design.selection.get()\nconst locked = await snaptrude.design.isAreaLocked(room)\nconsole.log(locked ? \"area is locked\" : \"area is free\")\n```"
+    ],
+    "argsType": "ComponentHandle",
+    "resultType": "boolean"
+  },
   {
     "path": "design.isLocked",
     "namespace": "design",
@@ -3089,6 +4186,18 @@
     "argsType": "ComponentHandle",
     "resultType": "boolean"
   },
+  {
+    "path": "design.listAreaLocked",
+    "namespace": "design",
+    "summary": "List the spaces whose footprint area is locked. A read — never throws; returns `[]` when the `area_lock` feature is off.",
+    "examplePrompts": [
+      "Which spaces have their area locked?",
+      "List every room with a locked footprint",
+      "Show me all the area-locked departments\n\n# Example\n```ts\nconst locked = await snaptrude.design.listAreaLocked()\nconsole.log(locked.length, \"area-locked spaces\")\n```"
+    ],
+    "argsType": null,
+    "resultType": "ComponentHandle[]"
+  },
   {
     "path": "design.listLocked",
     "namespace": "design",
@@ -3115,6 +4224,19 @@
     "argsType": "ComponentHandle[]",
     "resultType": "PluginDesignChangeResult"
   },
+  {
+    "path": "design.lockArea",
+    "namespace": "design",
+    "summary": "Lock the **footprint area** of one or more Room / Department mass spaces — geometry edits that would change the bottom-face area are then refused or auto-resized to preserve it. Distinct from {@linkcode PluginDesignApi.lock} (which freezes the whole object): this locks only the area. Cascades to the space's instances and its source mass. Undoable.",
+    "examplePrompts": [
+      "Lock the floor area of the selected rooms",
+      "Freeze the footprint area of this department so its size can't drift",
+      "Area-lock every room on this storey",
+      "Pin the area of this space while I edit its walls\n\n# Example\n```ts\nconst rooms = await snaptrude.design.selection.get()\nconst { affected } = await snaptrude.design.lockArea(rooms)\nconsole.log(\"area-locked\", affected.length, \"spaces\")\n```"
+    ],
+    "argsType": "ComponentHandle[]",
+    "resultType": "PluginDesignChangeResult"
+  },
   {
     "path": "design.materials.apply",
     "namespace": "design.materials",
@@ -3129,6 +4251,19 @@
     "argsType": "ComponentHandle[]",
     "resultType": "PluginMaterialResult"
   },
+  {
+    "path": "design.materials.applyToFaces",
+    "namespace": "design.materials",
+    "summary": "Paint specific **BREP faces** of a component with a material — an existing project material by handle, or a new one described inline as a {@linkcode PluginMaterialSpec}. Faces are addressed by **durable BREP face index** (their 0-based position in the component's BREP face list). Undoable when `save` is true (the default).",
+    "examplePrompts": [
+      "Paint the top face of this slab red",
+      "Apply the brick material to faces 0 and 2 of this wall",
+      "Put a wood finish on just the front face of this column",
+      "Colour face 4 of the selected mass with #ff8800\n\n# Example\n```ts\nconst [wall] = await snaptrude.design.query.listWalls({ storeys: [1] })\n// faces are addressed by durable 0-based BREP face index\nconst { count } = await snaptrude.design.materials.applyToFaces(wall, [0, 1], { name: \"Accent\", color: \"#b04a3a\" })\nconsole.log(\"painted\", count, \"faces\")\n```"
+    ],
+    "argsType": "ComponentHandle",
+    "resultType": "PluginMaterialResult"
+  },
   {
     "path": "design.materials.create",
     "namespace": "design.materials",
@@ -3142,6 +4277,32 @@
     "argsType": "PluginMaterialSpec",
     "resultType": "MaterialHandle"
   },
+  {
+    "path": "design.materials.get",
+    "namespace": "design.materials",
+    "summary": "Read the material applied to a component **as a whole** — the eyedropper. For a uniformly-painted component this is that single material; for a per-face-painted component it is the material on the component's base/first face. Use {@linkcode PluginDesignMaterialsApi.getByFace} / {@linkcode PluginDesignMaterialsApi.listByFace} for the per-face breakdown.",
+    "examplePrompts": [
+      "What material is on this wall?",
+      "Eyedrop the finish of the selected object",
+      "Which material does this slab use?",
+      "Read the material on this column so I can paint others with it",
+      "Is this component painted, and with what?\n\n# Example\n```ts\nconst [component] = await snaptrude.design.selection.get()\nconst sampled = await snaptrude.design.materials.get(component)\nif (sampled) {\nconsole.log(sampled.name, sampled.source) // e.g. \"Brick Red\" \"applied\"\nconst info = await snaptrude.design.materials.getInfo(sampled.material)\nconsole.log(info?.colorHex)\n}\n```"
+    ],
+    "argsType": "ComponentHandle",
+    "resultType": "PluginComponentMaterial | null"
+  },
+  {
+    "path": "design.materials.getByFace",
+    "namespace": "design.materials",
+    "summary": "Read the material applied to a single BREP face.",
+    "examplePrompts": [
+      "What material is on the top face of this slab?",
+      "Get the finish applied to face 2 of this wall",
+      "Which material is painted on the front face of this column?\n\n# Example\n```ts\nconst [wall] = await snaptrude.design.query.listWalls()\nconst material = await snaptrude.design.materials.getByFace(wall, 0)\nif (material) console.log(await snaptrude.design.materials.getInfo(material))\n```"
+    ],
+    "argsType": "ComponentHandle",
+    "resultType": "MaterialHandle | null"
+  },
   {
     "path": "design.materials.getDefault",
     "namespace": "design.materials",
@@ -3210,17 +4371,41 @@
   {
     "path": "design.materials.list",
     "namespace": "design.materials",
-    "summary": "List the project materials.",
+    "summary": "List the materials loaded in the project — every named material in the live scene (applied finishes, plugin-created materials, and type defaults in use). For the browsable preset/library catalog (finishes not yet in the project), use {@linkcode PluginDesignMaterialsApi.listPresets}.",
     "examplePrompts": [
       "List all the materials in this project",
       "What materials do I have available to apply?",
-      "Show me the preset materials library",
       "Which finishes exist in this model?",
-      "Get every material in the project palette\n\n# Example\n```ts\nconst presets = await snaptrude.design.materials.list(\"preset\")\nconsole.log(presets.length, \"preset materials\")\n```"
+      "Get every material in the project palette\n\n# Example\n```ts\nconst materials = await snaptrude.design.materials.list()\nconsole.log(materials.length, \"materials in the project\")\n```"
     ],
-    "argsType": "\"project\" | \"preset\"",
+    "argsType": null,
     "resultType": "MaterialHandle[]"
   },
+  {
+    "path": "design.materials.listByFace",
+    "namespace": "design.materials",
+    "summary": "List the per-face materials of a component — one entry per BREP face, in face index order. A face carrying no explicit per-face material reports `null`.",
+    "examplePrompts": [
+      "List the material on every face of this wall",
+      "Show me which faces of this slab are painted and with what",
+      "Break down the per-face finishes of the selected mass\n\n# Example\n```ts\nconst [wall] = await snaptrude.design.query.listWalls()\nconst faces = await snaptrude.design.materials.listByFace(wall)\nfor (const f of faces) console.log(f.faceIndex, f.material ?? \"(default)\")\n```"
+    ],
+    "argsType": "ComponentHandle",
+    "resultType": "PluginFaceMaterial[]"
+  },
+  {
+    "path": "design.materials.listPresets",
+    "namespace": "design.materials",
+    "summary": "List the preset material library — the catalog the app's material browser shows (the built-in finishes plus the workspace's uploaded materials), fetched from the material library service. Library entries are **not** scene materials and carry no {@linkcode MaterialHandle}; each is a named texture record. To use one, feed it to {@linkcode PluginDesignMaterialsApi.create} / {@linkcode PluginDesignMaterialsApi.apply} as a {@linkcode PluginMaterialSpec}: `{ name, textureUrl, materialType: category }`.",
+    "examplePrompts": [
+      "Show me the preset materials library",
+      "What wood finishes are available in the material library?",
+      "Browse the material catalog and apply a brick texture",
+      "Which preset materials can I choose from?\n\n# Example\n```ts\nconst presets = await snaptrude.design.materials.listPresets()\nconst brick = presets.find((p) => p.category.toLowerCase().includes(\"brick\"))\nif (brick) {\nconst walls = await snaptrude.design.query.listWalls()\nawait snaptrude.design.materials.apply(walls, {\nname: brick.name,\ntextureUrl: brick.textureUrl,\nmaterialType: brick.category,\n})\n}\n```"
+    ],
+    "argsType": null,
+    "resultType": "PluginPresetMaterial[]"
+  },
   {
     "path": "design.materials.reset",
     "namespace": "design.materials",
@@ -3234,6 +4419,18 @@
     "argsType": "ComponentHandle[]",
     "resultType": "PluginMaterialResult"
   },
+  {
+    "path": "design.materials.resetFaces",
+    "namespace": "design.materials",
+    "summary": "Reset specific BREP faces of a component back to the component/type default, removing any per-face finish. The inverse of {@linkcode PluginDesignMaterialsApi.applyToFaces}; undoable when `save` is true (the default). BREP-only (see `applyToFaces`).",
+    "examplePrompts": [
+      "Remove the paint from the top face of this slab",
+      "Reset faces 0 and 2 of this wall to their default material",
+      "Clear the custom finish on the front face of this column\n\n# Example\n```ts\nconst [wall] = await snaptrude.design.query.listWalls({ storeys: [1] })\nconst { count } = await snaptrude.design.materials.resetFaces(wall, [0, 1])\nconsole.log(\"reset\", count, \"faces\")\n```"
+    ],
+    "argsType": "ComponentHandle",
+    "resultType": "PluginMaterialResult"
+  },
   {
     "path": "design.query.exists",
     "namespace": "design.query",
@@ -3368,10 +4565,11 @@
   {
     "path": "design.query.getProperties",
     "namespace": "design.query",
-    "summary": "Read an entity's common properties as a {@linkcode PluginEntityProperties} record (only applicable fields are present). For spaces/masses this includes `adjacency` — the per-entity adjacency read (bulk form: `program.adjacency.getMatrix`).",
+    "summary": "Read an entity's common properties as a {@linkcode PluginEntityProperties} record (only applicable fields are present). For spaces/masses this includes `adjacency` — the per-entity adjacency read (bulk form: `program.adjacency.getMatrix`). For walls and the slab family (slab / floor / roof / ceiling) this includes `buildingType` — the assigned building type NAME the panel's type dropdown shows, matching `design.types.list(kind)`.",
     "examplePrompts": [
       "Show me all the details of the selected object",
       "What storey is this wall on?",
+      "Which wall type is assigned to this wall?",
       "Which department does this room belong to?",
       "Is this element locked or hidden?",
       "Get the adjacencies of this space\n\n# Example\n```ts\nconst [wall] = await snaptrude.design.query.listWalls()\nconst props = await snaptrude.design.query.getProperties(wall)\nconsole.log(props.type, props.storey, props.boundingBox)\n\n// The record is partial — type-specific fields exist only where they apply\nconst [room] = await snaptrude.design.query.listSpaces()\nconst p = await snaptrude.design.query.getProperties(room)\nif (p.spaceType === \"Room\" && p.areaClass === \"NET\") {\nfor (const adj of p.adjacency ?? []) {\n// adj.value: 2 = direct, 1 = indirect/contact, -1 = restricted\nconsole.log(adj.spaceId, adj.value)\n}\n}\n```"
@@ -3379,6 +4577,19 @@
     "argsType": "ComponentHandle",
     "resultType": "PluginEntityProperties"
   },
+  {
+    "path": "design.query.getStaircaseParams",
+    "namespace": "design.query",
+    "summary": "Read a staircase's parametric properties — its preset, dimensions, step count, base offset, and height-lock state — as a {@linkcode PluginStaircaseParams} record. The paired write is `design.update.staircase`.",
+    "examplePrompts": [
+      "What's the riser height of this staircase?",
+      "How many steps does the selected stair have?",
+      "Show me the tread and width of this staircase",
+      "Read all the parameters of the stairs on level 1\n\n# Example\n```ts\nconst [stair] = await snaptrude.design.query.listStaircases({ isSelected: true })\nconst params = stair ? await snaptrude.design.query.getStaircaseParams(stair) : null\nif (params) console.log(params.steps, params.riser, params.tread)\n```"
+    ],
+    "argsType": "ComponentHandle",
+    "resultType": "PluginStaircaseParams | null"
+  },
   {
     "path": "design.query.listBeams",
     "namespace": "design.query",
@@ -3623,9 +4834,11 @@
     "examplePrompts": [
       "What's the area of this room?",
       "How long is the selected wall?",
+      "How thick is this wall?",
+      "Get the thickness of the slab on level 2",
       "Get the volume of this mass",
       "Give me the dimensions of the selected element",
-      "What's the floor area of the kitchen?\n\n# Example\n```ts\nconst [space] = await snaptrude.design.query.listSpaces()\nconst m = await snaptrude.design.query.measure(space)\nconsole.log(m?.area, m?.volume)\n```"
+      "What's the floor area of the kitchen?\n\n# Example\n```ts\nconst [space] = await snaptrude.design.query.listSpaces()\nconst m = await snaptrude.design.query.measure(space)\nconsole.log(m?.area, m?.volume)\n\n// wall dimensions — the panel's Thickness / Height, in engine units\nconst [wall] = await snaptrude.design.query.listWalls()\nconst wm = await snaptrude.design.query.measure(wall)\nconsole.log(wm?.thickness, wm?.height)\n```"
     ],
     "argsType": "ComponentHandle",
     "resultType": "PluginEntityMeasurements | null"
@@ -3724,43 +4937,228 @@
     "resultType": "PluginDesignChangeResult"
   },
   {
-    "path": "design.transform.move",
-    "namespace": "design.transform",
-    "summary": "Translate entities by a **relative** displacement vector (added to the first component's absolute position as the anchor). Undoable.",
+    "path": "design.selection.setByFilter",
+    "namespace": "design.selection",
+    "summary": "Replace the selection with every visible entity of the active building that matches the filter — the programmatic equivalent of the editor's **Story selection** (`storeys`) and **Filter selection** (`types`) menus under the select tool, including their combination (fields AND, values within a field OR). Reaches selection-only kinds the query surface cannot (sites, terrain, CAD/PDF/image imports, dimension lines, 3D models, neighborhood buildings) and selects whole groups the way the editor does.",
+    "examplePrompts": [
+      "Select everything on storey 2",
+      "Select all the walls and doors",
+      "Story selection: select the ground floor and first floor",
+      "Filter selection: select all furniture in the model",
+      "Select only the furniture on the second storey",
+      "Select all the spaces so I can recolor them\n\n# Example\n```ts\n// \"Story selection\": everything on storeys 1 and 2\nawait snaptrude.design.selection.setByFilter({ storeys: [1, 2] })\n\n// \"Filter selection\": all walls and doors\nawait snaptrude.design.selection.setByFilter({ types: [\"wall\", \"door\"] })\n\n// Combined: only the furniture on storey 2\nconst { affected } = await snaptrude.design.selection.setByFilter({\nstoreys: [2],\ntypes: [\"furniture\"],\n})\n```"
+    ],
+    "argsType": "PluginSelectionFilter",
+    "resultType": "PluginDesignChangeResult"
+  },
+  {
+    "path": "design.transform.align",
+    "namespace": "design.transform",
+    "summary": "Align a set of components by snapping one bounding-box edge to a common value — the classic Left/Center/Right/Top/Middle/Bottom align. Purely **world-axis** (deterministic and headless — the UI's camera-relative remap is bypassed):",
+    "examplePrompts": [
+      "Align the selected rooms to the left",
+      "Line up these masses along their top edges",
+      "Center these columns horizontally",
+      "Align all the walls to the left edge of this reference wall",
+      "Snap the bottom edges of these spaces together\n\n# Example\n```ts\nconst rooms = await snaptrude.design.selection.get()\n// align every room's left (world -X) edge to a common minimum\nawait snaptrude.design.transform.align(rooms, \"left\")\n// …or align them to a fixed reference component's left edge\nconst [anchor] = await snaptrude.design.query.listWalls({ storeys: [1] })\nawait snaptrude.design.transform.align(rooms, \"left\", { reference: anchor })\n```"
+    ],
+    "argsType": "ComponentHandle[]",
+    "resultType": "PluginDesignChangeResult"
+  },
+  {
+    "path": "design.transform.mirror",
+    "namespace": "design.transform",
+    "summary": "Mirror components **in place** about a horizontal axis, flipping their geometry across that axis through the combined bounding-box centre (the mesh's world-matrix flip + brep inversion + CAD/dimension-line/parametric handling commit atomically). Nothing moves off-centre — this is the toolbar \"flip\", not a translate-and-reflect. Undoable.",
+    "examplePrompts": [
+      "Mirror the selected building across the x axis",
+      "Flip these rooms left to right",
+      "Mirror this furniture block horizontally",
+      "Flip the selected walls front to back",
+      "Create a mirror image of these masses about the z axis\n\n# Example\n```ts\nconst rooms = await snaptrude.design.selection.get()\nawait snaptrude.design.transform.mirror(rooms, \"x\")\n```"
+    ],
+    "argsType": "ComponentHandle[]",
+    "resultType": "PluginDesignChangeResult"
+  },
+  {
+    "path": "design.transform.move",
+    "namespace": "design.transform",
+    "summary": "Translate entities by a **relative** displacement vector (added to the first component's absolute position as the anchor). Undoable.",
+    "examplePrompts": [
+      "Move the selected room 5 metres to the right",
+      "Shift these walls 3m along the x axis",
+      "Nudge this space 500mm north",
+      "Translate the furniture block by (10, 0, 5)",
+      "Move these masses up one storey\n\n# Example\n```ts\nconst { vec3 } = snaptrude.core.math\nawait snaptrude.design.transform.move([\"space-id\"], vec3.new(10, 0, 0))\n```"
+    ],
+    "argsType": "ComponentHandle[]",
+    "resultType": "PluginDesignChangeResult"
+  },
+  {
+    "path": "design.transform.rotate",
+    "namespace": "design.transform",
+    "summary": "Rotate entities by a **signed angle in DEGREES** (positive = CCW about +Y). The pivot defaults to the combined bounding-box centre; pass `options.pivot` to rotate about an explicit world-space point instead. NOTE: unlike the removed `tools.transform.rotate` (radians), this canonical form takes DEGREES. Undoable.",
+    "examplePrompts": [
+      "Rotate the selected building 90 degrees",
+      "Turn this room 45 degrees clockwise",
+      "Spin the furniture block 180 degrees about its centre",
+      "Rotate these masses 30 degrees around the vertical axis",
+      "Rotate these walls 90 degrees about the origin\n\n# Example\n```ts\nawait snaptrude.design.transform.rotate([\"space-id\"], 90)\n// …or rotate about an explicit pivot point\nconst { vec3 } = snaptrude.core.math\nawait snaptrude.design.transform.rotate([\"space-id\"], 90, { pivot: vec3.new(0, 0, 0) })\n```"
+    ],
+    "argsType": "ComponentHandle[]",
+    "resultType": "PluginDesignChangeResult"
+  },
+  {
+    "path": "design.types.get",
+    "namespace": "design.types",
+    "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.id)\nif (type) for (const layer of type.layers) console.log(layer.name, layer.thickness)\n```"
+    ],
+    "argsType": "string",
+    "resultType": "PluginBuildingType | null"
+  },
+  {
+    "path": "design.types.list",
+    "namespace": "design.types",
+    "summary": "List the building types of one `kind` (wall / slab / floor / ceiling / roof) — the built-in defaults plus any team/user-added types. Returns lightweight summaries; call {@linkcode PluginDesignTypesApi.get} for the full layer stack.",
+    "examplePrompts": [
+      "What wall types does this project have?",
+      "List the available slab assemblies",
+      "Show me every roof type in the project",
+      "Which floor types can I use?\n\n# Example\n```ts\nconst wallTypes = await snaptrude.design.types.list(\"wall\")\nfor (const t of wallTypes) console.log(t.id, t.label, t.thickness)\n```"
+    ],
+    "argsType": "PluginBuildingTypeKind",
+    "resultType": "PluginBuildingTypeSummary[]"
+  },
+  {
+    "path": "design.unlock",
+    "namespace": "design",
+    "summary": "Unlock previously locked entities so they can be edited again. Undoable. Paired with {@linkcode PluginDesignApi.lock}.",
+    "examplePrompts": [
+      "Unlock the selected objects",
+      "Make this locked wall editable again",
+      "Unfreeze the masses I locked earlier",
+      "Remove the lock from these doors\n\n# Example\n```ts\n// Unlock everything that is explicitly locked\nconst locked = await snaptrude.design.listLocked()\nconst { affected } = await snaptrude.design.unlock(locked)\n```"
+    ],
+    "argsType": "ComponentHandle[]",
+    "resultType": "PluginDesignChangeResult"
+  },
+  {
+    "path": "design.unlockArea",
+    "namespace": "design",
+    "summary": "Unlock the footprint area of previously area-locked spaces so their area can change again. Paired with {@linkcode PluginDesignApi.lockArea}; cascades to instances + source; undoable. Requires the `area_lock` feature (throws if off).",
+    "examplePrompts": [
+      "Unlock the area of the selected rooms",
+      "Remove the footprint-area lock from this department",
+      "Let me resize this space again by unlocking its area",
+      "Area-unlock everything I locked earlier\n\n# Example\n```ts\nconst locked = await snaptrude.design.listAreaLocked()\nconst { affected } = await snaptrude.design.unlockArea(locked)\n```"
+    ],
+    "argsType": "ComponentHandle[]",
+    "resultType": "PluginDesignChangeResult"
+  },
+  {
+    "path": "design.update.ceiling",
+    "namespace": "design.update",
+    "summary": "Edit a **ceiling's** thickness — the slab-family updater for ceilings (shares the slab thickness command). Undoable. Thickness is in **engine units** (the `design.doors.setWidth` convention) and must be `> 0`. Ceilings have no Overhang control, so `overhang` is rejected with `PRECONDITION_FAILED`.",
+    "examplePrompts": [
+      "Make this ceiling 150mm thick",
+      "Set every ceiling to a 100 thickness",
+      "Thicken the ceiling to 200\n\n# Example\n```ts\nconst [ceiling] = await snaptrude.design.query.listCeilings()\nawait snaptrude.design.update.ceiling(ceiling, { thickness: 150 })\n```"
+    ],
+    "argsType": "ComponentHandle",
+    "resultType": "PluginDesignChangeResult"
+  },
+  {
+    "path": "design.update.floor",
+    "namespace": "design.update",
+    "summary": "Edit a **floor's** thickness — the slab-family updater for floors (shares the slab thickness command). Undoable. Thickness is in **engine units** (the `design.doors.setWidth` convention) and must be `> 0`. Floors have no Overhang control, so `overhang` is rejected with `PRECONDITION_FAILED`.",
+    "examplePrompts": [
+      "Make this floor 200mm thick",
+      "Set every floor to a 250 thickness",
+      "Thicken the ground floor slab to 300\n\n# Example\n```ts\nconst [floor] = await snaptrude.design.query.listFloors()\nawait snaptrude.design.update.floor(floor, { thickness: 200 })\n```"
+    ],
+    "argsType": "ComponentHandle",
+    "resultType": "PluginDesignChangeResult"
+  },
+  {
+    "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",
+    "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": [
+      "Set this element's elevation to 3000",
+      "Raise this mass so its base sits at 3 metres",
+      "Drop the selected slab to elevation 0",
+      "Put this staircase's base at 3200\n\n# Example\n```ts\n// Sit the roof slab exactly at the top of a 3m storey\nconst [roof] = await snaptrude.design.query.listRoofs()\nawait snaptrude.design.update.setElevation(roof, 3000)\n```"
+    ],
+    "argsType": "ComponentHandle",
+    "resultType": "PluginDesignChangeResult"
+  },
+  {
+    "path": "design.update.setLabel",
+    "namespace": "design.update",
+    "summary": "Set a component's **Label** — the same editable Label field the properties panel shows (doors, windows, furniture, spaces, and every other labelled component). The paired read is `design.query.getLabel`. Undoable; the canvas label text updates immediately.",
     "examplePrompts": [
-      "Move the selected room 5 metres to the right",
-      "Shift these walls 3m along the x axis",
-      "Nudge this space 500mm north",
-      "Translate the furniture block by (10, 0, 5)",
-      "Move these masses up one storey\n\n# Example\n```ts\nconst { vec3 } = snaptrude.core.math\nawait snaptrude.design.transform.move([\"space-id\"], vec3.new(10, 0, 0))\n```"
+      "Rename this door to D-101",
+      "Number all doors on storey 2 with a D-2-XX tag",
+      "Set the selected window's label to W-04",
+      "Tag every door with its fire rating\n\n# Example\n```ts\n// Door tag numbering: label every door as D-<storey>-<n>, numbered per storey\nawait snaptrude.design.selection.setByFilter({ types: [\"door\"] })\nconst doors = await snaptrude.design.selection.get()\nconst counts = {}\nfor (const door of doors) {\nconst { storey = 0 } = await snaptrude.design.query.getProperties(door)\ncounts[storey] = (counts[storey] ?? 0) + 1\nawait snaptrude.design.update.setLabel(door, `D-${storey}-${String(counts[storey]).padStart(2, \"0\")}`)\n}\n```"
     ],
-    "argsType": "ComponentHandle[]",
-    "resultType": "PluginDesignChangeResult"
+    "argsType": "ComponentHandle",
+    "resultType": "boolean"
   },
   {
-    "path": "design.transform.rotate",
-    "namespace": "design.transform",
-    "summary": "Rotate entities by a **signed angle in DEGREES**, anchored at the combined bounding-box centre (positive = CCW about +Y). NOTE: unlike the removed `tools.transform.rotate` (radians + caller pivot), this canonical form takes DEGREES and has NO caller pivot — the pivot is always the bbox centre. Undoable.",
+    "path": "design.update.setStorey",
+    "namespace": "design.update",
+    "summary": "Reassign one or more components to another **storey** — the same operation as the properties panel's Story dropdown, and it works across element kinds exactly like the panel (walls, slabs, masses, furniture, staircases, ...). Each component is moved vertically to the target storey's level (per-kind placement rules — e.g. a slab sits at the storey base, a wall on it) and its storey assignment, children, and dimension lines update together as **one undoable operation**.",
     "examplePrompts": [
-      "Rotate the selected building 90 degrees",
-      "Turn this room 45 degrees clockwise",
-      "Spin the furniture block 180 degrees about its centre",
-      "Rotate these masses 30 degrees around the vertical axis\n\n# Example\n```ts\nawait snaptrude.design.transform.rotate([\"space-id\"], 90)\n```"
+      "Move this sofa to storey 2",
+      "Put the selected walls on the first basement level",
+      "Send everything on this storey up one level",
+      "Reassign these slabs to storey 3\n\n# Example\n```ts\n// Move the current selection up to storey 2\nconst selection = await snaptrude.design.selection.get()\nconst { affected } = await snaptrude.design.update.setStorey(selection, 2)\nconsole.log(\"moved\", affected.length, \"components\")\n```"
     ],
     "argsType": "ComponentHandle[]",
     "resultType": "PluginDesignChangeResult"
   },
   {
-    "path": "design.unlock",
-    "namespace": "design",
-    "summary": "Unlock previously locked entities so they can be edited again. Undoable. Paired with {@linkcode PluginDesignApi.lock}.",
+    "path": "design.update.slab",
+    "namespace": "design.update",
+    "summary": "Edit a **slab's** thickness and/or overhang — the same commands the properties panel's Thickness field and Overhang slider drive. Sparse: only the fields you provide change. Undoable; the slab rebuilds and dimension lines refresh. Both values are in **engine units** (the same convention as `design.doors.setWidth`); thickness must be `> 0`, overhang is an absolute offset (negative insets the slab) and re-applying the current overhang is a no-op.",
     "examplePrompts": [
-      "Unlock the selected objects",
-      "Make this locked wall editable again",
-      "Unfreeze the masses I locked earlier",
-      "Remove the lock from these doors\n\n# Example\n```ts\n// Unlock everything that is explicitly locked\nconst locked = await snaptrude.design.listLocked()\nconst { affected } = await snaptrude.design.unlock(locked)\n```"
+      "Set this slab's thickness to 250mm",
+      "Make the floor slab 300 thick",
+      "Give this slab a 200 overhang",
+      "Remove the overhang on every slab on level 2\n\n# Example\n```ts\nconst [slab] = await snaptrude.design.query.listSlabs()\nawait snaptrude.design.update.slab(slab, { thickness: 250, overhang: 200 })\n```"
     ],
-    "argsType": "ComponentHandle[]",
+    "argsType": "ComponentHandle",
     "resultType": "PluginDesignChangeResult"
   },
   {
@@ -3791,6 +5189,99 @@
     "argsType": "PluginUpdateSpaceItem[]",
     "resultType": "PluginSpaceUpdateResult[]"
   },
+  {
+    "path": "design.update.staircase",
+    "namespace": "design.update",
+    "summary": "Update the parameters of one or more staircases — riser, tread, width, depth, step count, total height, well size, landing depth, base offset, and the two height locks — in one undoable operation. Sparse: only the fields you provide change. The paired read is `design.query.getStaircaseParams`.",
+    "examplePrompts": [
+      "Set the riser of this staircase to 165mm",
+      "Change all the stairs to 14 steps",
+      "Make the selected staircase 1200 wide with a 280 tread",
+      "Widen every staircase on level 1 to 1 metre",
+      "Unlock the height and set this stair to 3200 tall\n\n# Example\n```ts\n// Give every ground-floor staircase a common riser + tread (engine units)\nconst stairs = await snaptrude.design.query.listStaircases({ storeys: [1] })\nconst { affected } = await snaptrude.design.update.staircase(stairs, {\nriser: 165,\ntread: 280,\n})\nconsole.log(\"updated\", affected.length, \"staircases\")\n```"
+    ],
+    "argsType": "ComponentHandle[]",
+    "resultType": "PluginDesignChangeResult"
+  },
+  {
+    "path": "design.update.wall",
+    "namespace": "design.update",
+    "summary": "Edit a **wall** — its thickness and/or height (the same command the properties panel's Thickness/Height fields drive) and/or its **wall type** (the panel's Wall Types dropdown: converts the wall to another type, rebuilding its layer stack and materials). Sparse: only the fields you provide change. Undoable; the geometry rebuilds and any dimension lines refresh. Stacked-wall companions and hosted fenestration are handled exactly as the panel does.",
+    "examplePrompts": [
+      "Make this wall 230mm thick",
+      "Set the selected wall's height to 3 metres",
+      "Thicken every exterior wall to 300",
+      "Change this wall to a Glass Wall",
+      "Convert all the partitions on this floor to Brick Wall\n\n# Example\n```ts\n// Convert every wall on storey 1 to the first listed wall type\nconst [wallType] = await snaptrude.design.types.list(\"wall\")\nconst walls = await snaptrude.design.query.listWalls({ storeys: [1] })\nfor (const wall of walls) {\nawait snaptrude.design.update.wall(wall, { type: wallType.id })\n}\n```"
+    ],
+    "argsType": "ComponentHandle",
+    "resultType": "PluginDesignChangeResult"
+  },
+  {
+    "path": "design.visibility.hide",
+    "namespace": "design.visibility",
+    "summary": "Hide entities from the viewport — the same as the \"Hide\" action. Undoable. Hosted door/window/void children ride along with their wall. Already-hidden entities stay hidden.",
+    "examplePrompts": [
+      "Hide the selected walls",
+      "Conceal these masses so I can see behind them",
+      "Hide every column on this floor",
+      "Make this furniture disappear from view\n\n# Example\n```ts\nconst walls = await snaptrude.design.query.listWalls({ storeys: [1] })\nconst { affected } = await snaptrude.design.visibility.hide(walls)\n```"
+    ],
+    "argsType": "ComponentHandle[]",
+    "resultType": "PluginDesignChangeResult"
+  },
+  {
+    "path": "design.visibility.isolate",
+    "namespace": "design.visibility",
+    "summary": "Isolate entities — hide everything else so only the given entities remain visible (the \"Isolate\" / solo action). Undoable. Reverse it with {@linkcode PluginDesignVisibilityApi.showAll}.",
+    "examplePrompts": [
+      "Isolate the selected room so I can focus on it",
+      "Show only these walls and hide the rest",
+      "Solo this mass",
+      "Hide everything except the staircase\n\n# Example\n```ts\nconst [room] = await snaptrude.design.selection.get()\nawait snaptrude.design.visibility.isolate([room])\n```"
+    ],
+    "argsType": "ComponentHandle[]",
+    "resultType": "PluginDesignChangeResult"
+  },
+  {
+    "path": "design.visibility.showAll",
+    "namespace": "design.visibility",
+    "summary": "Reveal everything hidden on the active story — the \"Show All\" action, which also exits an isolate. Undoable.",
+    "examplePrompts": [
+      "Show everything again",
+      "Unhide all the hidden objects",
+      "Exit isolate mode",
+      "Reveal everything I hid earlier\n\n# Example\n```ts\nconst { affected } = await snaptrude.design.visibility.showAll()\nconsole.log(`Revealed ${affected.length} entities`)\n```"
+    ],
+    "argsType": null,
+    "resultType": "PluginDesignChangeResult"
+  },
+  {
+    "path": "design.windows.exists",
+    "namespace": "design.windows",
+    "summary": "Test whether a window catalog item exists for the given library id.",
+    "examplePrompts": [
+      "Is this window still in the library?",
+      "Check whether a window catalog item with this id exists",
+      "Does my team library have this window?",
+      "Verify the window is available before placing it\n\n# Example\n```ts\nconst [entry] = await snaptrude.design.windows.listCatalog()\nconst stillAvailable = await snaptrude.design.windows.exists(entry.id)\nconsole.log(stillAvailable ? \"safe to place\" : \"removed from library\")\n```"
+    ],
+    "argsType": "string",
+    "resultType": "boolean"
+  },
+  {
+    "path": "design.windows.getCatalogItem",
+    "namespace": "design.windows",
+    "summary": "Get a single window catalog item by its library id.",
+    "examplePrompts": [
+      "Get the details of this window from the library",
+      "Look up the catalog entry for this window id",
+      "What is the cost of this window item?",
+      "Show me the family name of this window in the catalog\n\n# Example\n```ts\nconst [entry] = await snaptrude.design.windows.listCatalog()\nconst item = await snaptrude.design.windows.getCatalogItem(entry.id)\nif (item) console.log(item.name, item.source, item.dbType)\n```"
+    ],
+    "argsType": "string",
+    "resultType": "PluginObjectCatalogItem | null"
+  },
   {
     "path": "design.windows.getDimensions",
     "namespace": "design.windows",
@@ -3844,6 +5335,32 @@
     "argsType": "ComponentHandle",
     "resultType": "number | null"
   },
+  {
+    "path": "design.windows.listCatalog",
+    "namespace": "design.windows",
+    "summary": "List the placeable window catalog (team + general libraries), optionally restricted to one group by its `dbType` token.",
+    "examplePrompts": [
+      "What windows can I place in this project?",
+      "List every window in the library",
+      "Show me the casement windows I can add",
+      "Browse the window catalog\n\n# Example\n```ts\nconst [group] = await snaptrude.design.windows.listCatalogGroups()\nconst items = await snaptrude.design.windows.listCatalog(group?.dbType)\nfor (const item of items) console.log(item.id, item.name, item.thumbnailUrl)\n```"
+    ],
+    "argsType": "string",
+    "resultType": "PluginObjectCatalogItem[]"
+  },
+  {
+    "path": "design.windows.listCatalogGroups",
+    "namespace": "design.windows",
+    "summary": "List the window catalog **groups** — the placement families (Fixed, Casement, Sliding, Folding, …), built-in groups merged with any team-custom types.",
+    "examplePrompts": [
+      "What kinds of windows can I place?",
+      "List the window groups in the catalog",
+      "Show me the window families available in this project",
+      "Which window types does this project support?\n\n# Example\n```ts\nconst groups = await snaptrude.design.windows.listCatalogGroups()\nfor (const g of groups) console.log(g.dbType, g.label, g.source)\n```"
+    ],
+    "argsType": null,
+    "resultType": "PluginObjectCatalogGroup[]"
+  },
   {
     "path": "design.windows.setHeight",
     "namespace": "design.windows",
@@ -3965,6 +5482,32 @@
     "argsType": "number",
     "resultType": "PluginStoryCreateResult"
   },
+  {
+    "path": "entity.story.delete",
+    "namespace": "entity.story",
+    "summary": "Delete a story and everything on it — the same as removing it from the storey panel. Every element placed on the story (walls, floors, masses, …) is deleted with it, the remaining stories are re-stacked, and the active story falls back to an adjacent one. Committed as a single undo step.",
+    "examplePrompts": [
+      "Delete the top floor",
+      "Remove the basement level",
+      "Get rid of storey 3",
+      "Delete the second floor and everything on it\n\n# Example\n```ts\nconst { newActiveStory } = await snaptrude.entity.story.delete(3)\nconsole.log(`Deleted story 3; now on story ${newActiveStory}`)\n```"
+    ],
+    "argsType": "number",
+    "resultType": "PluginStoryDeleteResult"
+  },
+  {
+    "path": "entity.story.duplicate",
+    "namespace": "entity.story",
+    "summary": "Duplicate a story into the adjacent level, up or down.",
+    "examplePrompts": [
+      "Duplicate this floor to the storey above",
+      "Copy the ground floor down into a new basement",
+      "Repeat this level upwards with its own independent geometry",
+      "Duplicate just the selected walls onto the next floor up\n\n# Example\n```ts\n// Duplicate the whole active story one level up (instanced copies).\nconst { targetStories, created, skipped } =\nawait snaptrude.entity.story.duplicate(\"up\")\nconsole.log(`Copied ${created.length} elements onto story ${targetStories}`)\nif (skipped) console.log(`${skipped} elements were skipped`)\n```"
+    ],
+    "argsType": "\"up\" | \"down\"",
+    "resultType": "PluginStoryDuplicateResult"
+  },
   {
     "path": "entity.story.get",
     "namespace": "entity.story",
@@ -3992,15 +5535,29 @@
     "argsType": null,
     "resultType": "PluginStoryGetAllResult"
   },
+  {
+    "path": "entity.story.setActive",
+    "namespace": "entity.story",
+    "summary": "Make a story the active story — the same as clicking it in the storey/layer panel. Subsequent draws and creates target this story, 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",
+      "Go to the basement level",
+      "Set level 3 as the current storey\n\n# Example\n```ts\n// Activate story 2, then draw a wall — it lands on story 2.\nawait snaptrude.entity.story.setActive(2)\n```"
+    ],
+    "argsType": "number",
+    "resultType": "PluginStorySetActiveResult"
+  },
   {
     "path": "entity.story.update",
     "namespace": "entity.story",
-    "summary": "Update a story's height.",
+    "summary": "Update a story's floor-to-floor `height` and/or `name`.",
     "examplePrompts": [
       "Change the ground floor height to 3.5 metres",
       "Make the second storey taller",
+      "Rename the ground floor to \"Lobby\"",
       "Set the floor-to-floor height of level 1",
-      "Increase the height of the third floor\n\n# Example\n```ts\n// Set ground floor height to 5 Babylon units\nconst result = await snaptrude.entity.story.update(1, 5)\n```"
+      "Rename storey 2 and make it taller in one go\n\n# Example\n```ts\n// Set ground floor height to 5 Babylon units — walls stretch and the\n// floors above move up to match, all in a single undo step.\nconst result = await snaptrude.entity.story.update(1, 5)\n// Rename only, leaving the height untouched.\nawait snaptrude.entity.story.update(1, undefined, { name: \"Lobby\" })\n```"
     ],
     "argsType": "number",
     "resultType": "PluginStoryUpdateResult"
@@ -4211,6 +5768,67 @@
     "argsType": "PluginAIInspirationSaveRecipeArgs",
     "resultType": "PluginAIInspirationSaveRecipeResult"
   },
+  {
+    "path": "presentation.annotate.arrow",
+    "namespace": "presentation.annotate",
+    "summary": "Draw an arrow on a sheet.",
+    "examplePrompts": [
+      "Draw an arrow pointing at the entrance on Sheet 1",
+      "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",
+    "resultType": "PluginPresentationAnnotateResult"
+  },
+  {
+    "path": "presentation.annotate.note",
+    "namespace": "presentation.annotate",
+    "summary": "Add a sticky note to a sheet.",
+    "examplePrompts": [
+      "Add a sticky note \"Review this wall\" to Sheet 1",
+      "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",
+    "resultType": "PluginPresentationAnnotateResult"
+  },
+  {
+    "path": "presentation.annotate.shape",
+    "namespace": "presentation.annotate",
+    "summary": "Draw a geo shape (rectangle, ellipse, cloud, …) on a sheet.",
+    "examplePrompts": [
+      "Draw a revision cloud around the kitchen on Sheet 2",
+      "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",
+    "resultType": "PluginPresentationAnnotateResult"
+  },
+  {
+    "path": "presentation.annotate.text",
+    "namespace": "presentation.annotate",
+    "summary": "Add a text label to a sheet.",
+    "examplePrompts": [
+      "Add a title \"Ground Floor\" to Sheet 1",
+      "Label the cover sheet with the project name",
+      "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",
+    "resultType": "PluginPresentationAnnotateTextResult"
+  },
+  {
+    "path": "presentation.diagrams.generateProgram",
+    "namespace": "presentation.diagrams",
+    "summary": "Generate the program (space + department) diagrams for the current model, creating new layout sheets.",
+    "examplePrompts": [
+      "Generate the program diagrams for this project",
+      "Auto-generate the space and department diagram sheets",
+      "Create the program layout sheets from the model\n\n# Example\n```ts\nconst { sheetIds } = await snaptrude.presentation.diagrams.generateProgram()\n```"
+    ],
+    "argsType": null,
+    "resultType": "PluginPresentationDiagramsGenerateResult"
+  },
   {
     "path": "presentation.diagrams.place",
     "namespace": "presentation.diagrams",
@@ -4223,6 +5841,20 @@
     "argsType": "string",
     "resultType": "PluginPresentationDiagramsPlaceResult"
   },
+  {
+    "path": "presentation.export",
+    "namespace": "presentation",
+    "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\")\n```"
+    ],
+    "argsType": "PluginPresentationExportFormat",
+    "resultType": "PluginPresentationExportResult"
+  },
   {
     "path": "presentation.import.image",
     "namespace": "presentation.import",
@@ -4249,18 +5881,44 @@
     "argsType": "{ url?: string; dataUrl?: string }",
     "resultType": "PluginPresentationImportResult"
   },
+  {
+    "path": "presentation.import.svg",
+    "namespace": "presentation.import",
+    "summary": "Import an SVG onto the current Present sheet as a vector asset.",
+    "examplePrompts": [
+      "Import this SVG diagram onto the present canvas",
+      "Add a vector logo to my presentation board",
+      "Place this SVG floor plan on the current sheet as vectors",
+      "Bring a crisp vector graphic into Present mode\n\n# Example\n```ts\nconst { shapeIds } = await snaptrude.presentation.import.svg({\nurl: \"https://example.com/diagram.svg\",\n})\n```"
+    ],
+    "argsType": "{ url?: string; dataUrl?: string }",
+    "resultType": "PluginPresentationImportResult"
+  },
   {
     "path": "presentation.sheets.create",
     "namespace": "presentation.sheets",
     "summary": "Create a new layout sheet.",
     "examplePrompts": [
       "Create a new sheet called Cover",
-      "Add a layout sheet",
-      "Make a new presentation sheet named Floor Plans\n\n# Example\n```ts\nconst sheet = await snaptrude.presentation.sheets.create(\"Cover\")\n```"
+      "Add an A3 landscape layout sheet",
+      "Make a new ANSI D presentation sheet named Floor Plans",
+      "Create a portrait A4 sheet\n\n# Example\n```ts\nconst sheet = await snaptrude.presentation.sheets.create(\"Cover\", {\nsize: \"ISO_A3\",\norientation: \"landscape\",\n})\n```"
     ],
     "argsType": "string",
     "resultType": "PluginPresentationSheet"
   },
+  {
+    "path": "presentation.sheets.delete",
+    "namespace": "presentation.sheets",
+    "summary": "Delete a layout sheet.",
+    "examplePrompts": [
+      "Delete sheet_2",
+      "Remove the Cover sheet",
+      "Get rid of the last layout sheet\n\n# Example\n```ts\nconst { id } = await snaptrude.presentation.sheets.delete(\"sheet_2\")\n```"
+    ],
+    "argsType": "string",
+    "resultType": "PluginPresentationSheetsDeleteResult"
+  },
   {
     "path": "presentation.sheets.get",
     "namespace": "presentation.sheets",
@@ -4294,11 +5952,73 @@
       "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\n\n# Example\n```ts\nconst { shapeId } = await snaptrude.presentation.sheets.place(\"sheet_1\", \"view_123\")\n```"
+      "Put the Ground Floor view on sheet_1 at 1:100 scale",
+      "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.rename",
+    "namespace": "presentation.sheets",
+    "summary": "Rename a layout sheet.",
+    "examplePrompts": [
+      "Rename sheet_1 to Cover",
+      "Call the first sheet Ground Floor",
+      "Change this sheet's name to Site Plan\n\n# Example\n```ts\nconst sheet = await snaptrude.presentation.sheets.rename(\"sheet_1\", \"Cover\")\n```"
+    ],
+    "argsType": "string",
+    "resultType": "PluginPresentationSheet"
+  },
+  {
+    "path": "presentation.sheets.reorder",
+    "namespace": "presentation.sheets",
+    "summary": "Move a sheet to a new position in the sheet order.",
+    "examplePrompts": [
+      "Move sheet_3 to the front",
+      "Make the Cover sheet the first sheet",
+      "Reorder this sheet to position 2\n\n# Example\n```ts\nconst { sheets } = await snaptrude.presentation.sheets.reorder(\"sheet_3\", 0)\n```"
+    ],
+    "argsType": "string",
+    "resultType": "PluginPresentationSheetsListResult"
+  },
+  {
+    "path": "presentation.sheets.setActive",
+    "namespace": "presentation.sheets",
+    "summary": "Make a sheet the active sheet.",
+    "examplePrompts": [
+      "Go to sheet_1",
+      "Open the Cover sheet",
+      "Switch to the Site Plan sheet\n\n# Example\n```ts\nawait snaptrude.presentation.sheets.setActive(\"sheet_1\")\n```"
+    ],
+    "argsType": "string",
+    "resultType": "PluginPresentationSheet"
+  },
+  {
+    "path": "presentation.sheets.setSize",
+    "namespace": "presentation.sheets",
+    "summary": "Set a sheet's paper size and/or orientation.",
+    "examplePrompts": [
+      "Resize sheet_1 to A1",
+      "Make the cover sheet ANSI B portrait",
+      "Change this sheet to Arch D landscape",
+      "Set the sheet size to A3\n\n# Example\n```ts\nconst sheet = await snaptrude.presentation.sheets.setSize(\"sheet_1\", \"ISO_A1\", \"portrait\")\n```"
+    ],
+    "argsType": "string",
+    "resultType": "PluginPresentationSheet"
+  },
+  {
+    "path": "presentation.sheets.updatePlacedView",
+    "namespace": "presentation.sheets",
+    "summary": "Refresh placed views to the current model state.",
+    "examplePrompts": [
+      "Update all the placed views to the latest model",
+      "Refresh the views on sheet_1",
+      "Re-render the placed views after my edits\n\n# Example\n```ts\nconst { shapeIds } = await snaptrude.presentation.sheets.updatePlacedView()\n```"
+    ],
+    "argsType": "{\n    sheetId?: string\n  }",
+    "resultType": "PluginPresentationSheetsUpdatePlacedViewResult"
+  },
   {
     "path": "presentation.views.capture",
     "namespace": "presentation.views",
@@ -4320,11 +6040,24 @@
       "Save the current view as Lobby Perspective",
       "Create a new saved view from where I'm looking",
       "Bookmark this camera angle",
-      "Save the current 2D plan as a view\n\n# Example\n```ts\nconst view = await snaptrude.presentation.views.create(\"Lobby\")\n```"
+      "Save the current 2D plan as a view",
+      "Save a view on the second storey\n\n# Example\n```ts\nconst view = await snaptrude.presentation.views.create(\"Lobby\")\n// …or capture the view on a specific storey\nconst level2 = await snaptrude.presentation.views.create(\"Level 2\", { storey: 2 })\n```"
     ],
     "argsType": "string",
     "resultType": "PluginPresentationViewsCreateResult"
   },
+  {
+    "path": "presentation.views.delete",
+    "namespace": "presentation.views",
+    "summary": "Delete a saved view.",
+    "examplePrompts": [
+      "Delete the view named Old Draft",
+      "Remove this saved view",
+      "Get rid of the Lobby camera bookmark\n\n# Example\n```ts\nconst { id } = await snaptrude.presentation.views.delete(\"view_123\")\n```"
+    ],
+    "argsType": "string",
+    "resultType": "PluginPresentationViewsDeleteResult"
+  },
   {
     "path": "presentation.views.get",
     "namespace": "presentation.views",
@@ -4349,6 +6082,19 @@
     "argsType": null,
     "resultType": "PluginPresentationViewsGetResult"
   },
+  {
+    "path": "presentation.views.getSettings",
+    "namespace": "presentation.views",
+    "summary": "Read a saved view's display settings (background, color mode, view mode, axis, edges, labels).",
+    "examplePrompts": [
+      "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\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"
+  },
   {
     "path": "presentation.views.list",
     "namespace": "presentation.views",
@@ -4363,6 +6109,18 @@
     "argsType": null,
     "resultType": "PluginPresentationViewsListResult"
   },
+  {
+    "path": "presentation.views.rename",
+    "namespace": "presentation.views",
+    "summary": "Rename a saved view.",
+    "examplePrompts": [
+      "Rename the view Lobby to Entrance Lobby",
+      "Call this view Ground Floor Plan",
+      "Change the active view's name to Final\n\n# Example\n```ts\nconst view = await snaptrude.presentation.views.rename(\"view_123\", \"Entrance\")\n```"
+    ],
+    "argsType": "string",
+    "resultType": "PluginPresentationViewsRenameResult"
+  },
   {
     "path": "presentation.views.setActive",
     "namespace": "presentation.views",
@@ -4376,6 +6134,21 @@
     "argsType": "string",
     "resultType": "PluginPresentationViewsSetActiveResult"
   },
+  {
+    "path": "presentation.views.updateSettings",
+    "namespace": "presentation.views",
+    "summary": "Update a saved view's display settings (partial patch — only the fields you pass change).",
+    "examplePrompts": [
+      "Switch this view to monochrome color mode",
+      "Turn off the axis in the Ground Floor view",
+      "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\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": "program.adjacency.compute",
     "namespace": "program.adjacency",
@@ -4409,6 +6182,8 @@
     "examplePrompts": [
       "What's my FAR right now?",
       "Give me the program area summary",
+      "What is my net internal area vs gross external area?",
+      "How much net and gross area do I have?",
       "How much built-up area have I used against the site area?",
       "Am I within my FAR target?\n\n# Example\n```ts\nconst s = await snaptrude.program.areas.get()\nconsole.log(s.builtUp, s.siteArea, s.achievedFar, s.targetFar, s.areaUnit)\n```"
     ],
@@ -4421,6 +6196,7 @@
     "summary": "List the program area rollup grouped by a facet.",
     "examplePrompts": [
       "Break down the area by storey",
+      "Break down net vs gross area by storey",
       "Show the area rollup per department",
       "Group the built-up area by building\n\n# Example\n```ts\nconst { groups } = await snaptrude.program.areas.list(\"storeys\")\nfor (const g of groups) console.log(g.name, g.builtUp, g.count)\n```"
     ],
@@ -4433,12 +6209,25 @@
     "summary": "List the spaces that make up one area group.",
     "examplePrompts": [
       "List the spaces on this storey with their areas",
+      "Which spaces are net and which are gross on this storey?",
       "What rooms are in the Bedrooms department bucket?",
       "Break the storey area down into individual spaces\n\n# Example\n```ts\nconst { members } = await snaptrude.program.areas.listMembers(\"storeys\", \"st_2\")\nfor (const m of members) console.log(m.label, m.carpet)\n```"
     ],
     "argsType": "PluginProgramAreaGroupBy",
     "resultType": "PluginProgramAreasListMembersResult"
   },
+  {
+    "path": "program.areas.refresh",
+    "namespace": "program.areas",
+    "summary": "Force the area breakdown to recompute, then return the fresh summary.",
+    "examplePrompts": [
+      "Recompute the area totals before I read them",
+      "Refresh the FAR numbers",
+      "Make sure the area breakdown is up to date\n\n# Example\n```ts\nconst s = await snaptrude.program.areas.refresh()\nconst { groups } = await snaptrude.program.areas.list(\"storeys\") // now fresh\nconsole.log(s.builtUp, groups.length)\n```"
+    ],
+    "argsType": null,
+    "resultType": "PluginProgramAreasRefreshResult"
+  },
   {
     "path": "program.areas.update",
     "namespace": "program.areas",
@@ -4448,7 +6237,7 @@
       "Override the site area to 5000",
       "Allow a 10 percent FAR deviation\n\n# Example\n```ts\nconst s = await snaptrude.program.areas.update({ targetFar: 2.5 })\nconsole.log(s.achievedFar, s.targetFar)\n```"
     ],
-    "argsType": "{ targetFar?: number; siteArea?: number; deviation?: number }",
+    "argsType": "{\n    targetFar?: number\n    siteArea?: number\n    deviation?: number\n  }",
     "resultType": "PluginProgramAreasUpdateResult"
   },
   {
@@ -4593,6 +6382,79 @@
     "argsType": "string",
     "resultType": "PluginProgramDepartmentsUpdateResult"
   },
+  {
+    "path": "program.layout.applySolution",
+    "namespace": "program.layout",
+    "summary": "Apply one of the pending arrange solutions.",
+    "examplePrompts": [
+      "Apply the second arrange solution",
+      "Pick layout solution 3 and commit it",
+      "Apply the arrange solution I chose\n\n# Example\n```ts\nawait snaptrude.program.layout.arrange({ autoCommit: false })\nlet job = await snaptrude.program.layout.getState()\nwhile (job?.status === \"running\") {\nawait new Promise((r) => setTimeout(r, 5000))\njob = await snaptrude.program.layout.getState()\n}\nif (job?.status === \"pendingReview\") {\nconsole.log(`${job.totalSolutions} candidate layouts`)\nawait snaptrude.program.layout.applySolution(1) // commit the second one\n}\n```"
+    ],
+    "argsType": "number",
+    "resultType": "PluginProgramLayoutApplyResult"
+  },
+  {
+    "path": "program.layout.arrange",
+    "namespace": "program.layout",
+    "summary": "Arrange the spaces inside the envelope using the computed adjacency data.",
+    "examplePrompts": [
+      "Arrange the rooms in the envelope",
+      "Lay out the departments inside the building envelope",
+      "Auto-arrange the program spaces",
+      "Arrange the rooms but let me pick the solution\n\n# Example\n```ts\nconst { success, error } = await snaptrude.program.layout.arrange()\nif (!success) throw new Error(error)\n// poll until the layout is applied\nlet job = await snaptrude.program.layout.getState()\nwhile (job?.status === \"running\") {\nawait new Promise((r) => setTimeout(r, 5000))\njob = await snaptrude.program.layout.getState()\n}\n```"
+    ],
+    "argsType": "PluginProgramLayoutRunArgs",
+    "resultType": "PluginProgramLayoutRunResult"
+  },
+  {
+    "path": "program.layout.cancel",
+    "namespace": "program.layout",
+    "summary": "Cancel the in-flight layout run.",
+    "examplePrompts": [
+      "Cancel the arrange",
+      "Stop the running layout job",
+      "Abort the pack in envelope\n\n# Example\n```ts\nawait snaptrude.program.layout.cancel()\n```"
+    ],
+    "argsType": null,
+    "resultType": "boolean"
+  },
+  {
+    "path": "program.layout.getState",
+    "namespace": "program.layout",
+    "summary": "Get the state of the layout run.",
+    "examplePrompts": [
+      "Is the arrange done?",
+      "Check the status of the layout run",
+      "Did the pack finish?\n\n# Example\n```ts\nconst job = await snaptrude.program.layout.getState()\nif (job?.status === \"active\") console.log(\"layout applied\")\n```"
+    ],
+    "argsType": null,
+    "resultType": "PluginProgramLayoutStateResult"
+  },
+  {
+    "path": "program.layout.pack",
+    "namespace": "program.layout",
+    "summary": "Pack the spaces into the envelope (a tighter fit than arrange).",
+    "examplePrompts": [
+      "Pack the rooms into the envelope",
+      "Fit the program spaces tightly into the building",
+      "Run pack-in-envelope on this storey\n\n# Example\n```ts\nconst { success } = await snaptrude.program.layout.pack({ envelopeId: \"be_...\" })\nlet job = await snaptrude.program.layout.getState()\nwhile (job?.status === \"running\") {\nawait new Promise((r) => setTimeout(r, 5000))\njob = await snaptrude.program.layout.getState()\n}\n```"
+    ],
+    "argsType": "PluginProgramLayoutRunArgs",
+    "resultType": "PluginProgramLayoutRunResult"
+  },
+  {
+    "path": "program.layout.stack",
+    "namespace": "program.layout",
+    "summary": "Stack the program across **every storey** of the building — the product's *Pack in envelope* / auto-stack.",
+    "examplePrompts": [
+      "Stack the program across all floors",
+      "Auto-stack the departments into the envelope on every storey",
+      "Pack the whole building's program into its envelope\n\n# Example\n```ts\nconst { success, skippedStoreys, error } = await snaptrude.program.layout.stack()\nif (!success) throw new Error(error)\nif (skippedStoreys.length)\nconsole.warn(`No envelope on storeys: ${skippedStoreys.join(\", \")}`)\n```"
+    ],
+    "argsType": null,
+    "resultType": "PluginProgramLayoutStackResult"
+  },
   {
     "path": "program.metrics.get",
     "namespace": "program.metrics",
@@ -4647,6 +6509,30 @@
     "argsType": null,
     "resultType": "PluginProgramSiteContextResult"
   },
+  {
+    "path": "program.site.getLocation",
+    "namespace": "program.site",
+    "summary": "Get the project's geographic location.",
+    "examplePrompts": [
+      "What's the project's latitude and longitude?",
+      "Where is this site located?",
+      "Get the geographic coordinates of the project\n\n# Example\n```ts\nconst location = await snaptrude.program.site.getLocation()\nif (location) console.log(location.latitude, location.longitude)\n```"
+    ],
+    "argsType": null,
+    "resultType": "PluginProgramSiteLocationResult"
+  },
+  {
+    "path": "program.site.getNorthAngle",
+    "namespace": "program.site",
+    "summary": "Get the site's true-north angle.",
+    "examplePrompts": [
+      "What's the north angle of the site?",
+      "How far is the model rotated from true north?",
+      "Get the project's true north direction\n\n# Example\n```ts\nconst northAngle = await snaptrude.program.site.getNorthAngle()\nif (northAngle !== null) console.log(`${northAngle}° from true north`)\n```"
+    ],
+    "argsType": null,
+    "resultType": "PluginProgramSiteNorthAngleResult"
+  },
   {
     "path": "program.site.listGeoPolygons",
     "namespace": "program.site",
@@ -4663,7 +6549,7 @@
   {
     "path": "program.site.listPolygons",
     "namespace": "program.site",
-    "summary": "List the site parcels with their footprints (in scene coordinates).",
+    "summary": "List the site parcels with their footprints (world XZ plan coordinates, Snaptrude units).",
     "examplePrompts": [
       "List every site parcel",
       "Show me each plot's footprint",
@@ -4731,7 +6617,7 @@
       "Re-pull all my data bindings",
       "Refresh every binding on the sheets\n\n# Example\n```ts\nawait snaptrude.program.spreadsheet.bindings.refresh({ name: \"takeoff\" })\n```"
     ],
-    "argsType": "{ name?: string }",
+    "argsType": "{\n    name?: string\n  }",
     "resultType": "PluginProgramSpreadsheetBindingsRefreshResult"
   },
   {
@@ -4750,12 +6636,13 @@
   {
     "path": "program.spreadsheet.export",
     "namespace": "program.spreadsheet",
-    "summary": "Export the whole report workbook to a file (xlsx, pdf, or csv).",
+    "summary": "Export the report workbook to a file (xlsx, pdf, or csv).",
     "examplePrompts": [
       "Export the report as an Excel file",
       "Download the whole workbook as a PDF",
       "Export the program workbook to xlsx",
-      "Save the report as a csv file\n\n# Example\n```ts\nconst file = await snaptrude.program.spreadsheet.export(\"xlsx\")\n// file.fileName, file.mimeType, file.dataBase64\n```"
+      "Save the report as a csv file",
+      "Export the Takeoff sheet as CSV\n\n# Example\n```ts\nconst file = await snaptrude.program.spreadsheet.export(\"xlsx\")\n// file.fileName, file.mimeType, file.dataBase64\n\n// CSV of a specific sheet:\nconst csv = await snaptrude.program.spreadsheet.export(\"csv\", { sheetName: \"Takeoff\" })\n```"
     ],
     "argsType": "PluginSpreadsheetExportFormat",
     "resultType": "PluginProgramSpreadsheetExportResult"
@@ -4770,9 +6657,23 @@
       "Get the last 10 audit log entries",
       "Read the program spreadsheet audit log\n\n# Example\n```ts\nconst { entries } = await snaptrude.program.spreadsheet.getAuditLog({ limit: 10 })\n```"
     ],
-    "argsType": "{ limit?: number }",
+    "argsType": "{\n    limit?: number\n  }",
     "resultType": "PluginProgramSpreadsheetGetAuditLogResult"
   },
+  {
+    "path": "program.spreadsheet.getMaterialTakeoff",
+    "namespace": "program.spreadsheet",
+    "summary": "Read the material take-off dataset (surface area per material, per element type).",
+    "examplePrompts": [
+      "Get the material take-off",
+      "How much of each material is used?",
+      "Read the surface area by material",
+      "Give me the material quantities before I render them",
+      "What's in the material take-off right now?\n\n# Example\n```ts\nconst mto = await snaptrude.program.spreadsheet.getMaterialTakeoff()\nfor (const row of mto.rows) {\nconsole.log(row.objectType, row.family, row.material, row.quantity, row.unit)\n}\n```"
+    ],
+    "argsType": null,
+    "resultType": "PluginProgramSpreadsheetGetMaterialTakeoffResult"
+  },
   {
     "path": "program.spreadsheet.getProgram",
     "namespace": "program.spreadsheet",
@@ -4871,7 +6772,7 @@
       "Recompute all the formulas",
       "Recalculate the Summary sheet\n\n# Example\n```ts\nawait snaptrude.program.spreadsheet.recalculate()\n```"
     ],
-    "argsType": "{ sheetName?: string }",
+    "argsType": "{\n    sheetName?: string\n  }",
     "resultType": "PluginProgramSpreadsheetRecalculateResult"
   },
   {
@@ -4898,7 +6799,7 @@
       "Generate the program schedule sheet titled Program",
       "Render the program filtered to the residential departments\n\n# Example\n```ts\nawait snaptrude.program.spreadsheet.renderProgram({ sheetName: \"Program\" })\n```"
     ],
-    "argsType": "{ sheetName?: string; title?: string; filter?: string }",
+    "argsType": "{\n    sheetName?: string\n    title?: string\n    filter?: string\n  }",
     "resultType": "PluginProgramSpreadsheetRenderResult"
   },
   {
@@ -4911,7 +6812,7 @@
       "Generate the takeoff schedule sheet titled Takeoff",
       "Render the material takeoff filtered to the walls\n\n# Example\n```ts\nawait snaptrude.program.spreadsheet.renderTakeoff({ sheetName: \"Takeoff\" })\n```"
     ],
-    "argsType": "{ sheetName?: string; title?: string; filter?: string }",
+    "argsType": "{\n    sheetName?: string\n    title?: string\n    filter?: string\n  }",
     "resultType": "PluginProgramSpreadsheetRenderResult"
   },
   {