@snaptrude/plugin-core 0.6.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",
@@ -2050,431 +1810,6 @@
     "argsType": "number",
     "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.",
-    "examplePrompts": [
-      "Sketch this parsed CAD JSON onto the active storey",
-      "Draw these CAD curves as an underlay on storey 2",
-      "Create a CAD sketch from this geometry data",
-      "Import my converted CAD JSON onto the ground floor\n\n# Example\n```ts\nconst cad = await snaptrude.core.io.import.cadJson(\n{ unit: \"mm\", geometry: [{ type: \"line\", layer: \"WALLS\", ... }] },\n1,\n)\n```"
-    ],
-    "argsType": "CadJsonInput",
-    "resultType": "UnderlayHandle"
-  },
-  {
-    "path": "core.io.import.dwg",
-    "namespace": "core.io.import",
-    "summary": "Import a **DWG** CAD drawing as a scene underlay. `.dwg` only (no DXF).",
-    "examplePrompts": [
-      "Import this DWG floor plan onto storey 1",
-      "Bring in a CAD drawing as an underlay and tell me when it's ready",
-      "Start importing this CAD file onto the ground floor\n\n# Example\n```ts\nconst job = await snaptrude.core.io.import.dwg(\"https://example.com/plan.dwg\", 1)\n// Poll until the server-side conversion finishes — always with a timeout\n// (a UI-cancelled import stays \"processing\" forever).\nconst deadline = Date.now() + 5 * 60_000\nwhile (!(await snaptrude.core.io.job.isComplete(job))) {\nif (Date.now() > deadline) throw new Error(\"DWG import timed out\")\nawait new Promise((r) => setTimeout(r, 2000))\n}\n// The DWG lands as a CAD underlay. CAD scaling isn't supported; manage it\n// (list / fade / delete) via core.io.underlay.*.\nconst cad = await snaptrude.core.io.job.getResult(job)\nif (cad) console.log(\"DWG imported as CAD underlay:\", cad)\n```"
-    ],
-    "argsType": "string",
-    "resultType": "ImportJobHandle"
-  },
-  {
-    "path": "core.io.import.image",
-    "namespace": "core.io.import",
-    "summary": "Import a raster image as a scene **underlay** — a flat, textured reference plane placed on a storey that you can trace over.",
-    "examplePrompts": [
-      "Import this floor plan image onto the ground floor to trace over",
-      "Drop this survey PNG in as a reference underlay at 30% opacity",
-      "Add a site plan image on storey 2",
-      "Bring in a sketch to trace, faded to half opacity\n\n# Example\n```ts\n// Place a floor plan on storey 1, then calibrate it to a real-world size.\nconst plan = await snaptrude.core.io.import.image(\n\"https://example.com/floorplan.png\",\n1,           // storey\nundefined,   // scale\n0.4,         // opacity\n\"Ground floor plan\",\n)\n// Make the plan's longest side exactly 40 project-units:\nawait snaptrude.core.io.underlay.setScale(plan, { planSize: 40 })\n```"
-    ],
-    "argsType": "string",
-    "resultType": "UnderlayHandle"
-  },
-  {
-    "path": "core.io.import.model",
-    "namespace": "core.io.import",
-    "summary": "Import a **3D model** file and place it in the scene as a component.",
-    "examplePrompts": [
-      "Import this SketchUp model onto storey 1",
-      "Bring in this OBJ file and place it at the origin",
-      "Add this 3D model to the ground floor\n\n# Example\n```ts\nconst model = await snaptrude.core.io.import.model(\n\"https://example.com/tree.skp\",\n1,        // storey\n\"skp\",\n)\n```"
-    ],
-    "argsType": "string",
-    "resultType": "ComponentHandle"
-  },
-  {
-    "path": "core.io.import.pdf",
-    "namespace": "core.io.import",
-    "summary": "Import one page of a PDF as a scene **underlay** (a traceable reference plane).",
-    "examplePrompts": [
-      "Import page 1 of this PDF floor plan onto storey 1",
-      "Bring in the second page of this PDF as an underlay at 1:50",
-      "Add this PDF plan to the ground floor to trace over",
-      "Place page 3 of the drawing set on storey 3\n\n# Example\n```ts\nconst sheet = await snaptrude.core.io.import.pdf(\n\"https://example.com/plans.pdf\",\n1,        // storey\n2,        // page\n\"1:100\",  // drawing scale\n)\n```"
-    ],
-    "argsType": "string",
-    "resultType": "UnderlayHandle"
-  },
-  {
-    "path": "core.io.import.terrain",
-    "namespace": "core.io.import",
-    "summary": "Import **site terrain** for a location — Mapbox topography (elevation + satellite/streets imagery, optional neighborhood buildings and parcels).",
-    "examplePrompts": [
-      "Import the site terrain for this location, about 500m across",
-      "Load the topography at 40.7128, -74.0060 for a 300 by 300 meter site",
-      "Bring in satellite terrain for the site with the surrounding buildings",
-      "Add site elevation for a 1km by 1km area at these coordinates\n\n# Example\n```ts\n// 300m × 300m site with elevation + satellite imagery.\nconst terrain = await snaptrude.core.io.import.terrain(\n40.7128,  // lat\n-74.006,  // lng\n300,      // width  (metres)\n300,      // length (metres)\ntrue,     // elevation\ntrue,     // satellite\n)\n```"
-    ],
-    "argsType": "number",
-    "resultType": "TerrainHandle"
-  },
-  {
-    "path": "core.io.job.getError",
-    "namespace": "core.io.job",
-    "summary": "The failure message if the job's status is `\"failed\"`; otherwise `null`.",
-    "examplePrompts": [
-      "Why did my DWG import fail?",
-      "What went wrong with the CAD import?",
-      "Show the error from the failed import job",
-      "Did the import error out, and why?\n\n# Example\n```ts\nconst job = await snaptrude.core.io.import.dwg(url, 1)\nif ((await snaptrude.core.io.job.getStatus(job)) === \"failed\") {\nconsole.error(await snaptrude.core.io.job.getError(job))\n}\n```"
-    ],
-    "argsType": "ImportJobHandle",
-    "resultType": "string | null"
-  },
-  {
-    "path": "core.io.job.getResult",
-    "namespace": "core.io.job",
-    "summary": "The imported result once the job is complete — the placed {@linkcode UnderlayHandle}. Returns `null` while the job is still pending/processing or if it failed (check {@link PluginCoreIoJobApi.getError}).",
-    "examplePrompts": [
-      "Get the underlay from my finished DWG import",
-      "Give me the result of the CAD import job",
-      "Fetch the imported CAD sketch once it's ready",
-      "Return the handle for the completed import\n\n# Example\n```ts\nconst job = await snaptrude.core.io.import.dwg(url, 1)\nconst deadline = Date.now() + 5 * 60_000\nwhile (!(await snaptrude.core.io.job.isComplete(job))) {\nif (Date.now() > deadline) throw new Error(\"DWG import timed out\")\nawait new Promise((r) => setTimeout(r, 2000))\n}\n// DWG results are CAD underlays (CAD scaling isn't supported); manage them\n// via core.io.underlay.* (list / setOpacity / delete).\nconst cad = await snaptrude.core.io.job.getResult(job)\nif (cad) console.log(\"import complete:\", cad)\n```"
-    ],
-    "argsType": "ImportJobHandle",
-    "resultType": "UnderlayHandle | null"
-  },
-  {
-    "path": "core.io.job.getStatus",
-    "namespace": "core.io.job",
-    "summary": "Read a job's current status: `\"pending\"` (queued), `\"processing\"` (running), `\"complete\"` (result ready), or `\"failed\"`.",
-    "examplePrompts": [
-      "What's the status of my DWG import?",
-      "Is the CAD import still processing?",
-      "Check where the import job is up to",
-      "Did the import job fail?\n\n# Example\n```ts\nconst job = await snaptrude.core.io.import.dwg(url, 1)\nconsole.log(await snaptrude.core.io.job.getStatus(job)) // \"processing\"\n```"
-    ],
-    "argsType": "ImportJobHandle",
-    "resultType": "ImportJobStatus"
-  },
-  {
-    "path": "core.io.job.isComplete",
-    "namespace": "core.io.job",
-    "summary": "Whether the job has finished successfully (status is `\"complete\"` and a result is ready). Returns `false` while pending/processing and on failure.",
-    "examplePrompts": [
-      "Is the DWG import done yet?",
-      "Has the CAD import finished?",
-      "Tell me when the import job completes",
-      "Is my import ready?\n\n# Example\n```ts\nconst job = await snaptrude.core.io.import.dwg(url, 1)\nconst deadline = Date.now() + 5 * 60_000 // cap the poll — see getStatus limitation\nwhile (!(await snaptrude.core.io.job.isComplete(job))) {\nif (Date.now() > deadline) throw new Error(\"DWG import timed out\")\nawait new Promise((r) => setTimeout(r, 2000))\n}\n```"
-    ],
-    "argsType": "ImportJobHandle",
-    "resultType": "boolean"
-  },
-  {
-    "path": "core.io.query.getPdfPageCount",
-    "namespace": "core.io.query",
-    "summary": "Count the pages of a PDF without importing it. `null` if the source can't be read as a PDF.",
-    "examplePrompts": [
-      "How many pages does this PDF have?",
-      "Count the pages in the drawing set before importing",
-      "Get the PDF page count",
-      "Is this a multi-page PDF, and how many?\n\n# Example\n```ts\nconst pages = await snaptrude.core.io.query.getPdfPageCount(url)\nfor (let p = 1; p <= (pages ?? 0); p++) {\nawait snaptrude.core.io.import.pdf(url, p, p) // one page per storey\n}\n```"
-    ],
-    "argsType": "string",
-    "resultType": "number | null"
-  },
-  {
-    "path": "core.io.query.listCadLayers",
-    "namespace": "core.io.query",
-    "summary": "List the distinct CAD layer names tagged on a parsed CAD JSON's entities. Read-only inspection: imports always bring in **every** layer (there is no layer filter on {@link core.io.import.dwg} / {@link core.io.import.cadJson}) — use the names to decide whether to import at all, or what to tell the user.",
-    "examplePrompts": [
-      "What CAD layers are in this drawing?",
-      "List the layers before importing the CAD",
-      "Show the DWG layer names so I can pick which to import",
-      "Enumerate the CAD JSON layers\n\n# Example\n```ts\nconst layers = await snaptrude.core.io.query.listCadLayers(cad)\nif (layers.some((l) => l.toUpperCase().includes(\"WALL\"))) {\nawait snaptrude.core.io.import.cadJson(cad, 1) // all layers import together\n}\n```"
-    ],
-    "argsType": "CadJsonInput",
-    "resultType": "string[]"
-  },
-  {
-    "path": "core.io.terrain.delete",
-    "namespace": "core.io.terrain",
-    "summary": "Delete the site terrain. Undoable.",
-    "examplePrompts": [
-      "Delete the site terrain",
-      "Remove the topography",
-      "Clear the imported site",
-      "Get rid of the terrain"
-    ],
-    "argsType": null,
-    "resultType": "void"
-  },
-  {
-    "path": "core.io.terrain.disableElevation",
-    "namespace": "core.io.terrain",
-    "summary": "Turn terrain elevation OFF — flatten to a plane. Undoable.",
-    "examplePrompts": [
-      "Flatten the terrain",
-      "Turn off site elevation",
-      "Disable the heightmap",
-      "Make the terrain flat"
-    ],
-    "argsType": null,
-    "resultType": "void"
-  },
-  {
-    "path": "core.io.terrain.disableSatellite",
-    "namespace": "core.io.terrain",
-    "summary": "Turn satellite imagery OFF. Undoable.",
-    "examplePrompts": [
-      "Hide the satellite imagery",
-      "Turn off the aerial texture",
-      "Disable satellite on the site",
-      "Remove the satellite drape"
-    ],
-    "argsType": null,
-    "resultType": "void"
-  },
-  {
-    "path": "core.io.terrain.enableElevation",
-    "namespace": "core.io.terrain",
-    "summary": "Turn terrain elevation (DEM height) ON — a real 3D topography surface. Undoable.",
-    "examplePrompts": [
-      "Turn on terrain elevation",
-      "Enable the site heightmap",
-      "Make the terrain 3D",
-      "Show the topography relief"
-    ],
-    "argsType": null,
-    "resultType": "void"
-  },
-  {
-    "path": "core.io.terrain.enableSatellite",
-    "namespace": "core.io.terrain",
-    "summary": "Turn satellite imagery ON. Undoable.",
-    "examplePrompts": [
-      "Show satellite imagery on the site",
-      "Enable the satellite texture",
-      "Turn on aerial imagery",
-      "Drape satellite over the terrain"
-    ],
-    "argsType": null,
-    "resultType": "void"
-  },
-  {
-    "path": "core.io.terrain.exists",
-    "namespace": "core.io.terrain",
-    "summary": "Whether the project has a site terrain.",
-    "examplePrompts": [
-      "Does this project have site terrain?",
-      "Is there a terrain imported?",
-      "Check if the site topography exists",
-      "Has a terrain been added yet?\n\n# Example\n```ts\nif (!(await snaptrude.core.io.terrain.exists())) {\nawait snaptrude.core.io.import.terrain(40.7128, -74.006, 300, 300)\n}\n```"
-    ],
-    "argsType": null,
-    "resultType": "boolean"
-  },
-  {
-    "path": "core.io.terrain.get",
-    "namespace": "core.io.terrain",
-    "summary": "Resolve the project's terrain handle, or `null` if there is none. The same handle {@link core.io.import.terrain} returns — use it to obtain the handle without re-importing.",
-    "examplePrompts": [
-      "Get the terrain handle",
-      "Give me the site terrain",
-      "Fetch the current terrain",
-      "Return the topography handle if it exists"
-    ],
-    "argsType": null,
-    "resultType": "TerrainHandle | null"
-  },
-  {
-    "path": "core.io.terrain.getDatum",
-    "namespace": "core.io.terrain",
-    "summary": "Read the terrain's current vertical position (world Y, internal units). `null` if there is no terrain. Import places the terrain so its highest point sits at `y = 0`, so a never-shifted terrain reads a negative baseline, not `0`; each {@link PluginCoreIoTerrainApi.setDatum} shift moves this value.",
-    "examplePrompts": [
-      "What's the terrain's datum?",
-      "Read the current site elevation reference",
-      "Get the terrain vertical offset",
-      "How far has the datum been shifted?"
-    ],
-    "argsType": null,
-    "resultType": "number | null"
-  },
-  {
-    "path": "core.io.terrain.getOpacity",
-    "namespace": "core.io.terrain",
-    "summary": "Read the terrain opacity, `0`..`1`, or `null` if no terrain.",
-    "examplePrompts": [],
-    "argsType": null,
-    "resultType": "number | null"
-  },
-  {
-    "path": "core.io.terrain.getReport",
-    "namespace": "core.io.terrain",
-    "summary": "The terrain cut/fill earthwork report — cut, fill, and net volumes — or `null` if there is no terrain.",
-    "examplePrompts": [
-      "What are the cut and fill volumes for the site?",
-      "Get the terrain earthwork report",
-      "How much cut and fill does the grading need?",
-      "Show the net volume of the terrain edits\n\n# Example\n```ts\nconst r = await snaptrude.core.io.terrain.getReport()\nif (r) console.log(`cut ${r.cutVolume}, fill ${r.fillVolume}, net ${r.netVolume}`)\n```"
-    ],
-    "argsType": null,
-    "resultType": "TerrainReport | null"
-  },
-  {
-    "path": "core.io.terrain.isElevationEnabled",
-    "namespace": "core.io.terrain",
-    "summary": "Whether terrain elevation (DEM height) is on. `null` if no terrain.",
-    "examplePrompts": [],
-    "argsType": null,
-    "resultType": "boolean | null"
-  },
-  {
-    "path": "core.io.terrain.isSatelliteEnabled",
-    "namespace": "core.io.terrain",
-    "summary": "Whether satellite imagery is draped on the terrain. `null` if no terrain.",
-    "examplePrompts": [],
-    "argsType": null,
-    "resultType": "boolean | null"
-  },
-  {
-    "path": "core.io.terrain.setDatum",
-    "namespace": "core.io.terrain",
-    "summary": "Shift the terrain's **datum** — move the whole terrain vertically DOWN by `offset` (internal units) from its current position; pass a negative value to raise it. Undoable.",
-    "examplePrompts": [
-      "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",
@@ -4388,21 +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.move",
     "namespace": "design.transform",
@@ -4685,6 +4005,212 @@
     "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",
@@ -5121,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",