@snaptrude/plugin-core 0.7.1 → 0.9.0

package/api-manifest.json

@@ -1,4 +1,380 @@
 [
+  {
+    "path": "analysis.daylight.compute",
+    "namespace": "analysis.daylight",
+    "summary": "Compute annual daylight metrics for the model's spaces.",
+    "examplePrompts": [
+      "Run an LM-83 ASE daylight analysis on all my spaces",
+      "Which rooms fail annual sunlight exposure?",
+      "Compute ASE with a 0.6m sensor grid at desk height",
+      "Run an LM-83 sDA analysis with blinds operated",
+      "Which spaces meet sDA300/50%?",
+      "Compute sDA with 70% reflective ceilings and Tvis 0.6 glazing\n\n# Example\n```ts\nlet res = await snaptrude.analysis.daylight.compute({\nstandard: \"IES-LM-83-23\",\nmetrics: [\"sDA\", \"ASE\"],\ngrid: { spacingM: 0.6, workplaneHeightM: 0.76, boundaryOffsetM: 0.5 },\noptics: { materials: { \"Glass - Clear\": { transmittance: 0.6 } } },\n})\nconst runId = res.runId\nwhile (res.status === \"running\" && runId) {\nawait new Promise((r) => setTimeout(r, 5000))\nres = await snaptrude.analysis.daylight.poll({ runId })\n}\nconst failing = res.aggregates.filter(\n(a) => a.scope === \"space\" && (a.sdaPercent ?? 0) < 55,\n)\n```"
+    ],
+    "argsType": "PluginDaylightComputeArgs",
+    "resultType": "PluginDaylightResults"
+  },
+  {
+    "path": "analysis.daylight.poll",
+    "namespace": "analysis.daylight",
+    "summary": "Poll an asynchronous daylight run started by {@linkcode PluginAnalysisDaylightApi.compute}.",
+    "examplePrompts": [
+      "Check whether my sDA run has finished",
+      "Get the results of the daylight run"
+    ],
+    "argsType": "PluginDaylightPollArgs",
+    "resultType": "PluginDaylightResults"
+  },
+  {
+    "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.overlays.hide",
+    "namespace": "analysis.heatmaps.overlays",
+    "summary": "Hide an overlay without removing it.",
+    "examplePrompts": [
+      "Hide the wind overlay but keep it around",
+      "Temporarily hide my heatmap",
+      "Turn off the occupancy colours without deleting them\n\n# Example\n```ts\nawait snaptrude.analysis.heatmaps.overlays.hide(\"wind\")\n```"
+    ],
+    "argsType": "string",
+    "resultType": "boolean"
+  },
+  {
+    "path": "analysis.heatmaps.overlays.list",
+    "namespace": "analysis.heatmaps.overlays",
+    "summary": "List the registered heatmap overlays.",
+    "examplePrompts": [
+      "Which heatmap overlays do I have?",
+      "List my rendered analysis overlays",
+      "Check which heatmap is currently visible\n\n# Example\n```ts\nconst { overlays } = await snaptrude.analysis.heatmaps.overlays.list()\nconst visible = overlays.find((o) => o.visible)\n```"
+    ],
+    "argsType": null,
+    "resultType": "PluginAnalysisHeatmapOverlaysListResult"
+  },
+  {
+    "path": "analysis.heatmaps.overlays.remove",
+    "namespace": "analysis.heatmaps.overlays",
+    "summary": "Remove an overlay — dispose its meshes and forget it.",
+    "examplePrompts": [
+      "Delete the wind overlay",
+      "Remove my occupancy heatmap for good",
+      "Free up an overlay slot\n\n# Example\n```ts\nawait snaptrude.analysis.heatmaps.overlays.remove(\"wind\")\n```"
+    ],
+    "argsType": "string",
+    "resultType": "boolean"
+  },
+  {
+    "path": "analysis.heatmaps.overlays.removeAll",
+    "namespace": "analysis.heatmaps.overlays",
+    "summary": "Remove every registered overlay and close the legend.",
+    "examplePrompts": [
+      "Clear all my heatmap overlays",
+      "Remove every analysis overlay from the scene",
+      "Start over with a clean set of overlays\n\n# Example\n```ts\nconst removed = await snaptrude.analysis.heatmaps.overlays.removeAll()\n```"
+    ],
+    "argsType": null,
+    "resultType": "number"
+  },
+  {
+    "path": "analysis.heatmaps.overlays.show",
+    "namespace": "analysis.heatmaps.overlays",
+    "summary": "Make a registered overlay the visible one.",
+    "examplePrompts": [
+      "Switch back to my wind heatmap",
+      "Show the occupancy overlay",
+      "Flip between my two analysis overlays\n\n# Example\n```ts\nawait snaptrude.analysis.heatmaps.overlays.show(\"wind\")\n```"
+    ],
+    "argsType": "string",
+    "resultType": "boolean"
+  },
+  {
+    "path": "analysis.heatmaps.renderField",
+    "namespace": "analysis.heatmaps",
+    "summary": "Render a heatmap from **arbitrary cell geometry** — planar polygons or pre-tessellated meshes, one scalar value each.",
+    "examplePrompts": [
+      "Overlay my FEA stress results on their solver mesh",
+      "Color these Voronoi regions by footfall",
+      "Paint each façade panel polygon by its PV yield",
+      "Render pass/fail daylight compliance per zone polygon\n\n# Example\n```ts\n// Two triangular cells at ground level, coloured pass/fail at 300 lux.\nawait snaptrude.analysis.heatmaps.renderField(\n[\n{ polygon: [{ x: 0, y: 0, z: 0 }, { x: 4, y: 0, z: 0 }, { x: 0, y: 0, z: 4 }], value: 420 },\n{ polygon: [{ x: 4, y: 0, z: 4 }, { x: 0, y: 0, z: 4 }, { x: 4, y: 0, z: 0 }], value: 180 },\n],\n{ title: \"Daylight\", unit: \"lux\", scale: { type: \"threshold\", threshold: 300 } },\n)\n```"
+    ],
+    "argsType": "PluginAnalysisHeatmapFieldCell[]",
+    "resultType": "PluginAnalysisHeatmapsRenderResult"
+  },
+  {
+    "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.renderSurfaceGrid",
+    "namespace": "analysis.heatmaps",
+    "summary": "Render a grid heatmap on an **arbitrarily oriented plane** — a façade, a section cut, any flat surface.",
+    "examplePrompts": [
+      "Paint the solar irradiance results on the south façade",
+      "Show my daylight values as a heatmap on this wall",
+      "Render panel-level PV yield on the building face",
+      "Overlay wind pressure on the tower's west elevation\n\n# Example\n```ts\n// Samples lie on a wall plane facing +X; colour each 1-unit cell by irradiance.\nawait snaptrude.analysis.heatmaps.renderSurfaceGrid(\nsamples.map((s) => ({ position: { x: wallX, y: s.y, z: s.z }, value: s.irradiance })),\n1,\n{ x: 1, y: 0, z: 0 }, // façade normal\n{ title: \"Irradiance\", unit: \"kWh/m²\", colors: [\"#0000ff\", \"#ffff00\", \"#ff0000\"] },\n)\n```"
+    ],
+    "argsType": "PluginAnalysisHeatmapGridCell[]",
+    "resultType": "PluginAnalysisHeatmapsRenderResult"
+  },
+  {
+    "path": "analysis.heatmaps.reset",
+    "namespace": "analysis.heatmaps",
+    "summary": "Clear every plugin heatmap overlay 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.solar.sampleGrid",
+    "namespace": "analysis.solar",
+    "summary": "Sample solar exposure at a set of points.",
+    "examplePrompts": [
+      "What's the irradiance at these facade points at noon on June 21?",
+      "How shaded are these balcony points across the summer?",
+      "Sample direct sun visibility at these roof points right now\n\n# Example\n```ts\nconst grid = await snaptrude.analysis.solar.sampleGrid({\npoints: [\n{ id: \"a\", position: [0, 3, 0] },\n{ id: \"b\", position: [5, 3, 0], normal: [0, 0, 1] },\n],\ndateTime: \"2026-06-21T12:00:00+05:30\",\n})\nfor (const r of grid.results) {\nconsole.log(r.id, r.directSunVisible, r.totalIrradiance, grid.units)\n}\n```"
+    ],
+    "argsType": "PluginSolarSampleGridArgs",
+    "resultType": "PluginSolarSampleGridResult"
+  },
+  {
+    "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": "analysis.weather.getSeries",
+    "namespace": "analysis.weather",
+    "summary": "Get the hourly weather series for a date range, paged.",
+    "examplePrompts": [
+      "Get the weather series for June at my site",
+      "Pull the hourly temperature and irradiance for this location",
+      "What EPW weather file is my project using?\n\n# Example\n```ts\nlet cursor: string | undefined = undefined\nconst rows = []\ndo {\nconst page = await snaptrude.analysis.weather.getSeries({\nstartDate: \"2026-06-01\",\nendDate: \"2026-06-30\",\ncursor,\n})\nrows.push(...page.rows)\ncursor = page.nextCursor ?? undefined\n} while (cursor)\n```"
+    ],
+    "argsType": "PluginWeatherGetSeriesArgs",
+    "resultType": "PluginWeatherSeriesResult"
+  },
   {
     "path": "core.buildings.copy",
     "namespace": "core.buildings",
@@ -107,6 +483,97 @@
     "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.camera.zoomExtents",
+    "namespace": "core.camera",
+    "summary": "Zoom (fit) the camera to all geometry in the scene — the \"zoom extents\" action. View-state only — not undoable. Canonical home of the zoom-extents read (the deprecated `core.zoom.extents`).",
+    "examplePrompts": [
+      "Zoom out so I can see the whole model",
+      "Fit everything in the view",
+      "Frame the entire building in the viewport",
+      "Do a zoom extents on the canvas\n\n# Example\n```ts\nawait snaptrude.core.camera.zoomExtents()\n```"
+    ],
+    "argsType": null,
+    "resultType": "boolean"
+  },
+  {
+    "path": "core.camera.zoomSelection",
+    "namespace": "core.camera",
+    "summary": "Zoom (fit) the camera to the current selection. View-state only — not undoable. Canonical home of the zoom-to-selection read (the deprecated `core.zoom.selection`).",
+    "examplePrompts": [
+      "Zoom in on what I have selected",
+      "Frame the selected walls in the view",
+      "Focus the camera on my current selection",
+      "Fit the view to the selected room\n\n# Example\n```ts\nawait snaptrude.core.camera.zoomSelection()\n```"
+    ],
+    "argsType": null,
+    "resultType": "boolean"
+  },
   {
     "path": "core.comment.create",
     "namespace": "core.comment",
@@ -133,6 +600,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 +652,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",
@@ -223,63 +716,147 @@
     "resultType": "ArcHandle"
   },
   {
-    "path": "core.geom.create.circle",
+    "path": "core.geom.create.brepFromExtrusion",
     "namespace": "core.geom.create",
-    "summary": "Create a circle from a centre point, an axis (plane normal), and a radius. Host API call — returns a handle. A circle is a closed curve; read it back via `snaptrude.core.geom.query.circle.*`.",
+    "summary": "Create a closed solid **B-rep** by extruding a contour along a direction. Host API call — returns a {@linkcode BrepHandle}. The direction is normalised by the host, so `amount` is the extrusion distance in raw Babylon units (negative extrudes the opposite way). The contour is copied — the input handle is never mutated. Holes and arc/circle profiles extrude natively (a circle profile yields a cylinder).",
     "examplePrompts": [
-      "Make a circle of radius 2 at this point",
-      "Draw a circular outline 5m across"
+      "Extrude this profile 3 metres up",
+      "Make a solid by extruding this outline",
+      "Create a cylinder from a circle profile\n\n# Example\n```ts\nconst rect = await snaptrude.core.geom.create.profileRect(4, 3)\nconst contour = await snaptrude.core.geom.create.contourFromProfile(rect)\nconst brep = await snaptrude.core.geom.create.brepFromExtrusion(contour, { x: 0, y: 1, z: 0 }, 3)\nconst faceCount = await snaptrude.core.geom.query.brep.getFaceCount(brep) // 6\n```"
     ],
-    "argsType": "Vec3Handle",
-    "resultType": "CircleHandle"
+    "argsType": "ContourHandle",
+    "resultType": "BrepHandle"
   },
   {
-    "path": "core.geom.create.contourFromProfile",
+    "path": "core.geom.create.brepFromFaces",
     "namespace": "core.geom.create",
-    "summary": "Create a contour (an outer profile loop, no holes). Host API call — returns a handle.",
-    "examplePrompts": [],
-    "argsType": "ProfileHandle",
-    "resultType": "ContourHandle"
+    "summary": "Create a closed solid **B-rep** from explicit face loops. Host API call — returns a {@linkcode BrepHandle}. Faces are plain arrays of `{x, y, z}` point components, NOT point handles (bulk-data precedent: `design.query.geometry.getTriangulatedMeshes`), in raw Babylon units.",
+    "examplePrompts": [
+      "Create a brep from faces",
+      "Build a custom solid from a set of faces",
+      "Make a pyramid from triangular faces\n\n# Example\n```ts\n// A pyramid: square base + 4 triangular sides\nconst apex = { x: 0, y: 4, z: 0 }\nconst a = { x: -2, y: 0, z: -2 }\nconst b = { x: 2, y: 0, z: -2 }\nconst c = { x: 2, y: 0, z: 2 }\nconst d = { x: -2, y: 0, z: 2 }\nconst brep = await snaptrude.core.geom.create.brepFromFaces([\n[a, d, c, b], // base\n[a, b, apex],\n[b, c, apex],\n[c, d, apex],\n[d, a, apex],\n])\nconst faceCount = await snaptrude.core.geom.query.brep.getFaceCount(brep) // 5\n```"
+    ],
+    "argsType": "Vec3Components[][]",
+    "resultType": "BrepHandle"
   },
   {
-    "path": "core.geom.create.contourFromProfiles",
+    "path": "core.geom.create.brepFromIntersection",
     "namespace": "core.geom.create",
-    "summary": "Create a contour from an outer profile plus zero or more inner profiles (holes). Host API call — returns a handle.",
+    "summary": "Create a closed solid **B-rep** as the boolean **intersection** of two breps (`a ∩ b` — the shared volume only). Host API call — returns a new {@linkcode BrepHandle}. Inputs are read-only and may be authored or scene-derived breps (see {@linkcode PluginGeomCreateApi.brepFromUnion}); coordinates are combined as-is.",
     "examplePrompts": [
-      "Make a shape with a hole in the middle",
-      "Cut a courtyard opening out of this floor outline"
+      "Keep only the overlap of these two solids",
+      "Intersect these two masses",
+      "Clip the tower to the zoning envelope\n\n# Example\n```ts\nconst overlap = await snaptrude.core.geom.create.brepFromIntersection(towerBrep, envelopeBrep)\n```"
     ],
-    "argsType": "ProfileHandle",
-    "resultType": "ContourHandle"
+    "argsType": "BrepHandle",
+    "resultType": "BrepHandle"
   },
   {
-    "path": "core.geom.create.line",
+    "path": "core.geom.create.brepFromLoft",
     "namespace": "core.geom.create",
-    "summary": "Create a straight line segment between two point handles. Host API call — returns a handle.",
+    "summary": "Create a closed solid **B-rep** by lofting between a bottom and a top contour. Host API call — returns a {@linkcode BrepHandle}. Both contours must have the same number of edges (and matching hole counts); side faces connect corresponding edges by authored index. Corresponding edges must stay coplanar — a twisted loft would produce non-planar side faces and is rejected. The contours are copied — the input handles are never mutated.",
     "examplePrompts": [
-      "Draw a line from point A to point B",
-      "Draw a straight edge between these two points"
+      "Make a tapered tower from these two outlines",
+      "Loft between a large base and a smaller top",
+      "Create a frustum from two squares\n\n# Example\n```ts\n// A square frustum: 4m base lofted to a 2m top, 3m up\nconst base = await snaptrude.core.geom.create.profileRect(4, 4)\nconst top = await snaptrude.core.geom.create.profileRect(2, 2, await snaptrude.core.math.vec3.new(0, 3, 0))\nconst brep = await snaptrude.core.geom.create.brepFromLoft(\nawait snaptrude.core.geom.create.contourFromProfile(base),\nawait snaptrude.core.geom.create.contourFromProfile(top),\n)\nconst faceCount = await snaptrude.core.geom.query.brep.getFaceCount(brep) // 6\n```"
     ],
-    "argsType": "Vec3Handle",
-    "resultType": "LineHandle"
+    "argsType": "ContourHandle",
+    "resultType": "BrepHandle"
   },
   {
-    "path": "core.geom.create.profileFromCurves",
+    "path": "core.geom.create.brepFromMesh",
     "namespace": "core.geom.create",
-    "summary": "Create a profile from an ordered list of curve handles forming a closed loop. Host API call — returns a handle.",
+    "summary": "Create a closed solid **B-rep** from indexed mesh data: a vertex position array plus face loops of indices into it. Host API call — returns a {@linkcode BrepHandle}. The indexed form of {@linkcode PluginGeomCreateApi.brepFromFaces} — same validation (planar faces, closed manifold solid, every edge shared by exactly two faces) after the indices are expanded to point loops.",
     "examplePrompts": [
-      "Join these lines and arcs into one closed shape"
+      "Create a brep from mesh vertices and indices",
+      "Turn this indexed mesh into a solid",
+      "Build a solid from vertex positions and face indices\n\n# Example\n```ts\n// A tetrahedron from 4 vertices and 4 triangular faces\nconst positions = [\n{ x: 0, y: 0, z: 0 },\n{ x: 4, y: 0, z: 0 },\n{ x: 2, y: 0, z: 4 },\n{ x: 2, y: 3, z: 1.5 },\n]\nconst brep = await snaptrude.core.geom.create.brepFromMesh(positions, [\n[0, 2, 1], // base\n[0, 1, 3],\n[1, 2, 3],\n[2, 0, 3],\n])\nconst vertexCount = await snaptrude.core.geom.query.brep.getVertexCount(brep) // 4\n```"
     ],
-    "argsType": "CurveHandle[]",
-    "resultType": "ProfileHandle"
+    "argsType": "Vec3Components[]",
+    "resultType": "BrepHandle"
   },
   {
-    "path": "core.geom.create.profileFromLinePoints",
+    "path": "core.geom.create.brepFromSubtraction",
     "namespace": "core.geom.create",
-    "summary": "Create a closed profile from an ordered list of point handles connected by line segments (last auto-connected to first). Host API call — returns a handle.",
+    "summary": "Create a closed solid **B-rep** as the boolean **subtraction** of two breps: **`a` minus `b`** — `b` is cut away from `a`. Host API call — returns a new {@linkcode BrepHandle}. Argument order matters: `brepFromSubtraction(a, b)` removes `b`'s volume from `a`. Inputs are read-only and may be authored or scene-derived breps (see {@linkcode PluginGeomCreateApi.brepFromUnion}); coordinates are combined as-is.",
     "examplePrompts": [
-      "Draw a closed polygon through these corner points",
-      "Create an L-shaped outline from a list of points"
+      "Subtract the courtyard from the building mass",
+      "Cut this solid out of that one",
+      "Punch a hole through the slab with this box\n\n# Example\n```ts\n// buildingBrep minus courtyardBrep — order matters\nconst carved = await snaptrude.core.geom.create.brepFromSubtraction(buildingBrep, courtyardBrep)\n```"
+    ],
+    "argsType": "BrepHandle",
+    "resultType": "BrepHandle"
+  },
+  {
+    "path": "core.geom.create.brepFromUnion",
+    "namespace": "core.geom.create",
+    "summary": "Create a closed solid **B-rep** as the boolean **union** of two breps (`a ∪ b`). Host API call — returns a new {@linkcode BrepHandle}. Inputs are read-only and may be authored breps (any `core.geom.create` brep constructor) or scene-derived breps from `design.query.geometry.getBrep`; coordinates are combined as-is, so both inputs must share a frame. The result must be a single solid — disjoint inputs are rejected.",
+    "examplePrompts": [
+      "Union these two solids",
+      "Merge these breps into one mass",
+      "Combine the tower and the podium into a single solid\n\n# Example\n```ts\nconst a = await snaptrude.core.geom.create.brepFromExtrusion(baseContour, { x: 0, y: 1, z: 0 }, 3)\nconst b = await snaptrude.core.geom.create.brepFromExtrusion(overlappingContour, { x: 0, y: 1, z: 0 }, 5)\nconst merged = await snaptrude.core.geom.create.brepFromUnion(a, b)\n```"
+    ],
+    "argsType": "BrepHandle",
+    "resultType": "BrepHandle"
+  },
+  {
+    "path": "core.geom.create.circle",
+    "namespace": "core.geom.create",
+    "summary": "Create a circle from a centre point, an axis (plane normal), and a radius. Host API call — returns a handle. A circle is a closed curve; read it back via `snaptrude.core.geom.query.circle.*`.",
+    "examplePrompts": [
+      "Make a circle of radius 2 at this point",
+      "Draw a circular outline 5m across"
+    ],
+    "argsType": "Vec3Handle",
+    "resultType": "CircleHandle"
+  },
+  {
+    "path": "core.geom.create.contourFromProfile",
+    "namespace": "core.geom.create",
+    "summary": "Create a contour (an outer profile loop, no holes). Host API call — returns a handle.",
+    "examplePrompts": [],
+    "argsType": "ProfileHandle",
+    "resultType": "ContourHandle"
+  },
+  {
+    "path": "core.geom.create.contourFromProfiles",
+    "namespace": "core.geom.create",
+    "summary": "Create a contour from an outer profile plus zero or more inner profiles (holes). Host API call — returns a handle.",
+    "examplePrompts": [
+      "Make a shape with a hole in the middle",
+      "Cut a courtyard opening out of this floor outline"
+    ],
+    "argsType": "ProfileHandle",
+    "resultType": "ContourHandle"
+  },
+  {
+    "path": "core.geom.create.line",
+    "namespace": "core.geom.create",
+    "summary": "Create a straight line segment between two point handles. Host API call — returns a handle.",
+    "examplePrompts": [
+      "Draw a line from point A to point B",
+      "Draw a straight edge between these two points"
+    ],
+    "argsType": "Vec3Handle",
+    "resultType": "LineHandle"
+  },
+  {
+    "path": "core.geom.create.profileFromCurves",
+    "namespace": "core.geom.create",
+    "summary": "Create a profile from an ordered list of curve handles forming a closed loop. Host API call — returns a handle.",
+    "examplePrompts": [
+      "Join these lines and arcs into one closed shape"
+    ],
+    "argsType": "CurveHandle[]",
+    "resultType": "ProfileHandle"
+  },
+  {
+    "path": "core.geom.create.profileFromLinePoints",
+    "namespace": "core.geom.create",
+    "summary": "Create a closed profile from an ordered list of point handles connected by line segments (last auto-connected to first). Host API call — returns a handle.",
+    "examplePrompts": [
+      "Draw a closed polygon through these corner points",
+      "Create an L-shaped outline from a list of points"
     ],
     "argsType": "Vec3Handle[]",
     "resultType": "ProfileHandle"
@@ -301,7 +878,8 @@
     "summary": "Free a transient contour resource handle — releases its registry entry and reclaims its share of the plugin's resource quota. Handle-lifecycle only; does NOT tear down engine-side geometry, nor the contour's child profile handles.",
     "examplePrompts": [],
     "argsType": "ContourHandle",
-    "resultType": "void"
+    "resultType": "void",
+    "deprecated": "core.handles.release"
   },
   {
     "path": "core.geom.delete.profile",
@@ -309,7 +887,8 @@
     "summary": "Free a transient profile resource handle — releases its registry entry and reclaims its share of the plugin's resource quota. This is a handle-lifecycle operation only and does NOT tear down any engine-side geometry.",
     "examplePrompts": [],
     "argsType": "ProfileHandle",
-    "resultType": "void"
+    "resultType": "void",
+    "deprecated": "core.handles.release"
   },
   {
     "path": "core.geom.query.arc.getAxis",
@@ -1687,128 +2266,619 @@
     "resultType": "PluginCoreGroupsCreateResult"
   },
   {
-    "path": "core.groups.delete",
-    "namespace": "core.groups",
-    "summary": "Delete (dissolve) a group.",
+    "path": "core.groups.delete",
+    "namespace": "core.groups",
+    "summary": "Delete (dissolve) a group.",
+    "examplePrompts": [
+      "Ungroup group-12",
+      "Dissolve this group but keep its contents",
+      "Delete the group without deleting its members\n\n# Example\n```ts\nawait snaptrude.core.groups.delete(\"group-12\")\n```"
+    ],
+    "argsType": "string",
+    "resultType": "PluginCoreGroupsDeleteResult"
+  },
+  {
+    "path": "core.groups.get",
+    "namespace": "core.groups",
+    "summary": "Get a single group by id.",
+    "examplePrompts": [
+      "Get the group with id group-12",
+      "Look up a single group by its id",
+      "Is group-3 locked and how many members does it have?\n\n# Example\n```ts\nconst group = await snaptrude.core.groups.get(\"group-12\")\nif (group) console.log(group.name, group.memberCount)\n```"
+    ],
+    "argsType": "string",
+    "resultType": "PluginCoreGroupsGetResult"
+  },
+  {
+    "path": "core.groups.getBounds",
+    "namespace": "core.groups",
+    "summary": "Get the axis-aligned bounds of a group.",
+    "examplePrompts": [
+      "How big is this group?",
+      "Get the bounding box of group-12",
+      "Where is the center of this group?\n\n# Example\n```ts\nconst bounds = await snaptrude.core.groups.getBounds(\"group-12\")\nif (bounds) console.log(bounds.center.x, bounds.center.y, bounds.center.z)\n```"
+    ],
+    "argsType": "string",
+    "resultType": "PluginCoreGroupsGetBoundsResult"
+  },
+  {
+    "path": "core.groups.getForComponent",
+    "namespace": "core.groups",
+    "summary": "Get the group a component belongs to.",
+    "examplePrompts": [
+      "Which group is this wall in?",
+      "Find the group that contains component cmp_42",
+      "Is this element grouped, and if so which group?\n\n# Example\n```ts\nconst group = await snaptrude.core.groups.getForComponent(\"cmp_42\")\nconsole.log(group ? group.name : \"ungrouped\")\n```"
+    ],
+    "argsType": "ComponentHandle",
+    "resultType": "PluginCoreGroupsGetForComponentResult"
+  },
+  {
+    "path": "core.groups.isLocked",
+    "namespace": "core.groups",
+    "summary": "Report whether a group is locked.",
+    "examplePrompts": [
+      "Is group-12 locked?",
+      "Check whether this group is locked before editing it",
+      "Tell me if the group is locked\n\n# Example\n```ts\nif (await snaptrude.core.groups.isLocked(\"group-12\")) {\nconsole.log(\"locked — unlock it first\")\n}\n```"
+    ],
+    "argsType": "string",
+    "resultType": "PluginCoreGroupsIsLockedResult"
+  },
+  {
+    "path": "core.groups.list",
+    "namespace": "core.groups",
+    "summary": "List every group in the active project.",
+    "examplePrompts": [
+      "List all the groups in my project",
+      "What groups do I have and how many things are in each?",
+      "Show every group with its lock state",
+      "How many groups are in this model?\n\n# Example\n```ts\nconst { groups } = await snaptrude.core.groups.list()\nfor (const g of groups) console.log(g.name, g.memberCount, g.isLocked)\n```"
+    ],
+    "argsType": null,
+    "resultType": "PluginCoreGroupsListResult"
+  },
+  {
+    "path": "core.groups.listMembers",
+    "namespace": "core.groups",
+    "summary": "List the direct members of a group.",
+    "examplePrompts": [
+      "What's inside group-12?",
+      "List the members of this group",
+      "Show the components and subgroups in group-3\n\n# Example\n```ts\nconst { members } = await snaptrude.core.groups.listMembers(\"group-12\")\nfor (const m of members) console.log(m.type, m.id)\n```"
+    ],
+    "argsType": "string",
+    "resultType": "PluginCoreGroupsListMembersResult"
+  },
+  {
+    "path": "core.groups.update",
+    "namespace": "core.groups",
+    "summary": "Update a group's name and/or membership.",
+    "examplePrompts": [
+      "Rename group-12 to Kitchen",
+      "Add these two walls to the group",
+      "Remove cmp_7 from group-3\n\n# Example\n```ts\nconst group = await snaptrude.core.groups.update(\"group-12\", {\nname: \"Kitchen\",\naddComponentIds: [\"cmp_9\"],\n})\n```"
+    ],
+    "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",
+    "summary": "Step forward over previously undone entries. Symmetric with {@linkcode PluginHistoryApi.undo}.",
+    "examplePrompts": [
+      "Redo the change I just undid",
+      "Redo the last two undone actions",
+      "Bring back the edit I reverted",
+      "Step forward again in the history\n\n# Example\n```ts\nawait snaptrude.core.history.redo()\nawait snaptrude.core.history.redo(2)\n```"
+    ],
+    "argsType": "number",
+    "resultType": "PluginHistoryStepResult"
+  },
+  {
+    "path": "core.history.undo",
+    "namespace": "core.history",
+    "summary": "Step back over committed history entries.",
+    "examplePrompts": [
+      "Undo my last change",
+      "Undo the last 3 actions",
+      "Revert what I just did to the model",
+      "Step back one change",
+      "Take back that last edit\n\n# Example\n```ts\nawait snaptrude.core.history.undo()   // one step\nawait snaptrude.core.history.undo(3)  // up to three steps\n```"
+    ],
+    "argsType": "number",
+    "resultType": "PluginHistoryStepResult"
+  },
+  {
+    "path": "core.io.export.model",
+    "namespace": "core.io.export",
+    "summary": "Export the model to a 3D file and return its bytes as base64.",
+    "examplePrompts": [
+      "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": "ExportModelFormat",
+    "resultType": "ExportedFile"
+  },
+  {
+    "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": [
+      "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": "ImportJobHandle"
+  },
+  {
+    "path": "core.io.import.epw",
+    "namespace": "core.io.import",
+    "summary": "Import an **EPW weather file** into the project's weather catalog.",
+    "examplePrompts": [
+      "Import this EPW weather file for the site",
+      "Upload a custom weather file for the daylight analysis",
+      "Use this .epw as the project's weather source\n\n# Example\n```ts\nconst { weatherFileId, label } = await snaptrude.core.io.import.epw(\n\"https://example.com/Chicago-OHare.epw\",\n)\nconsole.log(`Weather set to ${label} (${weatherFileId})`)\n```"
+    ],
+    "argsType": "string",
+    "resultType": "PluginImportEpwResult"
+  },
+  {
+    "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": [
+      "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": "UnderlayHandle"
+  },
+  {
+    "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": [
+      "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": "ComponentHandle"
+  },
+  {
+    "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": [
+      "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": "UnderlayHandle"
+  },
+  {
+    "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.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.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.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.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.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": [
-      "Ungroup group-12",
-      "Dissolve this group but keep its contents",
-      "Delete the group without deleting its members\n\n# Example\n```ts\nawait snaptrude.core.groups.delete(\"group-12\")\n```"
+      "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": "string",
-    "resultType": "PluginCoreGroupsDeleteResult"
+    "argsType": "number",
+    "resultType": "void"
   },
   {
-    "path": "core.groups.get",
-    "namespace": "core.groups",
-    "summary": "Get a single group by id.",
+    "path": "core.io.terrain.setOpacity",
+    "namespace": "core.io.terrain",
+    "summary": "Set the terrain opacity (`0` transparent .. `1` opaque). Undoable.",
     "examplePrompts": [
-      "Get the group with id group-12",
-      "Look up a single group by its id",
-      "Is group-3 locked and how many members does it have?\n\n# Example\n```ts\nconst group = await snaptrude.core.groups.get(\"group-12\")\nif (group) console.log(group.name, group.memberCount)\n```"
+      "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": "string",
-    "resultType": "PluginCoreGroupsGetResult"
+    "argsType": "number",
+    "resultType": "void"
   },
   {
-    "path": "core.groups.getBounds",
-    "namespace": "core.groups",
-    "summary": "Get the axis-aligned bounds of a group.",
+    "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": [
-      "How big is this group?",
-      "Get the bounding box of group-12",
-      "Where is the center of this group?\n\n# Example\n```ts\nconst bounds = await snaptrude.core.groups.getBounds(\"group-12\")\nif (bounds) console.log(bounds.center.x, bounds.center.y, bounds.center.z)\n```"
+      "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": "string",
-    "resultType": "PluginCoreGroupsGetBoundsResult"
+    "argsType": "UnderlayHandle",
+    "resultType": "void"
   },
   {
-    "path": "core.groups.getForComponent",
-    "namespace": "core.groups",
-    "summary": "Get the group a component belongs to.",
+    "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": [
-      "Which group is this wall in?",
-      "Find the group that contains component cmp_42",
-      "Is this element grouped, and if so which group?\n\n# Example\n```ts\nconst group = await snaptrude.core.groups.getForComponent(\"cmp_42\")\nconsole.log(group ? group.name : \"ungrouped\")\n```"
+      "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": "ComponentHandle",
-    "resultType": "PluginCoreGroupsGetForComponentResult"
+    "argsType": "UnderlayHandle",
+    "resultType": "BBoxComponents | null"
   },
   {
-    "path": "core.groups.isLocked",
-    "namespace": "core.groups",
-    "summary": "Report whether a group is locked.",
+    "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": [
-      "Is group-12 locked?",
-      "Check whether this group is locked before editing it",
-      "Tell me if the group is locked\n\n# Example\n```ts\nif (await snaptrude.core.groups.isLocked(\"group-12\")) {\nconsole.log(\"locked — unlock it first\")\n}\n```"
+      "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": "string",
-    "resultType": "PluginCoreGroupsIsLockedResult"
+    "argsType": "UnderlayHandle",
+    "resultType": "number | null"
   },
   {
-    "path": "core.groups.list",
-    "namespace": "core.groups",
-    "summary": "List every group in the active project.",
+    "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": [
-      "List all the groups in my project",
-      "What groups do I have and how many things are in each?",
-      "Show every group with its lock state",
-      "How many groups are in this model?\n\n# Example\n```ts\nconst { groups } = await snaptrude.core.groups.list()\nfor (const g of groups) console.log(g.name, g.memberCount, g.isLocked)\n```"
+      "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": null,
-    "resultType": "PluginCoreGroupsListResult"
+    "argsType": "UnderlayHandle",
+    "resultType": "{ scaleFactor: number; initialScaleFactor: number } | null"
   },
   {
-    "path": "core.groups.listMembers",
-    "namespace": "core.groups",
-    "summary": "List the direct members of a group.",
+    "path": "core.io.underlay.list",
+    "namespace": "core.io.underlay",
+    "summary": "List the underlays in the scene, optionally limited to one storey.",
     "examplePrompts": [
-      "What's inside group-12?",
-      "List the members of this group",
-      "Show the components and subgroups in group-3\n\n# Example\n```ts\nconst { members } = await snaptrude.core.groups.listMembers(\"group-12\")\nfor (const m of members) console.log(m.type, m.id)\n```"
+      "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": "string",
-    "resultType": "PluginCoreGroupsListMembersResult"
+    "argsType": "number",
+    "resultType": "UnderlayHandle[]"
   },
   {
-    "path": "core.groups.update",
-    "namespace": "core.groups",
-    "summary": "Update a group's name and/or membership.",
+    "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": [
-      "Rename group-12 to Kitchen",
-      "Add these two walls to the group",
-      "Remove cmp_7 from group-3\n\n# Example\n```ts\nconst group = await snaptrude.core.groups.update(\"group-12\", {\nname: \"Kitchen\",\naddComponentIds: [\"cmp_9\"],\n})\n```"
+      "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": "string",
-    "resultType": "PluginCoreGroupsUpdateResult"
+    "argsType": "UnderlayHandle",
+    "resultType": "{ scaleFactor: number }"
   },
   {
-    "path": "core.history.redo",
-    "namespace": "core.history",
-    "summary": "Step forward over previously undone entries. Symmetric with {@linkcode PluginHistoryApi.undo}.",
+    "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": [
-      "Redo the change I just undid",
-      "Redo the last two undone actions",
-      "Bring back the edit I reverted",
-      "Step forward again in the history\n\n# Example\n```ts\nawait snaptrude.core.history.redo()\nawait snaptrude.core.history.redo(2)\n```"
+      "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": "number",
-    "resultType": "PluginHistoryStepResult"
+    "argsType": "UnderlayHandle",
+    "resultType": "void"
   },
   {
-    "path": "core.history.undo",
-    "namespace": "core.history",
-    "summary": "Step back over committed history entries.",
+    "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": [
-      "Undo my last change",
-      "Undo the last 3 actions",
-      "Revert what I just did to the model",
-      "Step back one change",
-      "Take back that last edit\n\n# Example\n```ts\nawait snaptrude.core.history.undo()   // one step\nawait snaptrude.core.history.undo(3)  // up to three steps\n```"
+      "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": "number",
-    "resultType": "PluginHistoryStepResult"
+    "argsType": "UnderlayHandle",
+    "resultType": "{ scaleFactor: number }"
   },
   {
     "path": "core.layers.get",
@@ -2113,6 +3183,41 @@
     "argsType": "Vec3Handle",
     "resultType": "Vec3Handle"
   },
+  {
+    "path": "core.mode.get",
+    "namespace": "core.mode",
+    "summary": "Get the currently active application mode.",
+    "examplePrompts": [
+      "Which mode am I in right now?",
+      "Am I in present mode?",
+      "Check whether the editor is in BIM mode\n\n# Example\n```ts\nconst mode = await snaptrude.core.mode.get()\nif (mode !== \"present\") await snaptrude.core.mode.set(\"present\")\n```"
+    ],
+    "argsType": null,
+    "resultType": "PluginAppMode"
+  },
+  {
+    "path": "core.mode.list",
+    "namespace": "core.mode",
+    "summary": "List every application mode the editor has.",
+    "examplePrompts": [
+      "What modes does Snaptrude have?",
+      "List the editor modes I can switch to\n\n# Example\n```ts\nconst { modes } = await snaptrude.core.mode.list()\n// [\"design\", \"bim\", \"present\", \"program\"]\n```"
+    ],
+    "argsType": null,
+    "resultType": "PluginCoreModeListResult"
+  },
+  {
+    "path": "core.mode.set",
+    "namespace": "core.mode",
+    "summary": "Switch the editor to another application mode — the same action as clicking that tab in the top menu bar.",
+    "examplePrompts": [
+      "Switch to present mode",
+      "Open BIM mode",
+      "Go back to design mode\n\n# Example\n```ts\nawait snaptrude.core.mode.set(\"present\")\n// ... presentation work ...\nawait snaptrude.core.mode.set(\"design\")\n```"
+    ],
+    "argsType": "PluginAppMode",
+    "resultType": "PluginCoreModeSetResult"
+  },
   {
     "path": "core.project.settings.getTolerance",
     "namespace": "core.project.settings",
@@ -2266,112 +3371,313 @@
       "Make my lines snap to set angles",
       "Switch angle snap back on\n\n# Example\n```ts\nawait snaptrude.core.project.settings.snaps.enableAngle()\n```"
     ],
-    "argsType": null,
-    "resultType": "boolean"
+    "argsType": null,
+    "resultType": "boolean"
+  },
+  {
+    "path": "core.project.settings.snaps.enableDimension",
+    "namespace": "core.project.settings.snaps",
+    "summary": "Turn dimension snapping on, so drawing and editing snap to the configured length increment.",
+    "examplePrompts": [
+      "Turn on dimension snapping",
+      "Enable snapping to set lengths while I draw",
+      "Make my walls snap to round dimensions",
+      "Switch length snapping back on\n\n# Example\n```ts\nawait snaptrude.core.project.settings.snaps.enableDimension()\n```"
+    ],
+    "argsType": null,
+    "resultType": "boolean"
+  },
+  {
+    "path": "core.project.settings.snaps.enableMagnetic",
+    "namespace": "core.project.settings.snaps",
+    "summary": "Turn magnetic snapping on, so the cursor is pulled to nearby geometry while drawing.",
+    "examplePrompts": [
+      "Turn on magnetic snapping",
+      "Enable the magnet snap",
+      "Make the cursor stick to nearby geometry when drawing",
+      "Switch magnetic snap back on\n\n# Example\n```ts\nawait snaptrude.core.project.settings.snaps.enableMagnetic()\n```"
+    ],
+    "argsType": null,
+    "resultType": "boolean"
+  },
+  {
+    "path": "core.project.settings.snaps.enableNormal",
+    "namespace": "core.project.settings.snaps",
+    "summary": "Turn normal (perpendicular) snapping on, so drawing snaps when the cursor is at a right angle to existing edges.",
+    "examplePrompts": [
+      "Turn on perpendicular snapping",
+      "Enable the normal snap so lines snap at right angles",
+      "Snap to perpendicular when I draw walls",
+      "Help me draw at 90 degrees to existing edges\n\n# Example\n```ts\nawait snaptrude.core.project.settings.snaps.enableNormal()\n```"
+    ],
+    "argsType": null,
+    "resultType": "boolean"
+  },
+  {
+    "path": "core.project.settings.snaps.enableParallel",
+    "namespace": "core.project.settings.snaps",
+    "summary": "Turn parallel snapping on, so drawing snaps when the cursor lines up parallel to existing edges.",
+    "examplePrompts": [
+      "Turn on parallel snapping",
+      "Enable snapping to parallel lines",
+      "Help me draw walls parallel to existing ones",
+      "Snap to parallel edges when drawing\n\n# Example\n```ts\nawait snaptrude.core.project.settings.snaps.enableParallel()\n```"
+    ],
+    "argsType": null,
+    "resultType": "boolean"
+  },
+  {
+    "path": "core.project.settings.snaps.getAngle",
+    "namespace": "core.project.settings.snaps",
+    "summary": "Get the current angle-snap threshold in degrees — the angular increment that drawing snaps to when angle snapping is on.",
+    "examplePrompts": [
+      "What angle does drawing snap to?",
+      "Check the current angle snap in degrees",
+      "Show me the angle snapping increment",
+      "How many degrees is the angle snap set to?\n\n# Example\n```ts\nconst degrees = await snaptrude.core.project.settings.snaps.getAngle()\nconsole.log(degrees)\n```"
+    ],
+    "argsType": null,
+    "resultType": "number"
+  },
+  {
+    "path": "core.project.settings.snaps.getDimension",
+    "namespace": "core.project.settings.snaps",
+    "summary": "Get the current dimension-snap threshold — the length increment that drawing and editing snap to when dimension snapping is on.",
+    "examplePrompts": [
+      "What is the dimension snap distance?",
+      "Check the current snap increment for drawing",
+      "How far apart are the length snaps set?",
+      "Show me the snap spacing value\n\n# Example\n```ts\nconst increment = await snaptrude.core.project.settings.snaps.getDimension()\nconsole.log(increment)\n```"
+    ],
+    "argsType": null,
+    "resultType": "number"
+  },
+  {
+    "path": "core.project.settings.snaps.setAngle",
+    "namespace": "core.project.settings.snaps",
+    "summary": "Set the angle-snap threshold in degrees — the angular increment that drawing snaps to when angle snapping is on.",
+    "examplePrompts": [
+      "Set the angle snap to 15 degrees",
+      "Change angle snapping to every 45 degrees",
+      "Make drawing snap at 30 degree increments",
+      "Adjust the rotation snap angle\n\n# Example\n```ts\n// snap drawing to 15-degree increments (applies while angle snapping is on)\nawait snaptrude.core.project.settings.snaps.setAngle(15)\nawait snaptrude.core.project.settings.snaps.enableAngle()\n```"
+    ],
+    "argsType": "number",
+    "resultType": "boolean"
+  },
+  {
+    "path": "core.project.settings.snaps.setDimension",
+    "namespace": "core.project.settings.snaps",
+    "summary": "Set the dimension-snap threshold — the length increment that drawing and editing snap to when dimension snapping is on.",
+    "examplePrompts": [
+      "Set the dimension snap to 100mm",
+      "Change the snap distance to half a metre",
+      "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"
+  },
+  {
+    "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.project.settings.snaps.enableDimension",
-    "namespace": "core.project.settings.snaps",
-    "summary": "Turn dimension snapping on, so drawing and editing snap to the configured length increment.",
+    "path": "core.proposals.setActive",
+    "namespace": "core.proposals",
+    "summary": "Switch the active proposal.",
     "examplePrompts": [
-      "Turn on dimension snapping",
-      "Enable snapping to set lengths while I draw",
-      "Make my walls snap to round dimensions",
-      "Switch length snapping back on\n\n# Example\n```ts\nawait snaptrude.core.project.settings.snaps.enableDimension()\n```"
+      "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": null,
-    "resultType": "boolean"
+    "argsType": "string",
+    "resultType": "PluginCoreProposalsSetActiveResult"
   },
   {
-    "path": "core.project.settings.snaps.enableMagnetic",
-    "namespace": "core.project.settings.snaps",
-    "summary": "Turn magnetic snapping on, so the cursor is pulled to nearby geometry while drawing.",
+    "path": "core.storeys.copy",
+    "namespace": "core.storeys",
+    "summary": "Copy a storey into the adjacent level, up or down.",
     "examplePrompts": [
-      "Turn on magnetic snapping",
-      "Enable the magnet snap",
-      "Make the cursor stick to nearby geometry when drawing",
-      "Switch magnetic snap back on\n\n# Example\n```ts\nawait snaptrude.core.project.settings.snaps.enableMagnetic()\n```"
+      "Copy this floor to the storey above",
+      "Copy the ground floor down into a new basement",
+      "Repeat this level upwards with its own independent geometry",
+      "Copy just the selected walls onto the next floor up\n\n# Example\n```ts\n// Copy the whole active storey one level up (instanced copies).\nconst { targetStories, created, skipped } =\nawait snaptrude.core.storeys.copy(\"up\")\nconsole.log(`Copied ${created.length} elements onto storey ${targetStories}`)\nif (skipped) console.log(`${skipped} elements were skipped`)\n```"
     ],
-    "argsType": null,
-    "resultType": "boolean"
+    "argsType": "\"up\" | \"down\"",
+    "resultType": "PluginStoryDuplicateResult"
   },
   {
-    "path": "core.project.settings.snaps.enableNormal",
-    "namespace": "core.project.settings.snaps",
-    "summary": "Turn normal (perpendicular) snapping on, so drawing snaps when the cursor is at a right angle to existing edges.",
+    "path": "core.storeys.create",
+    "namespace": "core.storeys",
+    "summary": "Create a new storey (floor) in the project.",
     "examplePrompts": [
-      "Turn on perpendicular snapping",
-      "Enable the normal snap so lines snap at right angles",
-      "Snap to perpendicular when I draw walls",
-      "Help me draw at 90 degrees to existing edges\n\n# Example\n```ts\nawait snaptrude.core.project.settings.snaps.enableNormal()\n```"
+      "Add a third floor to the building",
+      "Create a new storey above the second floor",
+      "Add a basement level to this project",
+      "Insert a new level with a custom floor height\n\n# Example\n```ts\n// Create a new third floor with custom height\nconst { storyId } = await snaptrude.core.storeys.create(3, 4.5)\n```"
     ],
-    "argsType": null,
-    "resultType": "boolean"
+    "argsType": "number",
+    "resultType": "PluginStoryCreateResult"
   },
   {
-    "path": "core.project.settings.snaps.enableParallel",
-    "namespace": "core.project.settings.snaps",
-    "summary": "Turn parallel snapping on, so drawing snaps when the cursor lines up parallel to existing edges.",
+    "path": "core.storeys.delete",
+    "namespace": "core.storeys",
+    "summary": "Delete a storey and everything on it — the same as removing it from the storey panel. Every element placed on the storey (walls, floors, masses, …) is deleted with it, the remaining storeys are re-stacked, and the active storey falls back to an adjacent one. Committed as a single undo step.",
     "examplePrompts": [
-      "Turn on parallel snapping",
-      "Enable snapping to parallel lines",
-      "Help me draw walls parallel to existing ones",
-      "Snap to parallel edges when drawing\n\n# Example\n```ts\nawait snaptrude.core.project.settings.snaps.enableParallel()\n```"
+      "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.core.storeys.delete(3)\nconsole.log(`Deleted storey 3; now on storey ${newActiveStory}`)\n```"
     ],
-    "argsType": null,
-    "resultType": "boolean"
+    "argsType": "number",
+    "resultType": "PluginStoryDeleteResult"
   },
   {
-    "path": "core.project.settings.snaps.getAngle",
-    "namespace": "core.project.settings.snaps",
-    "summary": "Get the current angle-snap threshold in degrees — the angular increment that drawing snaps to when angle snapping is on.",
+    "path": "core.storeys.get",
+    "namespace": "core.storeys",
+    "summary": "Get properties of a storey by its storey number.",
     "examplePrompts": [
-      "What angle does drawing snap to?",
-      "Check the current angle snap in degrees",
-      "Show me the angle snapping increment",
-      "How many degrees is the angle snap set to?\n\n# Example\n```ts\nconst degrees = await snaptrude.core.project.settings.snaps.getAngle()\nconsole.log(degrees)\n```"
+      "What is the height of the ground floor?",
+      "How many rooms are on the second storey?",
+      "Get the total floor area of level 3",
+      "Is the first floor hidden in the viewport?",
+      "Show me the name and height of storey 2\n\n# Example\n```ts\nconst info = await snaptrude.core.storeys.get(1, [\"height\", \"name\", \"spacesCount\"])\nconsole.log(info.name, info.height, info.spacesCount)\n```"
     ],
-    "argsType": null,
-    "resultType": "number"
+    "argsType": "number",
+    "resultType": "PluginStoryGetResult"
   },
   {
-    "path": "core.project.settings.snaps.getDimension",
-    "namespace": "core.project.settings.snaps",
-    "summary": "Get the current dimension-snap threshold — the length increment that drawing and editing snap to when dimension snapping is on.",
+    "path": "core.storeys.list",
+    "namespace": "core.storeys",
+    "summary": "List all storeys in the current project.",
     "examplePrompts": [
-      "What is the dimension snap distance?",
-      "Check the current snap increment for drawing",
-      "How far apart are the length snaps set?",
-      "Show me the snap spacing value\n\n# Example\n```ts\nconst increment = await snaptrude.core.project.settings.snaps.getDimension()\nconsole.log(increment)\n```"
+      "How many floors does this building have?",
+      "List all the storeys in the project",
+      "Show me every level with its name",
+      "Which storeys exist in this model?\n\n# Example\n```ts\nconst { storeys } = await snaptrude.core.storeys.list()\nfor (const s of storeys) {\nconsole.log(`Storey ${s.value}: ${s.name} (id: ${s.id})`)\n}\n```"
     ],
     "argsType": null,
-    "resultType": "number"
+    "resultType": "PluginCoreStoreysListResult"
   },
   {
-    "path": "core.project.settings.snaps.setAngle",
-    "namespace": "core.project.settings.snaps",
-    "summary": "Set the angle-snap threshold in degrees — the angular increment that drawing snaps to when angle snapping is on.",
+    "path": "core.storeys.setActive",
+    "namespace": "core.storeys",
+    "summary": "Make a storey the active storey — the same as clicking it in the storey/layer panel. Subsequent draws and creates target this storey, and in 2D the viewport switches to it. This is a view/navigation change: it is **not** undoable and commits nothing to the model.",
     "examplePrompts": [
-      "Set the angle snap to 15 degrees",
-      "Change angle snapping to every 45 degrees",
-      "Make drawing snap at 30 degree increments",
-      "Adjust the rotation snap angle\n\n# Example\n```ts\n// snap drawing to 15-degree increments (applies while angle snapping is on)\nawait snaptrude.core.project.settings.snaps.setAngle(15)\nawait snaptrude.core.project.settings.snaps.enableAngle()\n```"
+      "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 storey 2, then draw a wall — it lands on storey 2.\nawait snaptrude.core.storeys.setActive(2)\n```"
     ],
     "argsType": "number",
-    "resultType": "boolean"
+    "resultType": "PluginStorySetActiveResult"
   },
   {
-    "path": "core.project.settings.snaps.setDimension",
-    "namespace": "core.project.settings.snaps",
-    "summary": "Set the dimension-snap threshold — the length increment that drawing and editing snap to when dimension snapping is on.",
+    "path": "core.storeys.update",
+    "namespace": "core.storeys",
+    "summary": "Update a storey's floor-to-floor `height` and/or `name`.",
     "examplePrompts": [
-      "Set the dimension snap to 100mm",
-      "Change the snap distance to half a metre",
-      "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```"
+      "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\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.core.storeys.update(1, 5)\n// Rename only, leaving the height untouched.\nawait snaptrude.core.storeys.update(1, undefined, { name: \"Lobby\" })\n```"
     ],
     "argsType": "number",
-    "resultType": "boolean"
+    "resultType": "PluginStoryUpdateResult"
   },
   {
     "path": "core.tags.assign",
@@ -2467,7 +3773,8 @@
       "Show the labels applied to this room\n\n# Example\n```ts\nconst { tags } = await snaptrude.core.tags.getTagsForComponent(\"cmp_42\")\nfor (const t of tags) console.log(t.categoryName, t.tagName)\n```"
     ],
     "argsType": "ComponentHandle",
-    "resultType": "PluginCoreTagsGetTagsForComponentResult"
+    "resultType": "PluginCoreTagsGetTagsForComponentResult",
+    "deprecated": "core.tags.listForComponent"
   },
   {
     "path": "core.tags.list",
@@ -2505,6 +3812,18 @@
     "argsType": "{ tagId?: string; categoryId?: string; untagged?: boolean }",
     "resultType": "PluginCoreTagsListComponentsResult"
   },
+  {
+    "path": "core.tags.listForComponent",
+    "namespace": "core.tags",
+    "summary": "List the tags carried by a component.",
+    "examplePrompts": [
+      "What tags does this space have?",
+      "List the tags on component cmp_42",
+      "Show the labels applied to this room\n\n# Example\n```ts\nconst { tags } = await snaptrude.core.tags.listForComponent(\"cmp_42\")\nfor (const t of tags) console.log(t.categoryName, t.tagName)\n```"
+    ],
+    "argsType": "ComponentHandle",
+    "resultType": "PluginCoreTagsGetTagsForComponentResult"
+  },
   {
     "path": "core.tags.unassign",
     "namespace": "core.tags",
@@ -2606,6 +3925,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",
@@ -2618,7 +3950,8 @@
       "Show me the full scene\n\n# Example\n```ts\nawait snaptrude.core.zoom.extents()\n```"
     ],
     "argsType": null,
-    "resultType": "boolean"
+    "resultType": "boolean",
+    "deprecated": "core.camera.zoomExtents"
   },
   {
     "path": "core.zoom.selection",
@@ -2631,7 +3964,8 @@
       "Fit the view to the selected room\n\n# Example\n```ts\nawait snaptrude.core.zoom.selection()\n```"
     ],
     "argsType": null,
-    "resultType": "boolean"
+    "resultType": "boolean",
+    "deprecated": "core.camera.zoomSelection"
   },
   {
     "path": "design.boolean.intersect",
@@ -2677,7 +4011,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",
@@ -2687,6 +4021,19 @@
     "argsType": "ContourHandle",
     "resultType": "ComponentHandle"
   },
+  {
+    "path": "design.create.buildableEnvelope",
+    "namespace": "design.create",
+    "summary": "Create a new parametric buildable envelope — the zoning-regulated volume a building may occupy — generated from a site polygon, tiered setbacks, a height or floor-count cap, and optional FAR and lot-coverage limits. The host mints the envelope id and returns it. Canonical home of the create formerly at `entity.buildableEnvelope.create` (now deprecated).",
+    "examplePrompts": [
+      "Create a buildable envelope for my site",
+      "Generate the zoning envelope with 10ft front setbacks",
+      "Show the maximum buildable volume with a 150ft height limit",
+      "Create a zoning envelope capped at 12 floors with FAR 3\n\n# Example\n```ts\nconst { buildableEnvelopeId } = await snaptrude.design.create.buildableEnvelope(\n[\n{ x: 0, z: 0 },\n{ x: 100, z: 0 },\n{ x: 100, z: 80 },\n{ x: 0, z: 80 },\n],\n\"ft\",\n[\n{ aboveHeight: 0, front: 10, side: 5, rear: 10 },\n{ aboveHeight: 100, front: 20, side: 10, rear: 20 },\n],\n{ kind: \"max_height\", maxHeight: 150 },\n12,\n)\n```"
+    ],
+    "argsType": "PluginBuildableEnvelopePolygonVertex[]",
+    "resultType": "PluginBuildableEnvelopeCreateResult"
+  },
   {
     "path": "design.create.ceiling",
     "namespace": "design.create",
@@ -2703,7 +4050,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",
@@ -2722,10 +4069,26 @@
       "Duplicate the selected furniture along the X axis",
       "Make 5 copies of this column at 4 metre intervals",
       "Array these walls with a 3m offset",
-      "Clone the desk as a unique copy, not an instance\n\n# Example\n```ts\nconst { vec3 } = snaptrude.core.math\nconst copies = await snaptrude.design.create.copy([\"space-id\"], vec3.new(6, 0, 0), { count: 3 })\n```"
+      "Clone the desk as a unique copy, not an instance"
     ],
     "argsType": "ComponentHandle[]",
-    "resultType": "ComponentHandle[]"
+    "resultType": "ComponentHandle[]",
+    "performance": "To place N repeats of the same geometry, bulk-create the seed(s) once then call this ONCE with `{ count: N - 1 }` — one host round-trip for all copies. Never reproduce geometry by looping `design.create.*` N times. Copy only after the create that mints the seed ids. # Example ```ts const { vec3 } = snaptrude.core.math const copies = await snaptrude.design.create.copy([\"space-id\"], vec3.new(6, 0, 0), { count: 3 }) ```"
+  },
+  {
+    "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",
@@ -2749,7 +4112,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"
@@ -2767,6 +4131,18 @@
     "argsType": "ContourHandle",
     "resultType": "ComponentHandle"
   },
+  {
+    "path": "design.create.massFromBrep",
+    "namespace": "design.create",
+    "summary": "Create a **mass** from a custom solid built with a `core.geom.create` brep constructor (`brepFromFaces`, `brepFromExtrusion`, `brepFromLoft`, `brepFromMesh`, or a brep boolean) — the free-form counterpart of {@linkcode PluginDesignCreateApi.mass}, for solids that are not simple footprint extrusions (pyramids, wedges, faceted volumes).",
+    "examplePrompts": [
+      "Create a mass from these faces",
+      "Turn this custom brep into a scene mass",
+      "Add a pyramid-shaped mass to the model\n\n# Example\n```ts\nconst apex = { x: 0, y: 4, z: 0 }\nconst a = { x: -2, y: 0, z: -2 }\nconst b = { x: 2, y: 0, z: -2 }\nconst c = { x: 2, y: 0, z: 2 }\nconst d = { x: -2, y: 0, z: 2 }\nconst brep = await snaptrude.core.geom.create.brepFromFaces([\n[a, d, c, b],\n[a, b, apex],\n[b, c, apex],\n[c, d, apex],\n[d, a, apex],\n])\nconst pyramid = await snaptrude.design.create.massFromBrep(brep, \"Pavilion\")\n```"
+    ],
+    "argsType": "BrepHandle",
+    "resultType": "ComponentHandle"
+  },
   {
     "path": "design.create.referenceLines",
     "namespace": "design.create",
@@ -2808,6 +4184,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,23 +4207,27 @@
       "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"
     ],
     "argsType": "ContourHandle",
-    "resultType": "ComponentHandle"
+    "resultType": "ComponentHandle",
+    "performance": "For MORE THAN ONE space, call `design.create.spaces(items[])` — the whole batch is one host round-trip. Looping this single-space creator is N round-trips (slow, and a large loop can trip the plugin rate limit). # Example ```ts const v = snaptrude.core.math.vec3 const outer = await snaptrude.core.geom.create.profileFromLinePoints([ await v.new(0, 0, 0), await v.new(10, 0, 0), await v.new(10, 0, 8), await v.new(0, 0, 8), ]) const contour = await snaptrude.core.geom.create.contourFromProfile(outer) const space = await snaptrude.design.create.space(contour, 3, \"Living\") // …place one directly on the second floor (no setActive dance): const upstairs = await snaptrude.design.create.space( contour, 3, \"Bedroom\", undefined, undefined, undefined, undefined, 2, ) ```"
   },
   {
     "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"
     ],
     "argsType": "PluginCreateSpaceItem[]",
-    "resultType": "ComponentHandle[]"
+    "resultType": "ComponentHandle[]",
+    "performance": "Bulk creator — the whole batch is ONE host round-trip. Always prefer this over calling `design.create.space` in a loop: build the full `items[]` array first (all per-item math and geometry up front), then make one call. # Example ```ts const rect = await snaptrude.core.geom.create.profileRect(4, 3) const contour = await snaptrude.core.geom.create.contourFromProfile(rect) const [a, b] = await snaptrude.design.create.spaces([ { contour, height: 3, label: \"R1\" }, { contour, height: 4, label: \"R2\", position: await vec3.new(10, 0, 0) }, ]) ```"
   },
   {
     "path": "design.create.staircase",
@@ -2858,11 +4252,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",
@@ -2872,10 +4283,50 @@
       "Remove these walls from the model",
       "Get rid of this mass entirely",
       "Delete all the furniture I picked",
-      "Remove the door and window I just created\n\n# Example\n```ts\n// Hard-delete every furniture item on storey 2 (a single undo entry)\nconst furniture = await snaptrude.design.query.listFurniture({ storeys: [2] })\nif (furniture.length > 0) {\nconst { affected } = await snaptrude.design.delete.entities(furniture)\n}\n```"
+      "Remove the door and window I just created"
     ],
     "argsType": "ComponentHandle[]",
-    "resultType": "PluginDesignChangeResult"
+    "resultType": "PluginDesignChangeResult",
+    "performance": "Array delete — pass every target in one call (one host round-trip). There is no per-item delete; collect the whole set and never loop this per entity. # Example ```ts // Hard-delete every furniture item on storey 2 (a single undo entry) const furniture = await snaptrude.design.query.listFurniture({ storeys: [2] }) if (furniture.length > 0) { const { affected } = await snaptrude.design.delete.entities(furniture) } ```"
+  },
+  {
+    "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",
@@ -2955,6 +4406,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 +4539,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 +4617,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 +4655,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 +4682,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 +4708,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",
@@ -3205,21 +4797,45 @@
       "Are any faces of the selected object painted differently?\n\n# Example\n```ts\nconst [selected] = await snaptrude.design.selection.get()\nconst uniform = await snaptrude.design.materials.isUniform(selected)\nconsole.log(uniform ? \"one material all over\" : \"painted per face\")\n```"
     ],
     "argsType": "ComponentHandle",
-    "resultType": "boolean"
+    "resultType": "boolean"
+  },
+  {
+    "path": "design.materials.list",
+    "namespace": "design.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?",
+      "Which finishes exist in this model?",
+      "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": 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.list",
+    "path": "design.materials.listPresets",
     "namespace": "design.materials",
-    "summary": "List the project 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": [
-      "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```"
+      "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": "\"project\" | \"preset\"",
-    "resultType": "MaterialHandle[]"
+    "argsType": null,
+    "resultType": "PluginPresetMaterial[]"
   },
   {
     "path": "design.materials.reset",
@@ -3234,6 +4850,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",
@@ -3288,6 +4916,19 @@
     "argsType": "ComponentHandle",
     "resultType": "CurveHandle | null"
   },
+  {
+    "path": "design.query.geometry.getTriangulatedMeshes",
+    "namespace": "design.query.geometry",
+    "summary": "Get the **triangulated render meshes** of scene components as plain, serializable arrays — flat world-space vertex `positions` (`[x0, y0, z0, x1, …]`) and triangle `indices` (three per triangle), one record per requested component.",
+    "examplePrompts": [
+      "Export the selected masses as a triangle mesh",
+      "Get the raw vertices and triangles of this wall in world coordinates",
+      "Give me the triangulated geometry of every space with its materials",
+      "Compute the surface area of this roof from its triangles"
+    ],
+    "argsType": "ComponentHandle[]",
+    "resultType": "PluginDesignQueryGeometryGetTriangulatedMeshesResult"
+  },
   {
     "path": "design.query.getBoundingBox",
     "namespace": "design.query",
@@ -3368,10 +5009,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 +5021,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,13 +5278,28 @@
     "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"
   },
+  {
+    "path": "design.query.referenceLines.get",
+    "namespace": "design.query.referenceLines",
+    "summary": "Get properties of a reference line by its ID.",
+    "examplePrompts": [
+      "Get the curve geometry of this reference line",
+      "Where does this grid line run?",
+      "Read the geometry of a guide line by its id",
+      "Look up the curve of the selected reference line\n\n# Example\n```ts\nconst [refLine] = await snaptrude.design.query.listReferenceLines()\nconst result = await snaptrude.design.query.referenceLines.get(refLine, [\"curve\"])\n// result.curve is an opaque CurveHandle; read its coordinates via\n// `snaptrude.core.geom.curve`.\n```"
+    ],
+    "argsType": "string",
+    "resultType": "PluginReferenceLineGetResult"
+  },
   {
     "path": "design.query.spaces.get",
     "namespace": "design.query.spaces",
@@ -3644,6 +5314,19 @@
     "argsType": "ComponentHandle",
     "resultType": "PluginDesignQuerySpacesGetResult"
   },
+  {
+    "path": "design.query.spaces.getEnclosure",
+    "namespace": "design.query.spaces",
+    "summary": "Get the **enclosure** of a space — the floor and ceiling that cap it, the bounding walls around it (with each wall's door/window openings), and the neighbouring spaces it shares a boundary with.",
+    "examplePrompts": [
+      "What walls, floor and ceiling enclose this room?",
+      "Which of this room's walls are external?",
+      "List the doors and windows around the selected space",
+      "Which spaces are adjacent to this room, and through which wall?\n\n# Example\n```ts\nconst [space] = await snaptrude.design.query.listSpaces()\nconst enclosure = await snaptrude.design.query.spaces.getEnclosure(space)\nif (enclosure) {\nconst walls = enclosure.surfaces.filter((s) => s.role === \"wall\")\nconst external = walls.filter((s) => s.isExternal)\nconsole.log(`${walls.length} walls, ${external.length} external`)\n}\n```"
+    ],
+    "argsType": "ComponentHandle",
+    "resultType": "PluginSpaceEnclosure | null"
+  },
   {
     "path": "design.query.spaces.getFootprint",
     "namespace": "design.query.spaces",
@@ -3723,6 +5406,51 @@
     "argsType": "ComponentHandle[]",
     "resultType": "PluginDesignChangeResult"
   },
+  {
+    "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"
+    ],
+    "argsType": "ComponentHandle[]",
+    "resultType": "PluginDesignChangeResult",
+    "performance": "Array API — one host round-trip for the whole set. Pass every target in a single call; never loop `design.transform.align` per entity. # Example ```ts const rooms = await snaptrude.design.selection.get() // align every room's left (world -X) edge to a common minimum await snaptrude.design.transform.align(rooms, \"left\") // …or align them to a fixed reference component's left edge const [anchor] = await snaptrude.design.query.listWalls({ storeys: [1] }) await snaptrude.design.transform.align(rooms, \"left\", { reference: anchor }) ```"
+  },
+  {
+    "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"
+    ],
+    "argsType": "ComponentHandle[]",
+    "resultType": "PluginDesignChangeResult",
+    "performance": "Array API — one host round-trip for the whole set. Pass every target in a single call; never loop `design.transform.mirror` per entity. # Example ```ts const rooms = await snaptrude.design.selection.get() await snaptrude.design.transform.mirror(rooms, \"x\") ```"
+  },
   {
     "path": "design.transform.move",
     "namespace": "design.transform",
@@ -3732,23 +5460,52 @@
       "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```"
+      "Move these masses up one storey"
     ],
     "argsType": "ComponentHandle[]",
-    "resultType": "PluginDesignChangeResult"
+    "resultType": "PluginDesignChangeResult",
+    "performance": "Array API — one host round-trip for the whole set. Pass every target in a single call; never loop `design.transform.move` per entity. # Example ```ts const { vec3 } = snaptrude.core.math await snaptrude.design.transform.move([\"space-id\"], vec3.new(10, 0, 0)) ```"
   },
   {
     "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.",
+    "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\n\n# Example\n```ts\nawait snaptrude.design.transform.rotate([\"space-id\"], 90)\n```"
+      "Rotate these masses 30 degrees around the vertical axis",
+      "Rotate these walls 90 degrees about the origin"
     ],
     "argsType": "ComponentHandle[]",
-    "resultType": "PluginDesignChangeResult"
+    "resultType": "PluginDesignChangeResult",
+    "performance": "Array API — one host round-trip for the whole set. Pass every target in a single call; never loop `design.transform.rotate` per entity. # Example ```ts await snaptrude.design.transform.rotate([\"space-id\"], 90) // …or rotate about an explicit pivot point const { vec3 } = snaptrude.core.math await snaptrude.design.transform.rotate([\"space-id\"], 90, { pivot: vec3.new(0, 0, 0) }) ```"
+  },
+  {
+    "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",
@@ -3763,6 +5520,134 @@
     "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.buildableEnvelope",
+    "namespace": "design.update",
+    "summary": "Update an existing parametric buildable envelope — regenerate the zoning volume from a revised site polygon, setbacks, vertical cap, or FAR and lot-coverage limits, keeping the same envelope id. Canonical home of the update formerly at `entity.buildableEnvelope.update` (now deprecated).",
+    "examplePrompts": [
+      "Change the envelope's height limit to 175 feet",
+      "Update the setbacks on the buildable envelope",
+      "Regenerate the zoning envelope with a new site boundary",
+      "Increase the FAR on the buildable volume\n\n# Example\n```ts\nconst { buildableEnvelopeId } = await snaptrude.design.update.buildableEnvelope(\nexistingId,\n[\n{ x: 0, z: 0 },\n{ x: 100, z: 0 },\n{ x: 100, z: 80 },\n{ x: 0, z: 80 },\n],\n\"ft\",\n[{ aboveHeight: 0, front: 10, side: 5, rear: 10 }],\n{ kind: \"max_height\", maxHeight: 175 },\n12,\n)\n```"
+    ],
+    "argsType": "string",
+    "resultType": "PluginBuildableEnvelopeUpdateResult"
+  },
+  {
+    "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": [
+      "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": "boolean"
+  },
+  {
+    "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": [
+      "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.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": [
+      "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",
+    "resultType": "PluginDesignChangeResult"
+  },
   {
     "path": "design.update.space",
     "namespace": "design.update",
@@ -3772,10 +5657,11 @@
       "Change this space's room type to Meeting Room",
       "Set the height of this room to 3 metres",
       "Move this space into the Circulation department",
-      "Exclude this room from the area calculations\n\n# Example\n```ts\nawait snaptrude.design.update.space(\"space-id\", { properties: { room_type: \"Office\" } })\n```"
+      "Exclude this room from the area calculations"
     ],
     "argsType": "ComponentHandle",
-    "resultType": "PluginSpaceUpdateResult"
+    "resultType": "PluginSpaceUpdateResult",
+    "performance": "For MORE THAN ONE space, call `design.update.spaces(items[])` — the whole batch is one host round-trip. Looping this single-space updater is N round-trips. # Example ```ts await snaptrude.design.update.space(\"space-id\", { properties: { room_type: \"Office\" } }) ```"
   },
   {
     "path": "design.update.spaces",
@@ -3786,10 +5672,104 @@
       "Change the room type of these five spaces at once",
       "Set every room on this floor to a 3m height in one go",
       "Bulk-assign these spaces to the Service department",
-      "Mark all of these rooms as excluded from area in one update\n\n# Example\n```ts\n// Re-label every selected room and mark it NET area — one undoable bulk update\nconst rooms = await snaptrude.design.query.listSpaces({ isSelected: true })\nconst results = await snaptrude.design.update.spaces(\nrooms.map((space) => ({\nspace,\nproperties: { room_type: \"Bedroom\", areaClass: \"NET\" },\n})),\n)\n// One result per item, in input order\nconsole.log(results.map((r) => r.spaceId))\n```"
+      "Mark all of these rooms as excluded from area in one update"
     ],
     "argsType": "PluginUpdateSpaceItem[]",
-    "resultType": "PluginSpaceUpdateResult[]"
+    "resultType": "PluginSpaceUpdateResult[]",
+    "performance": "Bulk update — the whole batch is ONE host round-trip. Prefer over looping `design.update.space`: build the `items[]` array first, then make one call. # Example ```ts // Re-label every selected room and mark it NET area — one undoable bulk update const rooms = await snaptrude.design.query.listSpaces({ isSelected: true }) const results = await snaptrude.design.update.spaces( rooms.map((space) => ({ space, properties: { room_type: \"Bedroom\", areaClass: \"NET\" }, })), ) // One result per item, in input order console.log(results.map((r) => r.spaceId)) ```"
+  },
+  {
+    "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",
@@ -3844,6 +5824,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",
@@ -3882,7 +5888,8 @@
       "Create a zoning envelope capped at 12 floors with FAR 3\n\n# Example\n```ts\nconst { buildableEnvelopeId } = await snaptrude.entity.buildableEnvelope.create(\n[\n{ x: 0, z: 0 },\n{ x: 100, z: 0 },\n{ x: 100, z: 80 },\n{ x: 0, z: 80 },\n],\n\"ft\",\n[\n{ aboveHeight: 0, front: 10, side: 5, rear: 10 },\n{ aboveHeight: 100, front: 20, side: 10, rear: 20 },\n],\n{ kind: \"max_height\", maxHeight: 150 },\n12,\n)\n```"
     ],
     "argsType": "PluginBuildableEnvelopePolygonVertex[]",
-    "resultType": "PluginBuildableEnvelopeCreateResult"
+    "resultType": "PluginBuildableEnvelopeCreateResult",
+    "deprecated": "design.create.buildableEnvelope"
   },
   {
     "path": "entity.buildableEnvelope.update",
@@ -3896,7 +5903,8 @@
       "Modify the envelope to allow 15 storeys instead\n\n# Example\n```ts\nconst { buildableEnvelopeId } = await snaptrude.entity.buildableEnvelope.update(\nexistingId,\n[\n{ x: 0, z: 0 },\n{ x: 100, z: 0 },\n{ x: 100, z: 80 },\n{ x: 0, z: 80 },\n],\n\"ft\",\n[{ aboveHeight: 0, front: 10, side: 5, rear: 10 }],\n{ kind: \"max_height\", maxHeight: 175 },\n12,\n)\n```"
     ],
     "argsType": "string",
-    "resultType": "PluginBuildableEnvelopeUpdateResult"
+    "resultType": "PluginBuildableEnvelopeUpdateResult",
+    "deprecated": "design.update.buildableEnvelope"
   },
   {
     "path": "entity.referenceLine.createMulti",
@@ -3910,7 +5918,8 @@
       "Turn this profile into reference lines\n\n# Example\n```ts\nconst { vec3 } = snaptrude.core.math\n\nconst start = await vec3.new(0, 0, 0)\nconst mid = await vec3.new(10, 0, 0)\nconst end = await vec3.new(10, 0, 10)\nconst l1 = await snaptrude.core.geom.create.line(start, mid)\nconst l2 = await snaptrude.core.geom.create.line(mid, end)\nconst profile = await snaptrude.core.geom.create.profileFromCurves([l1, l2])\n\nconst { referenceLineIds } = await snaptrude.entity.referenceLine.createMulti(profile)\n```"
     ],
     "argsType": "ProfileHandle",
-    "resultType": "PluginReferenceLineCreateMultiResult"
+    "resultType": "PluginReferenceLineCreateMultiResult",
+    "deprecated": "design.create.referenceLines"
   },
   {
     "path": "entity.referenceLine.delete",
@@ -3923,7 +5932,8 @@
       "Erase a reference line by its id\n\n# Example\n```ts\nawait snaptrude.entity.referenceLine.delete(\"some-ref-line-id\")\n```"
     ],
     "argsType": "string",
-    "resultType": "PluginReferenceLineDeleteResult"
+    "resultType": "PluginReferenceLineDeleteResult",
+    "deprecated": "design.delete.entities"
   },
   {
     "path": "entity.referenceLine.get",
@@ -3936,7 +5946,8 @@
       "Look up the curve of the selected reference line\n\n# Example\n```ts\nconst result = await snaptrude.entity.referenceLine.get(\"some-ref-line-id\", [\"curve\"])\n// result.curve is an opaque CurveHandle; a dedicated curve read API for its\n// coordinates is exposed separately via `snaptrude.core.geom.curve`.\n```"
     ],
     "argsType": "string",
-    "resultType": "PluginReferenceLineGetResult"
+    "resultType": "PluginReferenceLineGetResult",
+    "deprecated": "design.query.referenceLines.get"
   },
   {
     "path": "entity.referenceLine.getAll",
@@ -3949,7 +5960,8 @@
       "Do I have any reference lines in this project?\n\n# Example\n```ts\nconst { referenceLineIds } = await snaptrude.entity.referenceLine.getAll()\nconsole.log(`Project has ${referenceLineIds.length} reference lines`)\n```"
     ],
     "argsType": null,
-    "resultType": "PluginReferenceLineGetAllResult"
+    "resultType": "PluginReferenceLineGetAllResult",
+    "deprecated": "design.query.listReferenceLines"
   },
   {
     "path": "entity.story.create",
@@ -3963,7 +5975,37 @@
       "Add another floor on top of the building\n\n# Example\n```ts\n// Create a new third floor with custom height\nconst { storyId } = await snaptrude.entity.story.create(3, 4.5)\n```"
     ],
     "argsType": "number",
-    "resultType": "PluginStoryCreateResult"
+    "resultType": "PluginStoryCreateResult",
+    "deprecated": "core.storeys.create"
+  },
+  {
+    "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",
+    "deprecated": "core.storeys.delete"
+  },
+  {
+    "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"
+    ],
+    "argsType": "\"up\" | \"down\"",
+    "resultType": "PluginStoryDuplicateResult",
+    "performance": "For storeys that share a layout, duplicate the storey instead of recreating its contents floor by floor — this copies every eligible element in one call, and the default instanced copies keep the floors linked. To stack many identical floors, either call this per level or capture the storey's component ids and `design.create.copy(ids, oneFloorRise, { count })` to lay them all down in a single call. # Example ```ts // Duplicate the whole active story one level up (instanced copies). const { targetStories, created, skipped } = await snaptrude.entity.story.duplicate(\"up\") console.log(`Copied ${created.length} elements onto story ${targetStories}`) if (skipped) console.log(`${skipped} elements were skipped`) ```",
+    "deprecated": "core.storeys.copy"
   },
   {
     "path": "entity.story.get",
@@ -3977,7 +6019,8 @@
       "Show me the name and height of story 2\n\n# Example\n```ts\nconst info = await snaptrude.entity.story.get(1, [\"height\", \"name\", \"spacesCount\"])\nconsole.log(info.name, info.height, info.spacesCount)\n```"
     ],
     "argsType": "number",
-    "resultType": "PluginStoryGetResult"
+    "resultType": "PluginStoryGetResult",
+    "deprecated": "core.storeys.get"
   },
   {
     "path": "entity.story.getAll",
@@ -3990,20 +6033,37 @@
       "Which stories exist in this model?\n\n# Example\n```ts\nconst { stories } = await snaptrude.entity.story.getAll()\nfor (const s of stories) {\nconsole.log(`Story ${s.value}: ${s.name} (id: ${s.id})`)\n}\n```"
     ],
     "argsType": null,
-    "resultType": "PluginStoryGetAllResult"
+    "resultType": "PluginStoryGetAllResult",
+    "deprecated": "core.storeys.list"
+  },
+  {
+    "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",
+    "deprecated": "core.storeys.setActive"
   },
   {
     "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"
+    "resultType": "PluginStoryUpdateResult",
+    "deprecated": "core.storeys.update"
   },
   {
     "path": "presentation.aiInspiration.cancelJob",
@@ -4201,15 +6261,76 @@
     "resultType": "PluginAIInspirationRunResult"
   },
   {
-    "path": "presentation.aiInspiration.saveRecipe",
-    "namespace": "presentation.aiInspiration",
-    "summary": "Save a project-level AI Inspiration recipe.",
+    "path": "presentation.aiInspiration.saveRecipe",
+    "namespace": "presentation.aiInspiration",
+    "summary": "Save a project-level AI Inspiration recipe.",
+    "examplePrompts": [
+      "Save this recipe as \"Dusk facade render\"",
+      "Store these generation steps for reuse\n\n# Example\n```ts\nconst extraction = await snaptrude.presentation.aiInspiration.extractRecipeFromShape({\nshapeId: selected.shapeId,\n})\nif (extraction.status === \"ready\") {\nconst saved = await snaptrude.presentation.aiInspiration.saveRecipe({\ndraft: extraction.draft,\nname: \"Dusk facade render\",\n})\nconsole.log(saved.status, saved.recipe?.id)\n}\n```"
+    ],
+    "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": [
-      "Save this recipe as \"Dusk facade render\"",
-      "Store these generation steps for reuse\n\n# Example\n```ts\nconst extraction = await snaptrude.presentation.aiInspiration.extractRecipeFromShape({\nshapeId: selected.shapeId,\n})\nif (extraction.status === \"ready\") {\nconst saved = await snaptrude.presentation.aiInspiration.saveRecipe({\ndraft: extraction.draft,\nname: \"Dusk facade render\",\n})\nconsole.log(saved.status, saved.recipe?.id)\n}\n```"
+      "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": "PluginAIInspirationSaveRecipeArgs",
-    "resultType": "PluginAIInspirationSaveRecipeResult"
+    "argsType": null,
+    "resultType": "PluginPresentationDiagramsGenerateResult"
   },
   {
     "path": "presentation.diagrams.place",
@@ -4223,6 +6344,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 +6384,166 @@
     "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.placedViews.get",
+    "namespace": "presentation.placedViews",
+    "summary": "Get a single placed view by its shape id.",
+    "examplePrompts": [
+      "Get the placed view I just dropped on the sheet",
+      "Read the position and scale of this placed view",
+      "What's the crop on shape_123?\n\n# Example\n```ts\nconst placed = await snaptrude.presentation.placedViews.get(shapeId)\nconsole.log(placed.position, placed.scale)\n```"
+    ],
+    "argsType": "string",
+    "resultType": "PluginPlacedView"
+  },
+  {
+    "path": "presentation.placedViews.list",
+    "namespace": "presentation.placedViews",
+    "summary": "List the placed views in the presentation.",
+    "examplePrompts": [
+      "Which views are placed on this sheet?",
+      "List all the placed views in the presentation",
+      "What's laid out on sheet 2?",
+      "Show me every view on the Present canvas\n\n# Example\n```ts\nconst { placedViews } = await snaptrude.presentation.placedViews.list(\"sheet_1\")\n```"
+    ],
+    "argsType": "string",
+    "resultType": "PluginPresentationPlacedViewsListResult"
+  },
+  {
+    "path": "presentation.placedViews.move",
+    "namespace": "presentation.placedViews",
+    "summary": "Move a placed view.",
+    "examplePrompts": [
+      "Move the site plan view to the top-left of sheet 2",
+      "Reposition this placed view to 100, 200",
+      "Move the hero perspective onto the cover sheet\n\n# Example\n```ts\nawait snaptrude.presentation.placedViews.move(shapeId, { x: 50, y: 50 }, {\nsheetId: \"sheet_2\",\n})\n```"
+    ],
+    "argsType": "string",
+    "resultType": "PluginPlacedView"
+  },
+  {
+    "path": "presentation.placedViews.scale",
+    "namespace": "presentation.placedViews",
+    "summary": "Resize a placed view by a uniform factor.",
+    "examplePrompts": [
+      "Make this placed view twice as big",
+      "Shrink the placed 3D view to half its size",
+      "Scale the placed plan up by 50%\n\n# Example\n```ts\nawait snaptrude.presentation.placedViews.scale(shapeId, 2)\n```"
+    ],
+    "argsType": "string",
+    "resultType": "PluginPlacedView"
+  },
+  {
+    "path": "presentation.placedViews.setCrop",
+    "namespace": "presentation.placedViews",
+    "summary": "Crop a placed view, or clear its crop.",
+    "examplePrompts": [
+      "Crop the placed view to its left half",
+      "Crop this view to the top-right quarter",
+      "Remove the crop from the placed plan\n\n# Example\n```ts\n// keep the left half of the view\nawait snaptrude.presentation.placedViews.setCrop(shapeId, {\ntopLeft: { x: 0, y: 0 },\nbottomRight: { x: 0.5, y: 1 },\n})\nawait snaptrude.presentation.placedViews.setCrop(shapeId, null) // clear\n```"
+    ],
+    "argsType": "string",
+    "resultType": "PluginPlacedView"
+  },
+  {
+    "path": "presentation.placedViews.setScale",
+    "namespace": "presentation.placedViews",
+    "summary": "Set a placed view's architectural scale.",
+    "examplePrompts": [
+      "Set the plan to 1:100",
+      "Change the placed floor plan to 1:50 scale",
+      "Make this view print at quarter-inch scale\n\n# Example\n```ts\nawait snaptrude.presentation.placedViews.setScale(shapeId, 100) // 1:100\n```"
+    ],
+    "argsType": "string",
+    "resultType": "PluginPlacedView"
+  },
+  {
+    "path": "presentation.shapes.list",
+    "namespace": "presentation.shapes",
+    "summary": "List the calling plugin's shapes.",
+    "examplePrompts": [
+      "Which annotations has my plugin placed on the sheets?",
+      "List the plugin's shapes before refreshing them",
+      "Check whether the FAR label already exists\n\n# Example\n```ts\nconst { shapes } = await snaptrude.presentation.shapes.list()\nconst hasLabel = shapes.some((s) => s.key === \"far-label\")\n```"
+    ],
+    "argsType": null,
+    "resultType": "PluginPresentationShapesListResult"
+  },
+  {
+    "path": "presentation.shapes.remove",
+    "namespace": "presentation.shapes",
+    "summary": "Delete the shape for a key.",
+    "examplePrompts": [
+      "Remove the FAR label from the sheet",
+      "Delete the highlight the plugin added earlier",
+      "Clear the \"far-label\" annotation\n\n# Example\n```ts\nconst removed = await snaptrude.presentation.shapes.remove(\"far-label\")\n```"
+    ],
+    "argsType": "string",
+    "resultType": "boolean"
+  },
+  {
+    "path": "presentation.shapes.removeAll",
+    "namespace": "presentation.shapes",
+    "summary": "Delete every shape owned by the calling plugin.",
+    "examplePrompts": [
+      "Clear all annotations my plugin added",
+      "Reset the sheet output before rerunning the analysis",
+      "Remove every plugin-drawn shape\n\n# Example\n```ts\nconst deleted = await snaptrude.presentation.shapes.removeAll()\n```"
+    ],
+    "argsType": null,
+    "resultType": "number"
+  },
+  {
+    "path": "presentation.shapes.upsert",
+    "namespace": "presentation.shapes",
+    "summary": "Create or update the shape for a key.",
+    "examplePrompts": [
+      "Update the analysis label on the sheet instead of adding another one",
+      "Rerun the daylight report and refresh its annotations",
+      "Keep one \"FAR: 2.4\" text on Sheet 1 that updates on each run",
+      "Draw a highlight rectangle the plugin can move on the next run\n\n# Example\n```ts\nconst { shapeId, created } = await snaptrude.presentation.shapes.upsert(\"far-label\", {\ntype: \"text\",\ntext: \"FAR: 2.4\",\nposition: { x: 40, y: 40 },\ncolor: \"blue\",\n})\n```"
+    ],
+    "argsType": "string",
+    "resultType": "PluginPresentationShapesUpsertResult"
+  },
   {
     "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 +6577,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 +6665,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 +6707,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 +6734,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 +6759,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 +6807,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 +6821,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 +6834,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 +6862,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 +7007,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 +7134,55 @@
     "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.getTimezone",
+    "namespace": "program.site",
+    "summary": "Get the IANA timezone of the project's geographic location.",
+    "examplePrompts": [
+      "What timezone is this project in?",
+      "Get the site's IANA timezone",
+      "What's the local time zone at the project location?",
+      "Which timezone should I use for the sun study schedule?\n\n# Example\n```ts\nconst timezone = await snaptrude.program.site.getTimezone()\nif (timezone) console.log(`Project timezone: ${timezone}`)\n```"
+    ],
+    "argsType": null,
+    "resultType": "PluginProgramSiteTimezoneResult"
+  },
+  {
+    "path": "program.site.getWeather",
+    "namespace": "program.site",
+    "summary": "Get the weather file resolved for the project site.",
+    "examplePrompts": [
+      "Which weather file is my project using?",
+      "What EPW station was resolved for this site?",
+      "Get the weather file id for the daylight analysis\n\n# Example\n```ts\nconst weather = await snaptrude.program.site.getWeather()\nif (weather) console.log(weather.station, weather.selectionMethod)\n```"
+    ],
+    "argsType": null,
+    "resultType": "PluginProgramSiteWeatherResult"
+  },
   {
     "path": "program.site.listGeoPolygons",
     "namespace": "program.site",
@@ -4663,7 +7199,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",
@@ -4698,6 +7234,19 @@
     "argsType": "string",
     "resultType": "PluginProgramSpreadsheetAddConditionalFormattingResult"
   },
+  {
+    "path": "program.spreadsheet.addImage",
+    "namespace": "program.spreadsheet",
+    "summary": "Place a floating image on a workbook sheet from a base64 data URI.",
+    "examplePrompts": [
+      "Add my logo image to the report sheet",
+      "Place a PNG at cell B2 on the Takeoff sheet",
+      "Put an SVG diagram on a spreadsheet sheet",
+      "Insert an image into the workbook\n\n# Example\n```ts\nconst { name } = await snaptrude.program.spreadsheet.addImage(\n\"Report\",\n{ dataUri: \"data:image/png;base64,iVBORw0...\" },\n{ anchorCell: \"B2\", size: { width: 240, height: 120 }, name: \"logo\" },\n)\n```"
+    ],
+    "argsType": "string",
+    "resultType": "PluginProgramSpreadsheetAddImageResult"
+  },
   {
     "path": "program.spreadsheet.bindings.create",
     "namespace": "program.spreadsheet.bindings",
@@ -4731,7 +7280,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"
   },
   {
@@ -4747,15 +7296,41 @@
     "argsType": "string",
     "resultType": "PluginProgramSpreadsheetCreateSheetResult"
   },
+  {
+    "path": "program.spreadsheet.datasets.list",
+    "namespace": "program.spreadsheet.datasets",
+    "summary": "List the stored plugin datasets.",
+    "examplePrompts": [
+      "List my plugin datasets",
+      "What datasets are stored for the sheets?",
+      "Show the data sets bindings can use\n\n# Example\n```ts\nconst { datasets } = await snaptrude.program.spreadsheet.datasets.list()\n```"
+    ],
+    "argsType": null,
+    "resultType": "PluginProgramSpreadsheetDatasetsListResult"
+  },
+  {
+    "path": "program.spreadsheet.datasets.set",
+    "namespace": "program.spreadsheet.datasets",
+    "summary": "Store (upsert) a named plugin dataset.",
+    "examplePrompts": [
+      "Store my plugin's rows as a named dataset",
+      "Upload data the sheets can bind to and refresh",
+      "Save a dataset for a live sheet binding",
+      "Push my computed table so a binding keeps it fresh\n\n# Example\n```ts\nawait snaptrude.program.spreadsheet.datasets.set(\n\"costs\",\n[\n{ key: \"item\", header: \"Item\" },\n{ key: \"cost\", header: \"Cost\", align: \"right\" },\n],\n[{ item: \"Concrete\", cost: 120 }],\n)\n```"
+    ],
+    "argsType": "string",
+    "resultType": "PluginProgramSpreadsheetDatasetsSetResult"
+  },
   {
     "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 +7345,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 +7460,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 +7487,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 +7500,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"
   },
   {
@@ -5000,5 +7589,103 @@
     ],
     "argsType": "PluginSpreadsheetTransactionOp[]",
     "resultType": "PluginProgramSpreadsheetTransactionResult"
+  },
+  {
+    "path": "workspace.projects.copy",
+    "namespace": "workspace.projects",
+    "summary": "Copy the **current** project into a new project — the dashboard's \"Save As\".",
+    "examplePrompts": [
+      "Save this project as a new copy called Tower Study v2",
+      "Duplicate the current project into the Acme team",
+      "Make a copy of this project so I can try changes\n\n# Example\n```ts\nconst { projectId } = await snaptrude.workspace.projects.copy(\"Tower Study v2\")\n```"
+    ],
+    "argsType": "string",
+    "resultType": "PluginWorkspaceProjectsCopyResult"
+  },
+  {
+    "path": "workspace.projects.create",
+    "namespace": "workspace.projects",
+    "summary": "Create a new, empty BIM project.",
+    "examplePrompts": [
+      "Create a new project called Tower Study",
+      "Start a new project in the Acme team",
+      "Make a fresh project using millimeters",
+      "Create an empty project for me to work in\n\n# Example\n```ts\nconst { projectId } = await snaptrude.workspace.projects.create(\"Tower Study\", {\nteamId: \"team_1\",\nunit: \"mm\",\n})\n```"
+    ],
+    "argsType": "string",
+    "resultType": "PluginWorkspaceProjectsCreateResult"
+  },
+  {
+    "path": "workspace.projects.get",
+    "namespace": "workspace.projects",
+    "summary": "Get a single project by id.",
+    "examplePrompts": [
+      "Get the project with this id",
+      "Look up a project by its floorkey",
+      "What is the name of this project?\n\n# Example\n```ts\nconst project = await snaptrude.workspace.projects.get(\"floorkey_123\")\nif (project) console.log(project.name)\n```"
+    ],
+    "argsType": "string",
+    "resultType": "PluginWorkspaceProjectsGetResult"
+  },
+  {
+    "path": "workspace.projects.list",
+    "namespace": "workspace.projects",
+    "summary": "List the projects the user can access.",
+    "examplePrompts": [
+      "List all my projects",
+      "Show the projects in the Acme team",
+      "How many projects do I have?",
+      "What projects can I open?\n\n# Example\n```ts\nconst { projects } = await snaptrude.workspace.projects.list({ teamId: \"team_1\" })\nfor (const p of projects) console.log(p.id, p.name)\n```"
+    ],
+    "argsType": "{ teamId?: string }",
+    "resultType": "PluginWorkspaceProjectsListResult"
+  },
+  {
+    "path": "workspace.projects.rename",
+    "namespace": "workspace.projects",
+    "summary": "Rename a project.",
+    "examplePrompts": [
+      "Rename this project to Tower Study Final",
+      "Change the name of project floorkey_123",
+      "Give this project a new name\n\n# Example\n```ts\nconst { projectId } = await snaptrude.workspace.projects.rename(\n\"floorkey_123\",\n\"Tower Study Final\",\n)\n```"
+    ],
+    "argsType": "string",
+    "resultType": "PluginWorkspaceProjectsRenameResult"
+  },
+  {
+    "path": "workspace.teams.get",
+    "namespace": "workspace.teams",
+    "summary": "Get a single team by id.",
+    "examplePrompts": [
+      "Get the team with id team_1",
+      "Look up a team by its id",
+      "What is the name of this team?\n\n# Example\n```ts\nconst team = await snaptrude.workspace.teams.get(\"team_1\")\nif (team) console.log(team.name)\n```"
+    ],
+    "argsType": "string",
+    "resultType": "PluginWorkspaceTeamsGetResult"
+  },
+  {
+    "path": "workspace.teams.list",
+    "namespace": "workspace.teams",
+    "summary": "List the teams the user belongs to.",
+    "examplePrompts": [
+      "List all my teams",
+      "Which teams am I a member of?",
+      "Show every team I can access\n\n# Example\n```ts\nconst { teams } = await snaptrude.workspace.teams.list()\nfor (const t of teams) console.log(t.id, t.name)\n```"
+    ],
+    "argsType": null,
+    "resultType": "PluginWorkspaceTeamsListResult"
+  },
+  {
+    "path": "workspace.teams.listMembers",
+    "namespace": "workspace.teams",
+    "summary": "List the members of a team.",
+    "examplePrompts": [
+      "List the members of the Acme team",
+      "Who is on team_1?",
+      "How many people are in this team?\n\n# Example\n```ts\nconst { members } = await snaptrude.workspace.teams.listMembers(\"team_1\")\nfor (const m of members) console.log(m.name, m.email)\n```"
+    ],
+    "argsType": "string",
+    "resultType": "PluginWorkspaceTeamsListMembersResult"
   }
 ]