@snaptrude/plugin-core 0.7.0 → 0.7.1

package/api-manifest.json

@@ -1,244 +1,4 @@
 [
-  {
-    "path": "analysis.heatmaps.isActive",
-    "namespace": "analysis.heatmaps",
-    "summary": "Is a plugin heatmap currently showing?",
-    "examplePrompts": [
-      "Is my heatmap still showing?",
-      "Check whether the custom heatmap is active",
-      "Do I need to re-render the wind overlay?\n\n# Example\n```ts\nif (!(await snaptrude.analysis.heatmaps.isActive())) {\nawait snaptrude.analysis.heatmaps.renderGrid(cells, 2)\n}\n```"
-    ],
-    "argsType": null,
-    "resultType": "boolean"
-  },
-  {
-    "path": "analysis.heatmaps.renderGrid",
-    "namespace": "analysis.heatmaps",
-    "summary": "Render a grid heatmap — a coloured mesh from point samples.",
-    "examplePrompts": [
-      "Overlay my CFD wind simulation results on the site",
-      "Render a noise-level grid around the building",
-      "Show these sampled microclimate values as a colored grid\n\n# Example\n```ts\n// World coordinates are y-up: a ground-level field varies in x/z at y = 0.\nawait snaptrude.analysis.heatmaps.renderGrid(\nsamples.map((s) => ({ position: { x: s.x, y: 0, z: s.z }, value: s.windSpeed })),\n2, // 2-unit square cells\n{ title: \"Wind speed\", unit: \"m/s\", colors: [\"#0000ff\", \"#00ff00\", \"#ff0000\"] },\n)\n```"
-    ],
-    "argsType": "PluginAnalysisHeatmapGridCell[]",
-    "resultType": "PluginAnalysisHeatmapsRenderResult"
-  },
-  {
-    "path": "analysis.heatmaps.renderSpaces",
-    "namespace": "analysis.heatmaps",
-    "summary": "Render a per-space heatmap — one flat colour per space's top face.",
-    "examplePrompts": [
-      "Color each room by its occupancy count",
-      "Show my energy simulation results as a heatmap per space",
-      "Paint the rooms red to blue by temperature\n\n# Example\n```ts\nconst spaces = await snaptrude.design.query.listSpaces()\nawait snaptrude.analysis.heatmaps.renderSpaces(\nspaces.map((space) => ({ space, value: occupancy[space] ?? 0 })),\n{ title: \"Occupancy\", unit: \"people\", min: 0, max: 50 },\n)\n```"
-    ],
-    "argsType": "PluginAnalysisHeatmapSpaceEntry[]",
-    "resultType": "PluginAnalysisHeatmapsRenderResult"
-  },
-  {
-    "path": "analysis.heatmaps.reset",
-    "namespace": "analysis.heatmaps",
-    "summary": "Clear the plugin heatmap from the scene.",
-    "examplePrompts": [
-      "Clear my custom heatmap",
-      "Remove the wind overlay from the model",
-      "Reset the plugin heatmap view\n\n# Example\n```ts\nawait snaptrude.analysis.heatmaps.reset()\n```"
-    ],
-    "argsType": null,
-    "resultType": "boolean"
-  },
-  {
-    "path": "analysis.illuminance.cancel",
-    "namespace": "analysis.illuminance",
-    "summary": "Cancel the in-flight illuminance run.",
-    "examplePrompts": [
-      "Cancel the illuminance analysis",
-      "Stop the running daylight computation",
-      "Abort the lux study\n\n# Example\n```ts\nawait snaptrude.analysis.illuminance.cancel()\n```"
-    ],
-    "argsType": null,
-    "resultType": "boolean"
-  },
-  {
-    "path": "analysis.illuminance.compute",
-    "namespace": "analysis.illuminance",
-    "summary": "Start a daylight-illuminance run for a date range.",
-    "examplePrompts": [
-      "Run a daylight illuminance analysis for December",
-      "Compute the lux levels inside the building for winter",
-      "How much daylight do the interior floors get?\n\n# Example\n```ts\nconst { success } = await snaptrude.analysis.illuminance.compute(\n\"2026-12-01\",\n\"2026-12-31\",\n)\n// poll until the heatmap is rendered\nlet job = await snaptrude.analysis.illuminance.get()\nwhile (job?.status === \"running\") {\nawait new Promise((r) => setTimeout(r, 5000))\njob = await snaptrude.analysis.illuminance.get()\n}\n```"
-    ],
-    "argsType": "string",
-    "resultType": "PluginAnalysisComputeResult"
-  },
-  {
-    "path": "analysis.illuminance.get",
-    "namespace": "analysis.illuminance",
-    "summary": "Get the state of the illuminance study.",
-    "examplePrompts": [
-      "Is the illuminance analysis done?",
-      "Check the status of the daylight lux run",
-      "What date range was the illuminance heatmap computed for?\n\n# Example\n```ts\nconst job = await snaptrude.analysis.illuminance.get()\nif (job?.status === \"active\") console.log(job.startDate, job.endDate)\n```"
-    ],
-    "argsType": null,
-    "resultType": "PluginAnalysisJobStateResult"
-  },
-  {
-    "path": "analysis.illuminance.reset",
-    "namespace": "analysis.illuminance",
-    "summary": "Clear the illuminance heatmap from the scene.",
-    "examplePrompts": [
-      "Clear the illuminance heatmap",
-      "Remove the daylight lux colours from the model",
-      "Reset the illuminance analysis view\n\n# Example\n```ts\nawait snaptrude.analysis.illuminance.reset()\n```"
-    ],
-    "argsType": null,
-    "resultType": "boolean"
-  },
-  {
-    "path": "analysis.shadows.disable",
-    "namespace": "analysis.shadows",
-    "summary": "Turn real-time sun shadows OFF.",
-    "examplePrompts": [
-      "Turn off shadows",
-      "Hide the sun shadows",
-      "Disable shadow rendering in the scene\n\n# Example\n```ts\nawait snaptrude.analysis.shadows.disable()\n```"
-    ],
-    "argsType": null,
-    "resultType": "boolean"
-  },
-  {
-    "path": "analysis.shadows.enable",
-    "namespace": "analysis.shadows",
-    "summary": "Turn real-time sun shadows ON, optionally at a specific date and time.",
-    "examplePrompts": [
-      "Turn on shadows",
-      "Show the shadows at 3pm on June 21st",
-      "Enable sun shadows for the summer solstice afternoon\n\n# Example\n```ts\nawait snaptrude.analysis.shadows.enable({ dateTime: \"2026-06-21T15:00\" })\n```"
-    ],
-    "argsType": "PluginAnalysisShadowsEnableOptions",
-    "resultType": "boolean"
-  },
-  {
-    "path": "analysis.shadows.getDateTime",
-    "namespace": "analysis.shadows",
-    "summary": "Get the sun's current date and time.",
-    "examplePrompts": [
-      "What date and time are the shadows set to?",
-      "Get the current sun position date",
-      "Which time of day is the shadow study showing?\n\n# Example\n```ts\nconst dateTime = await snaptrude.analysis.shadows.getDateTime()\n```"
-    ],
-    "argsType": null,
-    "resultType": "PluginAnalysisShadowsDateTimeResult"
-  },
-  {
-    "path": "analysis.shadows.isEnabled",
-    "namespace": "analysis.shadows",
-    "summary": "Whether real-time sun shadows are currently enabled.",
-    "examplePrompts": [
-      "Are shadows on?",
-      "Check whether sun shadows are enabled",
-      "Is the scene showing shadows right now?\n\n# Example\n```ts\nconst on = await snaptrude.analysis.shadows.isEnabled()\n```"
-    ],
-    "argsType": null,
-    "resultType": "boolean"
-  },
-  {
-    "path": "analysis.shadows.setDateTime",
-    "namespace": "analysis.shadows",
-    "summary": "Move the sun to a specific date and time.",
-    "examplePrompts": [
-      "Set the shadow time to 9:30 am on the winter solstice",
-      "Move the sun to noon on March 1st",
-      "Change the shadow study date to December 21\n\n# Example\n```ts\nconst applied = await snaptrude.analysis.shadows.setDateTime(\"2026-12-21T09:30\")\nconsole.log(applied) // \"2026-12-21T09:30\" (snapped to the half-hour grid)\n```"
-    ],
-    "argsType": "string",
-    "resultType": "PluginAnalysisShadowsDateTimeResult"
-  },
-  {
-    "path": "analysis.sunlightHours.cancel",
-    "namespace": "analysis.sunlightHours",
-    "summary": "Cancel the in-flight sunlight-hours run.",
-    "examplePrompts": [
-      "Cancel the sunlight analysis",
-      "Stop the running sunlight hours computation",
-      "Abort the sun study\n\n# Example\n```ts\nawait snaptrude.analysis.sunlightHours.cancel()\n```"
-    ],
-    "argsType": null,
-    "resultType": "boolean"
-  },
-  {
-    "path": "analysis.sunlightHours.compute",
-    "namespace": "analysis.sunlightHours",
-    "summary": "Start a direct-sunlight-hours run for a date range.",
-    "examplePrompts": [
-      "Run a sunlight hours analysis for June",
-      "Compute direct sunlight hours between March and September",
-      "How much sun does my building get over the summer?\n\n# Example\n```ts\nconst { success } = await snaptrude.analysis.sunlightHours.compute(\n\"2026-06-01\",\n\"2026-06-30\",\n)\n// poll until the heatmap is rendered\nlet job = await snaptrude.analysis.sunlightHours.get()\nwhile (job?.status === \"running\") {\nawait new Promise((r) => setTimeout(r, 5000))\njob = await snaptrude.analysis.sunlightHours.get()\n}\n```"
-    ],
-    "argsType": "string",
-    "resultType": "PluginAnalysisComputeResult"
-  },
-  {
-    "path": "analysis.sunlightHours.get",
-    "namespace": "analysis.sunlightHours",
-    "summary": "Get the state of the sunlight-hours study.",
-    "examplePrompts": [
-      "Is the sunlight analysis done?",
-      "Check the status of the sunlight hours run",
-      "What date range was the sunlight heatmap computed for?\n\n# Example\n```ts\nconst job = await snaptrude.analysis.sunlightHours.get()\nif (job?.status === \"active\") console.log(job.startDate, job.endDate)\n```"
-    ],
-    "argsType": null,
-    "resultType": "PluginAnalysisJobStateResult"
-  },
-  {
-    "path": "analysis.sunlightHours.reset",
-    "namespace": "analysis.sunlightHours",
-    "summary": "Clear the sunlight-hours heatmap from the scene.",
-    "examplePrompts": [
-      "Clear the sunlight heatmap",
-      "Remove the sun hours colours from the model",
-      "Reset the sunlight analysis view\n\n# Example\n```ts\nawait snaptrude.analysis.sunlightHours.reset()\n```"
-    ],
-    "argsType": null,
-    "resultType": "boolean"
-  },
-  {
-    "path": "analysis.sunpath.disable",
-    "namespace": "analysis.sunpath",
-    "summary": "Turn the sun-path diagram overlay OFF.",
-    "examplePrompts": [
-      "Hide the sun path diagram",
-      "Turn off the sunpath overlay",
-      "Remove the sun trajectory arcs from the scene\n\n# Example\n```ts\nawait snaptrude.analysis.sunpath.disable()\n```"
-    ],
-    "argsType": null,
-    "resultType": "boolean"
-  },
-  {
-    "path": "analysis.sunpath.enable",
-    "namespace": "analysis.sunpath",
-    "summary": "Turn the sun-path diagram overlay ON.",
-    "examplePrompts": [
-      "Show the sun path diagram",
-      "Turn on the sunpath overlay",
-      "Visualize the sun's trajectory over my building\n\n# Example\n```ts\nawait snaptrude.analysis.sunpath.enable()\nconst active = await snaptrude.analysis.sunpath.isActive() // true\n```"
-    ],
-    "argsType": null,
-    "resultType": "boolean"
-  },
-  {
-    "path": "analysis.sunpath.isActive",
-    "namespace": "analysis.sunpath",
-    "summary": "Whether the sun-path diagram overlay is currently active.",
-    "examplePrompts": [
-      "Is the sun path diagram on?",
-      "Check whether the sunpath overlay is active",
-      "Am I looking at the sun trajectory right now?\n\n# Example\n```ts\nif (!(await snaptrude.analysis.sunpath.isActive())) {\nawait snaptrude.analysis.sunpath.enable()\n}\n```"
-    ],
-    "argsType": null,
-    "resultType": "boolean"
-  },
   {
     "path": "core.buildings.copy",
     "namespace": "core.buildings",
@@ -2051,585 +1811,160 @@
     "resultType": "PluginHistoryStepResult"
   },
   {
-    "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.",
+    "path": "core.layers.get",
+    "namespace": "core.layers",
+    "summary": "Get a single drawing layer by id.",
     "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```"
+      "Get the drawing layer with id ly_5",
+      "Is layer ly_5 hidden or locked?",
+      "Look up a single drawing layer by its id\n\n# Example\n```ts\nconst layer = await snaptrude.core.layers.get(\"ly_5\")\nif (layer) console.log(layer.name, layer.hidden, layer.locked)\n```"
     ],
-    "argsType": "CadJsonInput",
-    "resultType": "UnderlayHandle"
+    "argsType": "string",
+    "resultType": "PluginCoreLayersGetResult"
   },
   {
-    "path": "core.io.import.dwg",
-    "namespace": "core.io.import",
-    "summary": "Import a **DWG** CAD drawing as a scene underlay. `.dwg` only (no DXF).",
+    "path": "core.layers.getActive",
+    "namespace": "core.layers",
+    "summary": "Get the active drawing layer of a storey.",
     "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```"
+      "Which drawing layer is active on this storey?",
+      "Get the current layer on storey st_2",
+      "What layer am I drawing on?\n\n# Example\n```ts\nconst active = await snaptrude.core.layers.getActive(\"st_2\")\nif (active) console.log(active.name)\n```"
     ],
     "argsType": "string",
-    "resultType": "ImportJobHandle"
+    "resultType": "PluginCoreLayersGetActiveResult"
   },
   {
-    "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.",
+    "path": "core.layers.list",
+    "namespace": "core.layers",
+    "summary": "List the drawing layers of a storey.",
     "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```"
+      "List the drawing layers on this storey",
+      "Show all the PDF underlays on storey st_2",
+      "What CAD layers are on the ground floor?\n\n# Example\n```ts\nconst { layers } = await snaptrude.core.layers.list(\"st_2\")\nfor (const l of layers) console.log(l.name, l.layerType, l.hidden)\n```"
     ],
     "argsType": "string",
-    "resultType": "UnderlayHandle"
+    "resultType": "PluginCoreLayersListResult"
   },
   {
-    "path": "core.io.import.model",
-    "namespace": "core.io.import",
-    "summary": "Import a **3D model** file and place it in the scene as a component.",
+    "path": "core.layers.setActive",
+    "namespace": "core.layers",
+    "summary": "Make a drawing layer the active layer of its storey.",
     "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```"
+      "Draw on layer ly_5",
+      "Make this the active layer",
+      "Switch the active layer to the CAD underlay\n\n# Example\n```ts\nawait snaptrude.core.layers.setActive(\"ly_5\")\n```"
     ],
     "argsType": "string",
-    "resultType": "ComponentHandle"
+    "resultType": "PluginCoreLayersSetActiveResult"
   },
   {
-    "path": "core.io.import.pdf",
-    "namespace": "core.io.import",
-    "summary": "Import one page of a PDF as a scene **underlay** (a traceable reference plane).",
+    "path": "core.layers.update",
+    "namespace": "core.layers",
+    "summary": "Update a drawing layer's visibility.",
     "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```"
+      "Hide the PDF underlay layer",
+      "Show the CAD layer again",
+      "Hide layer ly_5\n\n# Example\n```ts\nconst layer = await snaptrude.core.layers.update(\"ly_5\", true)\n```"
     ],
     "argsType": "string",
-    "resultType": "UnderlayHandle"
+    "resultType": "PluginCoreLayersUpdateResult"
   },
   {
-    "path": "core.io.import.terrain",
-    "namespace": "core.io.import",
-    "summary": "Import **site terrain** for a location — Mapbox topography (elevation + satellite/streets imagery, optional neighborhood buildings and parcels).",
-    "examplePrompts": [
-      "Import the site terrain for this location, about 500m across",
-      "Load the topography at 40.7128, -74.0060 for a 300 by 300 meter site",
-      "Bring in satellite terrain for the site with the surrounding buildings",
-      "Add site elevation for a 1km by 1km area at these coordinates\n\n# Example\n```ts\n// 300m × 300m site with elevation + satellite imagery.\nconst terrain = await snaptrude.core.io.import.terrain(\n40.7128,  // lat\n-74.006,  // lng\n300,      // width  (metres)\n300,      // length (metres)\ntrue,     // elevation\ntrue,     // satellite\n)\n```"
-    ],
-    "argsType": "number",
-    "resultType": "TerrainHandle"
+    "path": "core.math.quat.components",
+    "namespace": "core.math.quat",
+    "summary": "Read the primitive `{ x, y, z, w }` components of a quaternion handle.",
+    "examplePrompts": [],
+    "argsType": "QuatHandle",
+    "resultType": "QuatComponents"
   },
   {
-    "path": "core.io.job.getError",
-    "namespace": "core.io.job",
-    "summary": "The failure message if the job's status is `\"failed\"`; otherwise `null`.",
-    "examplePrompts": [
-      "Why did my DWG import fail?",
-      "What went wrong with the CAD import?",
-      "Show the error from the failed import job",
-      "Did the import error out, and why?\n\n# Example\n```ts\nconst job = await snaptrude.core.io.import.dwg(url, 1)\nif ((await snaptrude.core.io.job.getStatus(job)) === \"failed\") {\nconsole.error(await snaptrude.core.io.job.getError(job))\n}\n```"
-    ],
-    "argsType": "ImportJobHandle",
-    "resultType": "string | null"
+    "path": "core.math.quat.conjugate",
+    "namespace": "core.math.quat",
+    "summary": "Compute the conjugate of a quaternion (negated vector part).",
+    "examplePrompts": [],
+    "argsType": "QuatHandle",
+    "resultType": "QuatHandle"
   },
   {
-    "path": "core.io.job.getResult",
-    "namespace": "core.io.job",
-    "summary": "The imported result once the job is complete — the placed {@linkcode UnderlayHandle}. Returns `null` while the job is still pending/processing or if it failed (check {@link PluginCoreIoJobApi.getError}).",
-    "examplePrompts": [
-      "Get the underlay from my finished DWG import",
-      "Give me the result of the CAD import job",
-      "Fetch the imported CAD sketch once it's ready",
-      "Return the handle for the completed import\n\n# Example\n```ts\nconst job = await snaptrude.core.io.import.dwg(url, 1)\nconst deadline = Date.now() + 5 * 60_000\nwhile (!(await snaptrude.core.io.job.isComplete(job))) {\nif (Date.now() > deadline) throw new Error(\"DWG import timed out\")\nawait new Promise((r) => setTimeout(r, 2000))\n}\n// DWG results are CAD underlays (CAD scaling isn't supported); manage them\n// via core.io.underlay.* (list / setOpacity / delete).\nconst cad = await snaptrude.core.io.job.getResult(job)\nif (cad) console.log(\"import complete:\", cad)\n```"
-    ],
-    "argsType": "ImportJobHandle",
-    "resultType": "UnderlayHandle | null"
+    "path": "core.math.quat.dot",
+    "namespace": "core.math.quat",
+    "summary": "Compute the dot product of two quaternions.",
+    "examplePrompts": [],
+    "argsType": "QuatHandle",
+    "resultType": "number"
   },
   {
-    "path": "core.io.job.getStatus",
-    "namespace": "core.io.job",
-    "summary": "Read a job's current status: `\"pending\"` (queued), `\"processing\"` (running), `\"complete\"` (result ready), or `\"failed\"`.",
-    "examplePrompts": [
-      "What's the status of my DWG import?",
-      "Is the CAD import still processing?",
-      "Check where the import job is up to",
-      "Did the import job fail?\n\n# Example\n```ts\nconst job = await snaptrude.core.io.import.dwg(url, 1)\nconsole.log(await snaptrude.core.io.job.getStatus(job)) // \"processing\"\n```"
-    ],
-    "argsType": "ImportJobHandle",
-    "resultType": "ImportJobStatus"
+    "path": "core.math.quat.equals",
+    "namespace": "core.math.quat",
+    "summary": "Test whether two quaternions have exactly equal components.",
+    "examplePrompts": [],
+    "argsType": "QuatHandle",
+    "resultType": "boolean"
   },
   {
-    "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",
+    "path": "core.math.quat.equalsApprox",
+    "namespace": "core.math.quat",
+    "summary": "Test whether two quaternions are equal within a tolerance `epsilon` (default `1e-6`).",
+    "examplePrompts": [],
+    "argsType": "QuatHandle",
     "resultType": "boolean"
   },
   {
-    "path": "core.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.math.quat.fromAxisAngle",
+    "namespace": "core.math.quat",
+    "summary": "Build a quaternion from a rotation axis and an angle in radians.",
+    "examplePrompts": [],
+    "argsType": "Vec3Handle",
+    "resultType": "QuatHandle"
   },
   {
-    "path": "core.io.query.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.math.quat.fromEuler",
+    "namespace": "core.math.quat",
+    "summary": "Build a quaternion from Euler angles in radians.",
+    "examplePrompts": [],
+    "argsType": "number",
+    "resultType": "QuatHandle"
   },
   {
-    "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"
-    ],
+    "path": "core.math.quat.identity",
+    "namespace": "core.math.quat",
+    "summary": "Return the identity quaternion (no rotation).",
+    "examplePrompts": [],
     "argsType": null,
-    "resultType": "void"
+    "resultType": "QuatHandle"
   },
   {
-    "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.math.quat.inverse",
+    "namespace": "core.math.quat",
+    "summary": "Compute the inverse quaternion — the rotation that undoes `q`.",
+    "examplePrompts": [],
+    "argsType": "QuatHandle",
+    "resultType": "QuatHandle"
   },
   {
-    "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.math.quat.length",
+    "namespace": "core.math.quat",
+    "summary": "Compute the magnitude (norm) of a quaternion.",
+    "examplePrompts": [],
+    "argsType": "QuatHandle",
+    "resultType": "number"
   },
   {
-    "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.math.quat.multiply",
+    "namespace": "core.math.quat",
+    "summary": "Compose two rotations with the Hamilton product `a * b` (apply `b` then `a`).",
+    "examplePrompts": [],
+    "argsType": "QuatHandle",
+    "resultType": "QuatHandle"
   },
   {
-    "path": "core.io.terrain.enableSatellite",
-    "namespace": "core.io.terrain",
-    "summary": "Turn satellite imagery ON. Undoable.",
-    "examplePrompts": [
-      "Show satellite imagery on the site",
-      "Enable the satellite texture",
-      "Turn on aerial imagery",
-      "Drape satellite over the terrain"
-    ],
-    "argsType": null,
-    "resultType": "void"
-  },
-  {
-    "path": "core.io.terrain.exists",
-    "namespace": "core.io.terrain",
-    "summary": "Whether the project has a site terrain.",
-    "examplePrompts": [
-      "Does this project have site terrain?",
-      "Is there a terrain imported?",
-      "Check if the site topography exists",
-      "Has a terrain been added yet?\n\n# Example\n```ts\nif (!(await snaptrude.core.io.terrain.exists())) {\nawait snaptrude.core.io.import.terrain(40.7128, -74.006, 300, 300)\n}\n```"
-    ],
-    "argsType": null,
-    "resultType": "boolean"
-  },
-  {
-    "path": "core.io.terrain.get",
-    "namespace": "core.io.terrain",
-    "summary": "Resolve the project's terrain handle, or `null` if there is none. The same handle {@link core.io.import.terrain} returns — use it to obtain the handle without re-importing.",
-    "examplePrompts": [
-      "Get the terrain handle",
-      "Give me the site terrain",
-      "Fetch the current terrain",
-      "Return the topography handle if it exists"
-    ],
-    "argsType": null,
-    "resultType": "TerrainHandle | null"
-  },
-  {
-    "path": "core.io.terrain.getDatum",
-    "namespace": "core.io.terrain",
-    "summary": "Read the terrain's current vertical position (world Y, internal units). `null` if there is no terrain. Import places the terrain so its highest point sits at `y = 0`, so a never-shifted terrain reads a negative baseline, not `0`; each {@link PluginCoreIoTerrainApi.setDatum} shift moves this value.",
-    "examplePrompts": [
-      "What's the terrain's datum?",
-      "Read the current site elevation reference",
-      "Get the terrain vertical offset",
-      "How far has the datum been shifted?"
-    ],
-    "argsType": null,
-    "resultType": "number | null"
-  },
-  {
-    "path": "core.io.terrain.getOpacity",
-    "namespace": "core.io.terrain",
-    "summary": "Read the terrain opacity, `0`..`1`, or `null` if no terrain.",
-    "examplePrompts": [],
-    "argsType": null,
-    "resultType": "number | null"
-  },
-  {
-    "path": "core.io.terrain.getReport",
-    "namespace": "core.io.terrain",
-    "summary": "The terrain cut/fill earthwork report — cut, fill, and net volumes — or `null` if there is no terrain.",
-    "examplePrompts": [
-      "What are the cut and fill volumes for the site?",
-      "Get the terrain earthwork report",
-      "How much cut and fill does the grading need?",
-      "Show the net volume of the terrain edits\n\n# Example\n```ts\nconst r = await snaptrude.core.io.terrain.getReport()\nif (r) console.log(`cut ${r.cutVolume}, fill ${r.fillVolume}, net ${r.netVolume}`)\n```"
-    ],
-    "argsType": null,
-    "resultType": "TerrainReport | null"
-  },
-  {
-    "path": "core.io.terrain.isElevationEnabled",
-    "namespace": "core.io.terrain",
-    "summary": "Whether terrain elevation (DEM height) is on. `null` if no terrain.",
-    "examplePrompts": [],
-    "argsType": null,
-    "resultType": "boolean | null"
-  },
-  {
-    "path": "core.io.terrain.isSatelliteEnabled",
-    "namespace": "core.io.terrain",
-    "summary": "Whether satellite imagery is draped on the terrain. `null` if no terrain.",
-    "examplePrompts": [],
-    "argsType": null,
-    "resultType": "boolean | null"
-  },
-  {
-    "path": "core.io.terrain.setDatum",
-    "namespace": "core.io.terrain",
-    "summary": "Shift the terrain's **datum** — move the whole terrain vertically DOWN by `offset` (internal units) from its current position; pass a negative value to raise it. Undoable.",
-    "examplePrompts": [
-      "Shift the terrain datum down by 12",
-      "Lower the site terrain by 10",
-      "Raise the terrain a little",
-      "Nudge the terrain datum down\n\n# Example\n```ts\nawait snaptrude.core.io.terrain.setDatum(12)   // shift terrain down by 12 (relative)\n```"
-    ],
-    "argsType": "number",
-    "resultType": "void"
-  },
-  {
-    "path": "core.io.terrain.setOpacity",
-    "namespace": "core.io.terrain",
-    "summary": "Set the terrain opacity (`0` transparent .. `1` opaque). Undoable.",
-    "examplePrompts": [
-      "Fade the terrain to 50%",
-      "Make the site semi-transparent",
-      "Set terrain opacity to 0.3",
-      "Dim the topography\n\n# Example\n```ts\nawait snaptrude.core.io.terrain.setOpacity(0.5)\n```"
-    ],
-    "argsType": "number",
-    "resultType": "void"
-  },
-  {
-    "path": "core.io.underlay.delete",
-    "namespace": "core.io.underlay",
-    "summary": "Delete an underlay from the scene (and its backend record). Applies to image, PDF, and CAD underlays.",
-    "examplePrompts": [
-      "Delete this floor plan underlay",
-      "Remove the imported PDF from the scene",
-      "Get rid of the CAD sketch I traced over",
-      "Clear the reference image off storey 1\n\n# Example\n```ts\nconst [first] = await snaptrude.core.io.underlay.list(1)\nif (first) await snaptrude.core.io.underlay.delete(first)\n```"
-    ],
-    "argsType": "UnderlayHandle",
-    "resultType": "void"
-  },
-  {
-    "path": "core.io.underlay.getBounds",
-    "namespace": "core.io.underlay",
-    "summary": "Read an underlay's world-space bounding box (image, PDF, or CAD). `null` if the underlay no longer resolves or has no measurable mesh. Useful for fitting drawn geometry to a reference, or computing a plan size before scaling.",
-    "examplePrompts": [
-      "How big is this floor plan in the scene?",
-      "Get the bounding box of the underlay",
-      "What's the extent of the imported PDF?",
-      "Measure the CAD sketch's size\n\n# Example\n```ts\nconst bb = await snaptrude.core.io.underlay.getBounds(plan)\nif (bb) console.log(`width ${bb.max.x - bb.min.x}`)\n```"
-    ],
-    "argsType": "UnderlayHandle",
-    "resultType": "BBoxComponents | null"
-  },
-  {
-    "path": "core.io.underlay.getOpacity",
-    "namespace": "core.io.underlay",
-    "summary": "Read an underlay's opacity (`0`..`1`), or `null` if it has no material.",
-    "examplePrompts": [
-      "How transparent is this underlay?",
-      "Get the opacity of the floor plan",
-      "What's the fade level on the reference image?",
-      "Read the underlay's opacity\n\n# Example\n```ts\nconst o = await snaptrude.core.io.underlay.getOpacity(plan)\n```"
-    ],
-    "argsType": "UnderlayHandle",
-    "resultType": "number | null"
-  },
-  {
-    "path": "core.io.underlay.getScale",
-    "namespace": "core.io.underlay",
-    "summary": "Read an underlay's scale. Works for **image and PDF** underlays. Returns `null` for CAD (scaling not supported) or if the handle no longer resolves.",
-    "examplePrompts": [
-      "What scale is this floor plan set to?",
-      "Get the current and original scale of the underlay",
-      "How much has this image been scaled since import?",
-      "Read the scale factor of the reference plan\n\n# Example\n```ts\nconst s = await snaptrude.core.io.underlay.getScale(plan)\nif (s) console.log(`scale ${s.scaleFactor} (was ${s.initialScaleFactor})`)\n```"
-    ],
-    "argsType": "UnderlayHandle",
-    "resultType": "{ scaleFactor: number; initialScaleFactor: number } | null"
-  },
-  {
-    "path": "core.io.underlay.list",
-    "namespace": "core.io.underlay",
-    "summary": "List the underlays in the scene, optionally limited to one storey.",
-    "examplePrompts": [
-      "List all the reference underlays in the model",
-      "What underlays are on the ground floor?",
-      "Show every imported floor plan and PDF",
-      "How many trace-over images are on storey 2?\n\n# Example\n```ts\nconst underlays = await snaptrude.core.io.underlay.list(1)\nconsole.log(`${underlays.length} underlays on storey 1`)\n```"
-    ],
-    "argsType": "number",
-    "resultType": "UnderlayHandle[]"
-  },
-  {
-    "path": "core.io.underlay.resetScale",
-    "namespace": "core.io.underlay",
-    "summary": "Reset an underlay's scale back to its import-time size (image or PDF; CAD scaling is not supported — throws). Equivalent to `setScale(underlay, 1)`.",
-    "examplePrompts": [
-      "Reset this floor plan's scale to how it was imported",
-      "Undo the scaling on the underlay",
-      "Put the reference image back to its original size",
-      "Restore the plan's default scale\n\n# Example\n```ts\nawait snaptrude.core.io.underlay.resetScale(plan)\n```"
-    ],
-    "argsType": "UnderlayHandle",
-    "resultType": "{ scaleFactor: number }"
-  },
-  {
-    "path": "core.io.underlay.setOpacity",
-    "namespace": "core.io.underlay",
-    "summary": "Set an underlay's opacity (`0` = transparent .. `1` = opaque). Undoable. The engine keeps underlays faintly visible: values below `0.01` clamp to `0.01`, so `setOpacity(u, 0)` reads back as `0.01`, not `0`.",
-    "examplePrompts": [
-      "Fade this floor plan to 30% so I can see through it",
-      "Make the underlay half transparent",
-      "Set the reference image opacity to 0.2",
-      "Dim the trace-over plan\n\n# Example\n```ts\nawait snaptrude.core.io.underlay.setOpacity(plan, 0.3)\n```"
-    ],
-    "argsType": "UnderlayHandle",
-    "resultType": "void"
-  },
-  {
-    "path": "core.io.underlay.setScale",
-    "namespace": "core.io.underlay",
-    "summary": "Set an underlay's scale — the **calibration** step after import. Works for **image and PDF** underlays (CAD scaling is not supported — throws).",
-    "examplePrompts": [
-      "Scale this floor plan so it's 50 meters across",
-      "Set the plan size to 30m — it's imported too small",
-      "Make the reference image twice its imported size",
-      "Calibrate the PDF: the site is 120 meters long\n\n# Example\n```ts\n// Absolute factor — set the underlay to 2× its imported size:\nawait snaptrude.core.io.underlay.setScale(plan, 2)\n\n// Fit to a real-world size — make the plan's longest side 50 project-units:\nawait snaptrude.core.io.underlay.setScale(plan, { planSize: 50 })\n```"
-    ],
-    "argsType": "UnderlayHandle",
-    "resultType": "{ scaleFactor: number }"
-  },
-  {
-    "path": "core.layers.get",
-    "namespace": "core.layers",
-    "summary": "Get a single drawing layer by id.",
-    "examplePrompts": [
-      "Get the drawing layer with id ly_5",
-      "Is layer ly_5 hidden or locked?",
-      "Look up a single drawing layer by its id\n\n# Example\n```ts\nconst layer = await snaptrude.core.layers.get(\"ly_5\")\nif (layer) console.log(layer.name, layer.hidden, layer.locked)\n```"
-    ],
-    "argsType": "string",
-    "resultType": "PluginCoreLayersGetResult"
-  },
-  {
-    "path": "core.layers.getActive",
-    "namespace": "core.layers",
-    "summary": "Get the active drawing layer of a storey.",
-    "examplePrompts": [
-      "Which drawing layer is active on this storey?",
-      "Get the current layer on storey st_2",
-      "What layer am I drawing on?\n\n# Example\n```ts\nconst active = await snaptrude.core.layers.getActive(\"st_2\")\nif (active) console.log(active.name)\n```"
-    ],
-    "argsType": "string",
-    "resultType": "PluginCoreLayersGetActiveResult"
-  },
-  {
-    "path": "core.layers.list",
-    "namespace": "core.layers",
-    "summary": "List the drawing layers of a storey.",
-    "examplePrompts": [
-      "List the drawing layers on this storey",
-      "Show all the PDF underlays on storey st_2",
-      "What CAD layers are on the ground floor?\n\n# Example\n```ts\nconst { layers } = await snaptrude.core.layers.list(\"st_2\")\nfor (const l of layers) console.log(l.name, l.layerType, l.hidden)\n```"
-    ],
-    "argsType": "string",
-    "resultType": "PluginCoreLayersListResult"
-  },
-  {
-    "path": "core.layers.setActive",
-    "namespace": "core.layers",
-    "summary": "Make a drawing layer the active layer of its storey.",
-    "examplePrompts": [
-      "Draw on layer ly_5",
-      "Make this the active layer",
-      "Switch the active layer to the CAD underlay\n\n# Example\n```ts\nawait snaptrude.core.layers.setActive(\"ly_5\")\n```"
-    ],
-    "argsType": "string",
-    "resultType": "PluginCoreLayersSetActiveResult"
-  },
-  {
-    "path": "core.layers.update",
-    "namespace": "core.layers",
-    "summary": "Update a drawing layer's visibility.",
-    "examplePrompts": [
-      "Hide the PDF underlay layer",
-      "Show the CAD layer again",
-      "Hide layer ly_5\n\n# Example\n```ts\nconst layer = await snaptrude.core.layers.update(\"ly_5\", true)\n```"
-    ],
-    "argsType": "string",
-    "resultType": "PluginCoreLayersUpdateResult"
-  },
-  {
-    "path": "core.math.quat.components",
-    "namespace": "core.math.quat",
-    "summary": "Read the primitive `{ x, y, z, w }` components of a quaternion handle.",
-    "examplePrompts": [],
-    "argsType": "QuatHandle",
-    "resultType": "QuatComponents"
-  },
-  {
-    "path": "core.math.quat.conjugate",
-    "namespace": "core.math.quat",
-    "summary": "Compute the conjugate of a quaternion (negated vector part).",
-    "examplePrompts": [],
-    "argsType": "QuatHandle",
-    "resultType": "QuatHandle"
-  },
-  {
-    "path": "core.math.quat.dot",
-    "namespace": "core.math.quat",
-    "summary": "Compute the dot product of two quaternions.",
-    "examplePrompts": [],
-    "argsType": "QuatHandle",
-    "resultType": "number"
-  },
-  {
-    "path": "core.math.quat.equals",
-    "namespace": "core.math.quat",
-    "summary": "Test whether two quaternions have exactly equal components.",
-    "examplePrompts": [],
-    "argsType": "QuatHandle",
-    "resultType": "boolean"
-  },
-  {
-    "path": "core.math.quat.equalsApprox",
-    "namespace": "core.math.quat",
-    "summary": "Test whether two quaternions are equal within a tolerance `epsilon` (default `1e-6`).",
-    "examplePrompts": [],
-    "argsType": "QuatHandle",
-    "resultType": "boolean"
-  },
-  {
-    "path": "core.math.quat.fromAxisAngle",
-    "namespace": "core.math.quat",
-    "summary": "Build a quaternion from a rotation axis and an angle in radians.",
-    "examplePrompts": [],
-    "argsType": "Vec3Handle",
-    "resultType": "QuatHandle"
-  },
-  {
-    "path": "core.math.quat.fromEuler",
-    "namespace": "core.math.quat",
-    "summary": "Build a quaternion from Euler angles in radians.",
-    "examplePrompts": [],
-    "argsType": "number",
-    "resultType": "QuatHandle"
-  },
-  {
-    "path": "core.math.quat.identity",
-    "namespace": "core.math.quat",
-    "summary": "Return the identity quaternion (no rotation).",
-    "examplePrompts": [],
-    "argsType": null,
-    "resultType": "QuatHandle"
-  },
-  {
-    "path": "core.math.quat.inverse",
-    "namespace": "core.math.quat",
-    "summary": "Compute the inverse quaternion — the rotation that undoes `q`.",
-    "examplePrompts": [],
-    "argsType": "QuatHandle",
-    "resultType": "QuatHandle"
-  },
-  {
-    "path": "core.math.quat.length",
-    "namespace": "core.math.quat",
-    "summary": "Compute the magnitude (norm) of a quaternion.",
-    "examplePrompts": [],
-    "argsType": "QuatHandle",
-    "resultType": "number"
-  },
-  {
-    "path": "core.math.quat.multiply",
-    "namespace": "core.math.quat",
-    "summary": "Compose two rotations with the Hamilton product `a * b` (apply `b` then `a`).",
-    "examplePrompts": [],
-    "argsType": "QuatHandle",
-    "resultType": "QuatHandle"
-  },
-  {
-    "path": "core.math.quat.new",
-    "namespace": "core.math.quat",
-    "summary": "Create a quaternion from primitive components.",
-    "examplePrompts": [],
-    "argsType": "number",
-    "resultType": "QuatHandle"
+    "path": "core.math.quat.new",
+    "namespace": "core.math.quat",
+    "summary": "Create a quaternion from primitive components.",
+    "examplePrompts": [],
+    "argsType": "number",
+    "resultType": "QuatHandle"
   },
   {
     "path": "core.math.quat.normalize",
@@ -3038,114 +2373,6 @@
     "argsType": "number",
     "resultType": "boolean"
   },
-  {
-    "path": "core.proposals.create",
-    "namespace": "core.proposals",
-    "summary": "Create a new design option (proposal).",
-    "examplePrompts": [
-      "Create a design option called Scheme B",
-      "Add a new proposal named Option 2",
-      "Make a fresh design variant to explore\n\n# Example\n```ts\nconst { id } = await snaptrude.core.proposals.create(\"Scheme B\")\n```"
-    ],
-    "argsType": "string",
-    "resultType": "PluginCoreProposalsCreateResult"
-  },
-  {
-    "path": "core.proposals.delete",
-    "namespace": "core.proposals",
-    "summary": "Delete a proposal.",
-    "examplePrompts": [
-      "Delete proposal prop_2 and everything in it",
-      "Remove this design option and destroy its geometry",
-      "Merge prop_2's layers into prop_1 and delete prop_2\n\n# Example\n```ts\n// destroy the proposal and its exclusive geometry\nawait snaptrude.core.proposals.delete(\"prop_2\", { deleteObjects: true })\n// …or keep the geometry by transferring its buckets to prop_1 first\nawait snaptrude.core.proposals.delete(\"prop_2\", { targetProposalId: \"prop_1\" })\n```"
-    ],
-    "argsType": "string",
-    "resultType": "PluginCoreProposalsDeleteResult"
-  },
-  {
-    "path": "core.proposals.get",
-    "namespace": "core.proposals",
-    "summary": "Get a single proposal by id.",
-    "examplePrompts": [
-      "Get the proposal with id prop_1",
-      "Look up a single design option by its id",
-      "Which buckets belong to proposal prop_2?\n\n# Example\n```ts\nconst proposal = await snaptrude.core.proposals.get(\"prop_1\")\nif (proposal) console.log(proposal.name, proposal.bucketIds)\n```"
-    ],
-    "argsType": "string",
-    "resultType": "PluginCoreProposalsGetResult"
-  },
-  {
-    "path": "core.proposals.getActive",
-    "namespace": "core.proposals",
-    "summary": "Get the active proposal.",
-    "examplePrompts": [
-      "Which design option is active?",
-      "Get the current proposal",
-      "What proposal am I working in?\n\n# Example\n```ts\nconst active = await snaptrude.core.proposals.getActive()\nif (active) console.log(active.id, active.name)\n```"
-    ],
-    "argsType": null,
-    "resultType": "PluginCoreProposalsGetActiveResult"
-  },
-  {
-    "path": "core.proposals.isActive",
-    "namespace": "core.proposals",
-    "summary": "Test whether a proposal is the active one.",
-    "examplePrompts": [
-      "Is proposal prop_2 the active one?",
-      "Check whether this design option is currently shown",
-      "Am I working in proposal prop_1?\n\n# Example\n```ts\nif (await snaptrude.core.proposals.isActive(\"prop_1\")) {\nconsole.log(\"prop_1 is active\")\n}\n```"
-    ],
-    "argsType": "string",
-    "resultType": "boolean"
-  },
-  {
-    "path": "core.proposals.list",
-    "namespace": "core.proposals",
-    "summary": "List the design options (proposals) in the active project.",
-    "examplePrompts": [
-      "List all the design options in this project",
-      "How many proposals does this project have?",
-      "Show every design variant with its name\n\n# Example\n```ts\nconst { proposals } = await snaptrude.core.proposals.list()\nfor (const p of proposals) console.log(p.id, p.name, p.isActive)\n```"
-    ],
-    "argsType": null,
-    "resultType": "PluginCoreProposalsListResult"
-  },
-  {
-    "path": "core.proposals.listForComponent",
-    "namespace": "core.proposals",
-    "summary": "List the proposals a component belongs to.",
-    "examplePrompts": [
-      "Which design options is this component part of?",
-      "List the proposals that contain this wall",
-      "Is this element shared across multiple design variants?\n\n# Example\n```ts\nconst { proposals } = await snaptrude.core.proposals.listForComponent(wall)\nconsole.log(`shared across ${proposals.length} proposals`)\n```"
-    ],
-    "argsType": "ComponentHandle",
-    "resultType": "PluginCoreProposalsListForComponentResult"
-  },
-  {
-    "path": "core.proposals.rename",
-    "namespace": "core.proposals",
-    "summary": "Rename a proposal.",
-    "examplePrompts": [
-      "Rename proposal prop_1 to Final Scheme",
-      "Change the name of this design option",
-      "Call proposal prop_2 \"Option A\"\n\n# Example\n```ts\nconst proposal = await snaptrude.core.proposals.rename(\"prop_1\", \"Final Scheme\")\n```"
-    ],
-    "argsType": "string",
-    "resultType": "PluginCoreProposalsRenameResult"
-  },
-  {
-    "path": "core.proposals.setActive",
-    "namespace": "core.proposals",
-    "summary": "Switch the active proposal.",
-    "examplePrompts": [
-      "Switch to proposal prop_2",
-      "Make Scheme B the active design option",
-      "Show me the other proposal\n\n# Example\n```ts\nawait snaptrude.core.proposals.setActive(\"prop_2\")\n```"
-    ],
-    "argsType": "string",
-    "resultType": "PluginCoreProposalsSetActiveResult"
-  },
   {
     "path": "core.tags.assign",
     "namespace": "core.tags",
@@ -3500,20 +2727,6 @@
     "argsType": "ComponentHandle[]",
     "resultType": "ComponentHandle[]"
   },
-  {
-    "path": "design.create.door",
-    "namespace": "design.create",
-    "summary": "Place a **door** from the catalog into a host wall.",
-    "examplePrompts": [
-      "Add a door to this wall here",
-      "Place a sliding door on the selected wall",
-      "Put a door from the catalog at this point on the wall",
-      "Insert the entrance door into this wall",
-      "Add a door to the wall and call it Entry-01\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```"
-    ],
-    "argsType": "string",
-    "resultType": "ComponentHandle"
-  },
   {
     "path": "design.create.floor",
     "namespace": "design.create",
@@ -3595,20 +2808,6 @@
     "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",
@@ -3664,20 +2863,6 @@
     "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\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",
@@ -3692,32 +2877,6 @@
     "argsType": "ComponentHandle[]",
     "resultType": "PluginDesignChangeResult"
   },
-  {
-    "path": "design.doors.exists",
-    "namespace": "design.doors",
-    "summary": "Test whether a door catalog item exists for the given library id.",
-    "examplePrompts": [
-      "Is this door still in the library?",
-      "Check whether a door catalog item with this id exists",
-      "Does my team library have this door?",
-      "Verify the door is available before placing it\n\n# Example\n```ts\nconst [entry] = await snaptrude.design.doors.listCatalog()\nconst stillAvailable = await snaptrude.design.doors.exists(entry.id)\nconsole.log(stillAvailable ? \"safe to place\" : \"removed from library\")\n```"
-    ],
-    "argsType": "string",
-    "resultType": "boolean"
-  },
-  {
-    "path": "design.doors.getCatalogItem",
-    "namespace": "design.doors",
-    "summary": "Get a single door catalog item by its library id.",
-    "examplePrompts": [
-      "Get the details of this door from the library",
-      "Look up the catalog entry for this door id",
-      "What is the cost of this door item?",
-      "Show me the family name of this door in the catalog\n\n# Example\n```ts\nconst [entry] = await snaptrude.design.doors.listCatalog()\nconst item = await snaptrude.design.doors.getCatalogItem(entry.id)\nif (item) console.log(item.name, item.source, item.dbType)\n```"
-    ],
-    "argsType": "string",
-    "resultType": "PluginObjectCatalogItem | null"
-  },
   {
     "path": "design.doors.getFamily",
     "namespace": "design.doors",
@@ -3790,37 +2949,11 @@
     "examplePrompts": [
       "How wide is this door?",
       "What's the width of the selected door?",
-      "Measure the width of the entrance door",
-      "Check whether this door is 900mm wide\n\n# Example\n```ts\nconst [door] = await snaptrude.design.query.listDoors({ isSelected: true })\nconst width = await snaptrude.design.doors.getWidth(door)\nif (width !== null) console.log(\"door width:\", width)\n```"
-    ],
-    "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```"
+      "Measure the width of the entrance door",
+      "Check whether this door is 900mm wide\n\n# Example\n```ts\nconst [door] = await snaptrude.design.query.listDoors({ isSelected: true })\nconst width = await snaptrude.design.doors.getWidth(door)\nif (width !== null) console.log(\"door width:\", width)\n```"
     ],
-    "argsType": null,
-    "resultType": "PluginObjectCatalogGroup[]"
+    "argsType": "ComponentHandle",
+    "resultType": "number | null"
   },
   {
     "path": "design.doors.mirror",
@@ -3932,42 +3065,17 @@
   {
     "path": "design.furniture.listCatalog",
     "namespace": "design.furniture",
-    "summary": "List the placeable furniture catalog (team + general libraries), optionally filtered by library `source` and/or `category`.",
+    "summary": "List the placeable furniture catalog (team + general libraries).",
     "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?",
-      "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```"
+      "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```"
     ],
     "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.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",
@@ -3981,18 +3089,6 @@
     "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",
@@ -4019,19 +3115,6 @@
     "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",
@@ -4046,19 +3129,6 @@
     "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",
@@ -4072,18 +3142,6 @@
     "argsType": "PluginMaterialSpec",
     "resultType": "MaterialHandle"
   },
-  {
-    "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",
@@ -4163,18 +3221,6 @@
     "argsType": "\"project\" | \"preset\"",
     "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.reset",
     "namespace": "design.materials",
@@ -4188,18 +3234,6 @@
     "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",
@@ -4345,19 +3379,6 @@
     "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",
@@ -4702,35 +3723,6 @@
     "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\n\n# Example\n```ts\nconst rooms = await snaptrude.design.selection.get()\n// align every room's left (world -X) edge to a common minimum\nawait snaptrude.design.transform.align(rooms, \"left\")\n// …or align them to a fixed reference component's left edge\nconst [anchor] = await snaptrude.design.query.listWalls({ storeys: [1] })\nawait snaptrude.design.transform.align(rooms, \"left\", { reference: anchor })\n```"
-    ],
-    "argsType": "ComponentHandle[]",
-    "resultType": "PluginDesignChangeResult"
-  },
   {
     "path": "design.transform.move",
     "namespace": "design.transform",
@@ -4771,32 +3763,6 @@
     "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.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.space",
     "namespace": "design.update",
@@ -4825,46 +3791,6 @@
     "argsType": "PluginUpdateSpaceItem[]",
     "resultType": "PluginSpaceUpdateResult[]"
   },
-  {
-    "path": "design.update.staircase",
-    "namespace": "design.update",
-    "summary": "Update the parameters of one or more staircases — riser, tread, width, depth, step count, total height, well size, landing depth, base offset, and the two height locks — in one undoable operation. Sparse: only the fields you provide change. The paired read is `design.query.getStaircaseParams`.",
-    "examplePrompts": [
-      "Set the riser of this staircase to 165mm",
-      "Change all the stairs to 14 steps",
-      "Make the selected staircase 1200 wide with a 280 tread",
-      "Widen every staircase on level 1 to 1 metre",
-      "Unlock the height and set this stair to 3200 tall\n\n# Example\n```ts\n// Give every ground-floor staircase a common riser + tread (engine units)\nconst stairs = await snaptrude.design.query.listStaircases({ storeys: [1] })\nconst { affected } = await snaptrude.design.update.staircase(stairs, {\nriser: 165,\ntread: 280,\n})\nconsole.log(\"updated\", affected.length, \"staircases\")\n```"
-    ],
-    "argsType": "ComponentHandle[]",
-    "resultType": "PluginDesignChangeResult"
-  },
-  {
-    "path": "design.windows.exists",
-    "namespace": "design.windows",
-    "summary": "Test whether a window catalog item exists for the given library id.",
-    "examplePrompts": [
-      "Is this window still in the library?",
-      "Check whether a window catalog item with this id exists",
-      "Does my team library have this window?",
-      "Verify the window is available before placing it\n\n# Example\n```ts\nconst [entry] = await snaptrude.design.windows.listCatalog()\nconst stillAvailable = await snaptrude.design.windows.exists(entry.id)\nconsole.log(stillAvailable ? \"safe to place\" : \"removed from library\")\n```"
-    ],
-    "argsType": "string",
-    "resultType": "boolean"
-  },
-  {
-    "path": "design.windows.getCatalogItem",
-    "namespace": "design.windows",
-    "summary": "Get a single window catalog item by its library id.",
-    "examplePrompts": [
-      "Get the details of this window from the library",
-      "Look up the catalog entry for this window id",
-      "What is the cost of this window item?",
-      "Show me the family name of this window in the catalog\n\n# Example\n```ts\nconst [entry] = await snaptrude.design.windows.listCatalog()\nconst item = await snaptrude.design.windows.getCatalogItem(entry.id)\nif (item) console.log(item.name, item.source, item.dbType)\n```"
-    ],
-    "argsType": "string",
-    "resultType": "PluginObjectCatalogItem | null"
-  },
   {
     "path": "design.windows.getDimensions",
     "namespace": "design.windows",
@@ -4918,32 +3844,6 @@
     "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",
@@ -5065,19 +3965,6 @@
     "argsType": "number",
     "resultType": "PluginStoryCreateResult"
   },
-  {
-    "path": "entity.story.duplicate",
-    "namespace": "entity.story",
-    "summary": "Duplicate a story into the adjacent level, up or down.",
-    "examplePrompts": [
-      "Duplicate this floor to the storey above",
-      "Copy the ground floor down into a new basement",
-      "Repeat this level upwards with its own independent geometry",
-      "Duplicate just the selected walls onto the next floor up\n\n# Example\n```ts\n// Duplicate the whole active story one level up (instanced copies).\nconst { targetStories, created, skipped } =\nawait snaptrude.entity.story.duplicate(\"up\")\nconsole.log(`Copied ${created.length} elements onto story ${targetStories}`)\nif (skipped) console.log(`${skipped} elements were skipped`)\n```"
-    ],
-    "argsType": "\"up\" | \"down\"",
-    "resultType": "PluginStoryDuplicateResult"
-  },
   {
     "path": "entity.story.get",
     "namespace": "entity.story",
@@ -5108,16 +3995,222 @@
   {
     "path": "entity.story.update",
     "namespace": "entity.story",
-    "summary": "Update a story's floor-to-floor height, cascading the full geometry change.",
+    "summary": "Update a story's height.",
     "examplePrompts": [
       "Change the ground floor height to 3.5 metres",
       "Make the second storey taller",
       "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 — 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```"
+      "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```"
     ],
     "argsType": "number",
     "resultType": "PluginStoryUpdateResult"
   },
+  {
+    "path": "presentation.aiInspiration.cancelJob",
+    "namespace": "presentation.aiInspiration",
+    "summary": "Cancel a transient AI Inspiration job.",
+    "examplePrompts": [
+      "Cancel the running generation",
+      "Stop that AI job\n\n# Example\n```ts\nconst { job } = await snaptrude.presentation.aiInspiration.cancelJob({ jobId })\nconsole.log(job.status) // \"cancelled\" (or a terminal state it already reached)\n```"
+    ],
+    "argsType": "PluginAIInspirationJobArgs",
+    "resultType": "PluginAIInspirationCancelJobResult"
+  },
+  {
+    "path": "presentation.aiInspiration.deleteRecipe",
+    "namespace": "presentation.aiInspiration",
+    "summary": "Delete a project-level AI Inspiration recipe.",
+    "examplePrompts": [
+      "Delete the facade render recipe",
+      "Remove that saved AI recipe\n\n# Example\n```ts\nconst { recipes } = await snaptrude.presentation.aiInspiration.listRecipes()\nconst stale = recipes.find((r) => r.name === \"Old style test\")\nif (stale) {\nconst { deleted } = await snaptrude.presentation.aiInspiration.deleteRecipe({ recipeId: stale.id })\nconsole.log(deleted)\n}\n```"
+    ],
+    "argsType": "PluginAIInspirationDeleteRecipeArgs",
+    "resultType": "PluginAIInspirationDeleteRecipeResult"
+  },
+  {
+    "path": "presentation.aiInspiration.extractRecipeFromShape",
+    "namespace": "presentation.aiInspiration",
+    "summary": "Extract a reusable recipe draft from the workflow path ending at a shape.",
+    "examplePrompts": [
+      "Turn this workflow into a reusable recipe",
+      "Save the generation steps behind this image\n\n# Example\n```ts\nconst extraction = await snaptrude.presentation.aiInspiration.extractRecipeFromShape({\nshapeId: selected.shapeId,\n})\nif (extraction.status === \"ready\") console.log(extraction.draft.summary)\n```"
+    ],
+    "argsType": "PluginAIInspirationExtractRecipeFromShapeArgs",
+    "resultType": "PluginAIInspirationExtractionResult"
+  },
+  {
+    "path": "presentation.aiInspiration.generate",
+    "namespace": "presentation.aiInspiration",
+    "summary": "Generate an image or video from a Present canvas source.",
+    "examplePrompts": [
+      "Generate an image from this sketch",
+      "Render the selected view as a photorealistic image",
+      "Make an AI image of a modern facade from this source",
+      "Generate a video from this image",
+      "Turn this massing into a rendered street view\n\n# Example\n```ts\nconst { sources } = await snaptrude.presentation.aiInspiration.listSources({})\nconst [source, ...refs] = sources\nconst { outputs } = await snaptrude.presentation.aiInspiration.generate({\nsourceShapeId: source.shapeId,\nprompt: \"Photorealistic render of a modern timber facade at dusk\",\nreferenceShapeIds: refs.slice(0, 2).map((r) => r.shapeId),\nreferenceStrength: \"medium\",\n})\nfor (const out of outputs ?? []) console.log(out.outputType, out.shapeId, out.outputUrl)\n```"
+    ],
+    "argsType": "PluginAIInspirationGenerateArgs",
+    "resultType": "PluginAIInspirationRunResult"
+  },
+  {
+    "path": "presentation.aiInspiration.getJob",
+    "namespace": "presentation.aiInspiration",
+    "summary": "Get a transient AI Inspiration job by ID.",
+    "examplePrompts": [
+      "Is my render finished?",
+      "Check on the generation job\n\n# Example\n```ts\nconst { jobId } = await snaptrude.presentation.aiInspiration.generate({\nsourceShapeId: source.shapeId,\nprompt: \"Aerial dusk render\",\nrunMode: \"job\",\n})\nconst { job } = await snaptrude.presentation.aiInspiration.getJob({ jobId })\nconsole.log(job.status, job.progress?.message)\n```"
+    ],
+    "argsType": "PluginAIInspirationJobArgs",
+    "resultType": "PluginAIInspirationGetJobResult"
+  },
+  {
+    "path": "presentation.aiInspiration.getModelCapabilities",
+    "namespace": "presentation.aiInspiration",
+    "summary": "Get capability flags for a model.",
+    "examplePrompts": [
+      "What can this model do?",
+      "Does the default model support reference images?",
+      "Check if the video model supports keyframes\n\n# Example\n```ts\nconst { defaultModelId } = await snaptrude.presentation.aiInspiration.listModels()\nconst { capability } = await snaptrude.presentation.aiInspiration.getModelCapabilities({\nmodelId: defaultModelId,\n})\nconsole.log(capability.supportsReferenceImages, capability.maxExtraImages)\n```"
+    ],
+    "argsType": "PluginAIInspirationGetModelCapabilitiesArgs",
+    "resultType": "PluginAIInspirationGetModelCapabilitiesResult"
+  },
+  {
+    "path": "presentation.aiInspiration.getPresetCatalog",
+    "namespace": "presentation.aiInspiration",
+    "summary": "Get the curated AI Inspiration preset catalog.",
+    "examplePrompts": [
+      "What style presets are available?",
+      "List the curated AI generation presets",
+      "Show me the exterior render styles\n\n# Example\n```ts\nconst { categories, presets } = await snaptrude.presentation.aiInspiration.getPresetCatalog()\nconst exterior = presets.filter((p) => p.categoryLabel === \"Exterior\")\nconsole.log(categories.map((c) => c.label), exterior.map((p) => p.name))\n```"
+    ],
+    "argsType": null,
+    "resultType": "PluginAIInspirationGetPresetCatalogResult"
+  },
+  {
+    "path": "presentation.aiInspiration.getSelectedBranchRerunPlan",
+    "namespace": "presentation.aiInspiration",
+    "summary": "Build a rerun plan for the selected workflow branch ending at a shape.",
+    "examplePrompts": [
+      "Can I rerun the steps that produced this output?",
+      "Preview the rerun for this generated image\n\n# Example\n```ts\nconst plan = await snaptrude.presentation.aiInspiration.getSelectedBranchRerunPlan({\nshapeId: selected.shapeId,\n})\nif (plan.status === \"ready\") console.log(plan.edges.map((e) => e.operation.label))\nelse console.log(\"Cannot rerun:\", plan.reason)\n```"
+    ],
+    "argsType": "PluginAIInspirationGetWorkflowForShapeArgs",
+    "resultType": "PluginAIInspirationRerunPlanResult"
+  },
+  {
+    "path": "presentation.aiInspiration.getSelection",
+    "namespace": "presentation.aiInspiration",
+    "summary": "Get selected Present canvas shapes that AI Inspiration can use.",
+    "examplePrompts": [
+      "Generate from what I have selected",
+      "Which of my selected shapes can be used as AI sources?\n\n# Example\n```ts\nconst { selectedShapeIds, sources } = await snaptrude.presentation.aiInspiration.getSelection()\nconsole.log(selectedShapeIds.length, \"selected,\", sources.length, \"usable\")\n```"
+    ],
+    "argsType": null,
+    "resultType": "PluginAIInspirationGetSelectionResult"
+  },
+  {
+    "path": "presentation.aiInspiration.getWorkflowForShape",
+    "namespace": "presentation.aiInspiration",
+    "summary": "Get the sanitized workflow graph containing a Present shape.",
+    "examplePrompts": [
+      "Show the generation history of this image",
+      "What workflow produced this shape?\n\n# Example\n```ts\nconst { workflow, node } = await snaptrude.presentation.aiInspiration.getWorkflowForShape({\nshapeId: selected.shapeId,\n})\nif (workflow && node) console.log(node.id, workflow.edgeIds.length, \"edges\")\n```"
+    ],
+    "argsType": "PluginAIInspirationGetWorkflowForShapeArgs",
+    "resultType": "PluginAIInspirationGetWorkflowForShapeResult"
+  },
+  {
+    "path": "presentation.aiInspiration.listJobs",
+    "namespace": "presentation.aiInspiration",
+    "summary": "List transient AI Inspiration jobs created in the current host session.",
+    "examplePrompts": [
+      "What AI jobs are running?",
+      "Show my generation queue\n\n# Example\n```ts\nconst { jobs } = await snaptrude.presentation.aiInspiration.listJobs()\nconst running = jobs.filter((j) => j.status === \"running\" || j.status === \"queued\")\nconsole.log(running.map((j) => `${j.jobId}: ${j.method}`))\n```"
+    ],
+    "argsType": null,
+    "resultType": "PluginAIInspirationListJobsResult"
+  },
+  {
+    "path": "presentation.aiInspiration.listModels",
+    "namespace": "presentation.aiInspiration",
+    "summary": "List AI Inspiration models that can be used for generation.",
+    "examplePrompts": [
+      "What AI inspiration models can I use?",
+      "List the available image and video models",
+      "Which generation model is the default?\n\n# Example\n```ts\nconst { defaultModelId, models } = await snaptrude.presentation.aiInspiration.listModels()\nconst videoModels = models.filter((m) => m.output === \"video\")\nconsole.log(defaultModelId, videoModels.map((m) => m.id))\n```"
+    ],
+    "argsType": null,
+    "resultType": "PluginAIInspirationListModelsResult"
+  },
+  {
+    "path": "presentation.aiInspiration.listRecipes",
+    "namespace": "presentation.aiInspiration",
+    "summary": "List project-level AI Inspiration recipes stored in Present document metadata.",
+    "examplePrompts": [
+      "What AI recipes are saved in this project?",
+      "List my generation recipes\n\n# Example\n```ts\nconst { recipes } = await snaptrude.presentation.aiInspiration.listRecipes()\nconsole.log(recipes.map((r) => `${r.name} → ${r.outputKind}`))\n```"
+    ],
+    "argsType": null,
+    "resultType": "PluginAIInspirationListRecipesResult"
+  },
+  {
+    "path": "presentation.aiInspiration.listSources",
+    "namespace": "presentation.aiInspiration",
+    "summary": "List image/view/video sources on the current Present page.",
+    "examplePrompts": [
+      "List the images I can generate from on this page",
+      "What source shapes are on the present canvas?",
+      "Show me the reference images available for AI generation\n\n# Example\n```ts\nconst { sources } = await snaptrude.presentation.aiInspiration.listSources({ includeGenerated: true })\nfor (const s of sources) console.log(s.kind, s.shapeId, s.name)\n```"
+    ],
+    "argsType": "PluginAIInspirationListSourcesArgs",
+    "resultType": "PluginAIInspirationListSourcesResult"
+  },
+  {
+    "path": "presentation.aiInspiration.refine",
+    "namespace": "presentation.aiInspiration",
+    "summary": "Refine/upscale an AI Inspiration source image.",
+    "examplePrompts": [
+      "Upscale this AI image",
+      "Refine and sharpen the selected render",
+      "Make this generated image higher resolution\n\n# Example\n```ts\nconst { sources } = await snaptrude.presentation.aiInspiration.listSources({ includeGenerated: true })\nconst image = sources.find((s) => s.kind === \"image\")\nif (image) {\nconst { outputs } = await snaptrude.presentation.aiInspiration.refine({\nsourceShapeId: image.shapeId,\nupscaleFactor: 2,\n})\nconsole.log(outputs?.[0]?.shapeId)\n}\n```"
+    ],
+    "argsType": "PluginAIInspirationRefineArgs",
+    "resultType": "PluginAIInspirationRunResult"
+  },
+  {
+    "path": "presentation.aiInspiration.rerunSelectedBranch",
+    "namespace": "presentation.aiInspiration",
+    "summary": "Rerun the selected workflow branch and supersede the previous branch.",
+    "examplePrompts": [
+      "Rerun this generation branch",
+      "Regenerate this output with the same steps\n\n# Example\n```ts\nconst { outputs } = await snaptrude.presentation.aiInspiration.rerunSelectedBranch({\nshapeId: selected.shapeId,\n})\nconsole.log(outputs?.map((o) => o.shapeId))\n```"
+    ],
+    "argsType": "PluginAIInspirationRerunSelectedBranchArgs",
+    "resultType": "PluginAIInspirationRunResult"
+  },
+  {
+    "path": "presentation.aiInspiration.runRecipe",
+    "namespace": "presentation.aiInspiration",
+    "summary": "Run a saved or inline recipe against Present canvas slot shapes.",
+    "examplePrompts": [
+      "Apply my saved recipe to this image",
+      "Run the dusk-render recipe on the selected view\n\n# Example\n```ts\nconst { recipes } = await snaptrude.presentation.aiInspiration.listRecipes()\nconst recipe = recipes[0]\nconst { sources } = await snaptrude.presentation.aiInspiration.listSources({})\nconst { outputs } = await snaptrude.presentation.aiInspiration.runRecipe({\nrecipeId: recipe.id,\nslotShapeIds: { [recipe.slots[0].id]: sources[0].shapeId },\n})\nconsole.log(outputs?.map((o) => o.outputUrl))\n```"
+    ],
+    "argsType": "PluginAIInspirationRunRecipeArgs",
+    "resultType": "PluginAIInspirationRunResult"
+  },
+  {
+    "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.diagrams.place",
     "namespace": "presentation.diagrams",
@@ -5156,19 +4249,6 @@
     "argsType": "{ url?: string; dataUrl?: string }",
     "resultType": "PluginPresentationImportResult"
   },
-  {
-    "path": "presentation.import.svg",
-    "namespace": "presentation.import",
-    "summary": "Import an SVG onto the current Present sheet as a vector asset.",
-    "examplePrompts": [
-      "Import this SVG diagram onto the present canvas",
-      "Add a vector logo to my presentation board",
-      "Place this SVG floor plan on the current sheet as vectors",
-      "Bring a crisp vector graphic into Present mode\n\n# Example\n```ts\nconst { shapeIds } = await snaptrude.presentation.import.svg({\nurl: \"https://example.com/diagram.svg\",\n})\n```"
-    ],
-    "argsType": "{ url?: string; dataUrl?: string }",
-    "resultType": "PluginPresentationImportResult"
-  },
   {
     "path": "presentation.sheets.create",
     "namespace": "presentation.sheets",
@@ -5269,19 +4349,6 @@
     "argsType": null,
     "resultType": "PluginPresentationViewsGetResult"
   },
-  {
-    "path": "presentation.views.getSettings",
-    "namespace": "presentation.views",
-    "summary": "Read a saved view's display settings (background, color 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",
@@ -5309,20 +4376,6 @@
     "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\n\n# Example\n```ts\nawait snaptrude.presentation.views.updateSettings(\"view_123\", {\ncolorMode: \"monochrome\",\nshowAxis: false,\n})\n```"
-    ],
-    "argsType": "string",
-    "resultType": "PluginPresentationViewsUpdateSettingsResult"
-  },
   {
     "path": "program.adjacency.compute",
     "namespace": "program.adjacency",
@@ -5356,8 +4409,6 @@
     "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```"
     ],
@@ -5370,7 +4421,6 @@
     "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```"
     ],
@@ -5383,7 +4433,6 @@
     "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```"
     ],
@@ -5544,54 +4593,6 @@
     "argsType": "string",
     "resultType": "PluginProgramDepartmentsUpdateResult"
   },
-  {
-    "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\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.metrics.get",
     "namespace": "program.metrics",
@@ -5646,30 +4647,6 @@
     "argsType": null,
     "resultType": "PluginProgramSiteContextResult"
   },
-  {
-    "path": "program.site.getLocation",
-    "namespace": "program.site",
-    "summary": "Get the project's geographic location.",
-    "examplePrompts": [
-      "What's the project's latitude and longitude?",
-      "Where is this site located?",
-      "Get the geographic coordinates of the project\n\n# Example\n```ts\nconst location = await snaptrude.program.site.getLocation()\nif (location) console.log(location.latitude, location.longitude)\n```"
-    ],
-    "argsType": null,
-    "resultType": "PluginProgramSiteLocationResult"
-  },
-  {
-    "path": "program.site.getNorthAngle",
-    "namespace": "program.site",
-    "summary": "Get the site's true-north angle.",
-    "examplePrompts": [
-      "What's the north angle of the site?",
-      "How far is the model rotated from true north?",
-      "Get the project's true north direction\n\n# Example\n```ts\nconst northAngle = await snaptrude.program.site.getNorthAngle()\nif (northAngle !== null) console.log(`${northAngle}° from true north`)\n```"
-    ],
-    "argsType": null,
-    "resultType": "PluginProgramSiteNorthAngleResult"
-  },
   {
     "path": "program.site.listGeoPolygons",
     "namespace": "program.site",