@snaptrude/plugin-core 0.7.1 → 0.9.0

package/src/api/analysis/solar.ts

@@ -0,0 +1,237 @@
+import * as z from "zod"
+import { PluginApiReturn } from "../../types"
+import { PluginWeatherSourceMeta } from "./weather"
+
+/**
+ * Analysis solar — sample solar exposure at caller-chosen points.
+ *
+ * Unlike the heatmap studies (which raster the model's own surfaces), this
+ * samples solar exposure at **points you supply** — an instant (sun visible? /
+ * irradiance now) or aggregated over a date range (shaded fraction / cumulative
+ * irradiance). Positions are **world plan-space** coordinates, the same units
+ * and frame as plugin geometry reads; the backend echoes them verbatim and
+ * never re-projects.
+ *
+ * Raw numbers only: this renders no heatmap, mutates no geometry, and writes no
+ * save commands — visualization is the plugin's job. Large grids run as a job
+ * (`status: "running"` until complete); every result carries `modelRevision` +
+ * `inputHash` so the caller can mark it stale after a geometry change.
+ *
+ * Accessed via `snaptrude.analysis.solar`.
+ */
+export abstract class PluginAnalysisSolarApi {
+  constructor() {}
+
+  /**
+   * Sample solar exposure at a set of points.
+   *
+   * Provide **exactly one** timing mode: `dateTime` (a single instant →
+   * `mode: "instant"`, results in `W/m²`), or `startDate` + `endDate` (a range
+   * → `mode: "range"`, results aggregated in `kWh/m²`). `results` is paged —
+   * follow `nextCursor` until it is `null`. Each point's optional `normal`
+   * gives plane-of-array irradiance; omit it for a horizontal sample.
+   *
+   * @param args - {@linkcode PluginSolarSampleGridArgs}: the `points`, exactly
+   *   one timing mode (`dateTime` XOR `startDate`+`endDate`), and an optional
+   *   `includeHourlyArtifact` to attach a downloadable per-hour series.
+   * @returns A {@linkcode PluginSolarSampleGridResult} — the run `status`,
+   *   `mode`/`units`, provenance (`weather`, `modelRevision`, `inputHash`),
+   *   this page of `results`, an optional `hourlyArtifact`, and `nextCursor`.
+   * @throws When the project has no geo-located site (no location to sample
+   *   solar exposure for).
+   *
+   * @examplePrompt What's the irradiance at these facade points at noon on June 21?
+   * @examplePrompt How shaded are these balcony points across the summer?
+   * @examplePrompt Sample direct sun visibility at these roof points right now
+   *
+   * # Example
+   * ```ts
+   * const grid = await snaptrude.analysis.solar.sampleGrid({
+   *   points: [
+   *     { id: "a", position: [0, 3, 0] },
+   *     { id: "b", position: [5, 3, 0], normal: [0, 0, 1] },
+   *   ],
+   *   dateTime: "2026-06-21T12:00:00+05:30",
+   * })
+   * for (const r of grid.results) {
+   *   console.log(r.id, r.directSunVisible, r.totalIrradiance, grid.units)
+   * }
+   * ```
+   */
+  public abstract sampleGrid(
+    args: PluginSolarSampleGridArgs,
+  ): PluginApiReturn<PluginSolarSampleGridResult>
+}
+
+/**
+ * Status of a {@linkcode PluginAnalysisSolarApi.sampleGrid} run.
+ *
+ * | Value | Meaning |
+ * |---|---|
+ * | `"running"` | The job is in flight — poll again |
+ * | `"complete"` | Results are final |
+ * | `"cancelled"` | The run was cancelled |
+ * | `"failed"` | The run failed |
+ */
+export const PluginSolarRunStatus = z.enum([
+  "running",
+  "complete",
+  "cancelled",
+  "failed",
+])
+export type PluginSolarRunStatus = z.infer<typeof PluginSolarRunStatus>
+
+/**
+ * Timing mode of the run — chosen by which timing args were supplied.
+ *
+ * | Value | Meaning |
+ * |---|---|
+ * | `"instant"` | Single `dateTime` — irradiance in `W/m²` |
+ * | `"range"` | `startDate`+`endDate` — irradiance aggregated in `kWh/m²` |
+ */
+export const PluginSolarSampleMode = z.enum(["instant", "range"])
+export type PluginSolarSampleMode = z.infer<typeof PluginSolarSampleMode>
+
+/**
+ * Irradiance units of the results — `W/m²` (instant) or `kWh/m²` (range).
+ */
+export const PluginSolarUnits = z.enum(["W/m2", "kWh/m2"])
+export type PluginSolarUnits = z.infer<typeof PluginSolarUnits>
+
+/**
+ * Downloadable per-hour artifact (present only when `includeHourlyArtifact`).
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `url` | `string` | Signed download URL |
+ * | `format` | `"parquet" \| "csv-gz"` | File format |
+ * | `expiresAt` | `string` | ISO 8601 expiry of the signed URL |
+ */
+export const PluginSolarHourlyArtifact = z.object({
+  url: z.string(),
+  format: z.enum(["parquet", "csv-gz"]),
+  expiresAt: z.string(),
+})
+export type PluginSolarHourlyArtifact = z.infer<
+  typeof PluginSolarHourlyArtifact
+>
+
+/**
+ * A caller-supplied point to sample.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `id` | `string` | Caller-chosen id, echoed back verbatim on the result |
+ * | `position` | `[number, number, number]` | World plan-space `[x, y, z]` |
+ * | `normal` | `[number, number, number]`? | Surface normal for plane-of-array; omit = horizontal |
+ */
+export const PluginSolarSamplePoint = z.object({
+  id: z.string(),
+  position: z.tuple([z.number(), z.number(), z.number()]),
+  normal: z.tuple([z.number(), z.number(), z.number()]).optional(),
+})
+export type PluginSolarSamplePoint = z.infer<typeof PluginSolarSamplePoint>
+
+/**
+ * Arguments for {@linkcode PluginAnalysisSolarApi.sampleGrid}.
+ *
+ * Provide **exactly one** timing mode: `dateTime` (instant) XOR
+ * `startDate`+`endDate` (range).
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `points` | {@linkcode PluginSolarSamplePoint}`[]` | Points to sample |
+ * | `dateTime` | `string`? | Instant mode: local ISO 8601 with offset |
+ * | `startDate` | `string`? | Range mode: inclusive start `"YYYY-MM-DD"` |
+ * | `endDate` | `string`? | Range mode: inclusive end `"YYYY-MM-DD"` |
+ * | `includeHourlyArtifact` | `boolean`? | Attach a downloadable per-hour series |
+ */
+export const PluginSolarSampleGridArgs = z
+  .object({
+    points: z.array(PluginSolarSamplePoint),
+    dateTime: z.string().optional(),
+    startDate: z.string().optional(),
+    endDate: z.string().optional(),
+    includeHourlyArtifact: z.boolean().optional(),
+  })
+  .superRefine((a, ctx) => {
+    const hasInstant = a.dateTime !== undefined
+    const hasStart = a.startDate !== undefined
+    const hasEnd = a.endDate !== undefined
+    const hasRange = hasStart || hasEnd
+    if (hasInstant === hasRange) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message:
+          "provide exactly one timing mode: dateTime (instant), or startDate+endDate (range)",
+      })
+    }
+    if (hasRange && !(hasStart && hasEnd)) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: "range mode requires both startDate and endDate",
+      })
+    }
+  })
+export type PluginSolarSampleGridArgs = z.infer<
+  typeof PluginSolarSampleGridArgs
+>
+
+/**
+ * One sampled point's result. Irradiance fields are in the enclosing result's
+ * `units` and are omitted when the backend did not compute them.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `id` | `string` | The point's caller-chosen id |
+ * | `directSunVisible` | `boolean` | Instant mode: sun disc visible from the point |
+ * | `shadeFraction` | `number` | `0`..`1`; range mode: fraction of sun-up hours shaded |
+ * | `directIrradiance` | `number`? | Direct component, in the result's `units` |
+ * | `diffuseIrradiance` | `number`? | Diffuse component, in the result's `units` |
+ * | `totalIrradiance` | `number`? | Total (direct + diffuse), in the result's `units` |
+ */
+export const PluginSolarSampleResult = z.object({
+  id: z.string(),
+  directSunVisible: z.boolean(),
+  shadeFraction: z.number(),
+  directIrradiance: z.number().optional(),
+  diffuseIrradiance: z.number().optional(),
+  totalIrradiance: z.number().optional(),
+})
+export type PluginSolarSampleResult = z.infer<typeof PluginSolarSampleResult>
+
+/**
+ * Result of {@linkcode PluginAnalysisSolarApi.sampleGrid} — one page.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `status` | {@linkcode PluginSolarRunStatus} | Run status |
+ * | `mode` | {@linkcode PluginSolarSampleMode} | `"instant"` or `"range"` |
+ * | `coordinateSystem` | `"world-plan-space"` | Echo of the input frame |
+ * | `modelRevision` | `string` | Geometry revision sampled against (staleness key) |
+ * | `inputHash` | `string` | Hash of points+dates+geometry (staleness key) |
+ * | `units` | {@linkcode PluginSolarUnits} | `"W/m2"` (instant) or `"kWh/m2"` (range) |
+ * | `sunUpHours` | `number` | Sun-up hours over the sampled window |
+ * | `weather` | {@linkcode PluginWeatherSourceMeta} \| `null` | Resolved weather file, or `null` |
+ * | `weatherQuality` | `string[]` | Deduped quality flags present in the consumed rows |
+ * | `results` | {@linkcode PluginSolarSampleResult}`[]` | This page of per-point results |
+ * | `hourlyArtifact` | {@linkcode PluginSolarHourlyArtifact} \| `null` | Per-hour download, or `null` |
+ * | `nextCursor` | `string \| null` | Next page cursor; `null` = last page |
+ */
+export const PluginSolarSampleGridResult = z.object({
+  status: PluginSolarRunStatus,
+  mode: PluginSolarSampleMode,
+  coordinateSystem: z.literal("world-plan-space"),
+  modelRevision: z.string(),
+  inputHash: z.string(),
+  units: PluginSolarUnits,
+  sunUpHours: z.number(),
+  weather: PluginWeatherSourceMeta.nullable(),
+  weatherQuality: z.array(z.string()),
+  results: z.array(PluginSolarSampleResult),
+  hourlyArtifact: PluginSolarHourlyArtifact.nullable(),
+  nextCursor: z.string().nullable(),
+})
+export type PluginSolarSampleGridResult = z.infer<
+  typeof PluginSolarSampleGridResult
+>

package/src/api/analysis/weather.ts

@@ -0,0 +1,179 @@
+import * as z from "zod"
+import { PluginApiReturn } from "../../types"
+
+/**
+ * Analysis weather — read the project site's typical-year weather series.
+ *
+ * Returns the hourly weather rows (temperature, humidity, wind, solar
+ * irradiance) of the EPW file the sustainability analyses compute against,
+ * resolved from the project's geo-located site. This is a **synchronous,
+ * paged read** of an already-resolved weather file — not a job: call
+ * {@linkcode PluginAnalysisWeatherApi.getSeries} for a date range, then follow
+ * `nextCursor` until it is `null`.
+ *
+ * The weather file is resolved by the **same** code path the daylight /
+ * sunlight-hours analyses use, so the `source.weatherFileId` here matches the
+ * provenance a {@linkcode PluginAnalysisDaylightApi} run echoes. Dates cross as
+ * ISO 8601 date strings (`"YYYY-MM-DD"`); each row's `timestamp` is a local
+ * ISO 8601 string **with** its UTC offset, and `utcOffsetMinutes` restates the
+ * offset so consumers never re-derive it.
+ *
+ * Reads never throw for "no data": when the project has no geo-located site
+ * (no weather file to resolve) the host surfaces that per its read contract.
+ *
+ * Accessed via `snaptrude.analysis.weather`.
+ */
+export abstract class PluginAnalysisWeatherApi {
+  constructor() {}
+
+  /**
+   * Get the hourly weather series for a date range, paged.
+   *
+   * Returns the resolved weather file's provenance (`source`) plus the weather
+   * `rows` for the requested range. The page size is backend-chosen; when
+   * `nextCursor` is a string, pass it back as `args.cursor` to fetch the next
+   * page, and stop when it is `null`.
+   *
+   * @param args - {@linkcode PluginWeatherGetSeriesArgs}: the inclusive
+   *   `startDate`/`endDate` ISO dates, an optional `interval` (`"hourly"` is
+   *   the only v1 value), and an optional `cursor` for paging.
+   * @returns A {@linkcode PluginWeatherSeriesResult} — the resolved weather
+   *   `source`, the `rows` for this page, and `nextCursor` (`null` at the end).
+   *
+   * @examplePrompt Get the weather series for June at my site
+   * @examplePrompt Pull the hourly temperature and irradiance for this location
+   * @examplePrompt What EPW weather file is my project using?
+   *
+   * # Example
+   * ```ts
+   * let cursor: string | undefined = undefined
+   * const rows = []
+   * do {
+   *   const page = await snaptrude.analysis.weather.getSeries({
+   *     startDate: "2026-06-01",
+   *     endDate: "2026-06-30",
+   *     cursor,
+   *   })
+   *   rows.push(...page.rows)
+   *   cursor = page.nextCursor ?? undefined
+   * } while (cursor)
+   * ```
+   */
+  public abstract getSeries(
+    args: PluginWeatherGetSeriesArgs,
+  ): PluginApiReturn<PluginWeatherSeriesResult>
+}
+
+/**
+ * How the weather file was matched to the project site.
+ *
+ * | Value | Meaning |
+ * |---|---|
+ * | `"nearest-station"` | Auto-resolved to the closest weather station |
+ * | `"user-upload"` | A weather file the user uploaded (`core.io.import.epw`) |
+ * | `"project-override"` | A station pinned for the project regardless of distance |
+ */
+export const PluginWeatherSelectionMethod = z.enum([
+  "nearest-station",
+  "user-upload",
+  "project-override",
+])
+export type PluginWeatherSelectionMethod = z.infer<
+  typeof PluginWeatherSelectionMethod
+>
+
+/**
+ * Provenance of the resolved weather file — where the numbers came from.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `weatherFileId` | `string` | Catalog id (same key as `core.io.import.epw`'s `weatherFileId`) |
+ * | `station` | `string` | Station/file name, e.g. `"USA_IL_Chicago-OHare.Intl.AP.725300_TMY3"` |
+ * | `sourceId` | `string` | WMO/station identifier from the EPW header |
+ * | `distanceKm` | `number \| null` | Station → project site distance, km; `null` for pinned project-override files |
+ * | `selectionMethod` | {@linkcode PluginWeatherSelectionMethod} | How the file was matched |
+ * | `checksum` | `string` | sha256 of the EPW file — the provenance key |
+ * | `windReferenceHeightM` | `number` | Anemometer height the wind rows are valid at |
+ */
+export const PluginWeatherSourceMeta = z.object({
+  weatherFileId: z.string(),
+  station: z.string(),
+  sourceId: z.string(),
+  distanceKm: z.number().nullable(),
+  selectionMethod: PluginWeatherSelectionMethod,
+  checksum: z.string(),
+  windReferenceHeightM: z.number(),
+})
+export type PluginWeatherSourceMeta = z.infer<typeof PluginWeatherSourceMeta>
+
+/**
+ * One hourly weather reading.
+ *
+ * `flags` is empty for a clean measured/typical value; known flag strings are
+ * `"missing"`, `"substituted"`, and `"interpolated"` (kept as `string[]` so the
+ * backend can add flag kinds without a contract break).
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `timestamp` | `string` | Local ISO 8601 with offset, e.g. `"2026-06-21T14:00:00+05:30"` |
+ * | `utcOffsetMinutes` | `number` | UTC offset in minutes (restates the timestamp's offset) |
+ * | `dryBulbC` | `number` | Dry-bulb temperature, °C |
+ * | `relativeHumidityPercent` | `number` | Relative humidity, % |
+ * | `windSpeedMps` | `number` | Wind speed, m/s (at `source.windReferenceHeightM`) |
+ * | `ghiWm2` | `number` | Global horizontal irradiance, W/m² |
+ * | `dniWm2` | `number` | Direct normal irradiance, W/m² |
+ * | `dhiWm2` | `number` | Diffuse horizontal irradiance, W/m² |
+ * | `flags` | `string[]` | Quality flags; `[]` = clean value |
+ */
+export const PluginWeatherRow = z.object({
+  timestamp: z.string(),
+  utcOffsetMinutes: z.number(),
+  dryBulbC: z.number(),
+  relativeHumidityPercent: z.number(),
+  windSpeedMps: z.number(),
+  ghiWm2: z.number(),
+  dniWm2: z.number(),
+  dhiWm2: z.number(),
+  flags: z.array(z.string()),
+})
+export type PluginWeatherRow = z.infer<typeof PluginWeatherRow>
+
+/**
+ * Arguments for {@linkcode PluginAnalysisWeatherApi.getSeries}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `startDate` | `string` | Inclusive range start, ISO `"YYYY-MM-DD"` |
+ * | `endDate` | `string` | Inclusive range end, ISO `"YYYY-MM-DD"` |
+ * | `interval` | `"hourly"`? | Sampling interval; `"hourly"` is the only v1 value |
+ * | `cursor` | `string`? | Paging cursor from a prior page's `nextCursor` |
+ */
+export const PluginWeatherGetSeriesArgs = z.object({
+  startDate: z.string(),
+  endDate: z.string(),
+  interval: z.enum(["hourly"]).optional(),
+  cursor: z.string().optional(),
+})
+export type PluginWeatherGetSeriesArgs = z.infer<
+  typeof PluginWeatherGetSeriesArgs
+>
+
+/**
+ * Result of {@linkcode PluginAnalysisWeatherApi.getSeries} — one page.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `source` | {@linkcode PluginWeatherSourceMeta} | The resolved weather file's provenance |
+ * | `rows` | {@linkcode PluginWeatherRow}`[]` | Weather rows for this page |
+ * | `nextCursor` | `string \| null` | Pass back as `args.cursor`; `null` = last page |
+ * | `warnings` | `string[]`? | Degradation notices (e.g. `"override lookup failed; served nearest-station"`); omitted when the page is clean |
+ */
+export const PluginWeatherSeriesResult = z.object({
+  source: PluginWeatherSourceMeta,
+  rows: z.array(PluginWeatherRow),
+  nextCursor: z.string().nullable(),
+  warnings: z.array(z.string()).optional(),
+})
+export type PluginWeatherSeriesResult = z.infer<
+  typeof PluginWeatherSeriesResult
+>

package/src/api/core/camera/index.ts

@@ -0,0 +1,251 @@
+import * as z from "zod"
+import { PluginApiReturn } from "../../../types"
+import { Vec3Handle } from "../../../handles"
+
+/**
+ * Camera controls.
+ *
+ * Position the viewport camera, snap it to a standard orthographic/isometric
+ * view, and toggle between the 2D (plan) and 3D modelling modes — mirrors the
+ * canvas view menu and the 2D/3D toggle. Like {@linkcode PluginZoomApi}, these
+ * are transient VIEW-STATE changes: they are not model edits, so they are not
+ * write-gated and are not undoable. Accessed via `snaptrude.core.camera`.
+ */
+export abstract class PluginCameraApi {
+  constructor() {}
+
+  /**
+   * Point the camera: place its eye at `eye` looking toward `target` (world
+   * coordinates, internal `babylon` units). View-state only — not undoable.
+   *
+   * @param eye - Camera position as a {@linkcode Vec3Handle}
+   * @param target - Point the camera looks at as a {@linkcode Vec3Handle}
+   * @returns `true` once the camera has been positioned.
+   *
+   * @examplePrompt Look at the model from above the north-east corner
+   * @examplePrompt Position the camera at (50, 30, 50) looking at the origin
+   * @examplePrompt Point the camera at the centre of the building from the side
+   * @examplePrompt Set the eye to this point and aim it at that point
+   *
+   * # Example
+   * ```ts
+   * const { vec3 } = snaptrude.core.math
+   * await snaptrude.core.camera.lookFrom(vec3.new(50, 30, 50), vec3.new(0, 0, 0))
+   * ```
+   */
+  public abstract lookFrom(
+    eye: Vec3Handle,
+    target: Vec3Handle,
+  ): PluginApiReturn<boolean>
+
+  /**
+   * Snap the camera to a standard view — the five orthographic elevations
+   * (`top` / `front` / `back` / `left` / `right`) or the 3D `iso` (isometric
+   * perspective) view. Mirrors the canvas view menu. View-state only — not
+   * undoable. The orthographic presets exit 2D mode first if needed.
+   *
+   * @param view - The standard view to snap to ({@linkcode PluginStandardView})
+   * @returns `true` once the view has been applied.
+   *
+   * @examplePrompt Switch to the top view
+   * @examplePrompt Show me the front elevation
+   * @examplePrompt Go to the isometric view
+   * @examplePrompt Look at the model from the left
+   * @examplePrompt Give me a plan view from the top
+   *
+   * # Example
+   * ```ts
+   * await snaptrude.core.camera.setStandardView("top")
+   * ```
+   */
+  public abstract setStandardView(
+    view: PluginStandardView,
+  ): PluginApiReturn<boolean>
+
+  /**
+   * Toggle the modelling mode between `2d` (plan) and `3d`. Mirrors the canvas
+   * 2D/3D toggle: `3d` enters the isometric perspective view, `2d` drops to the
+   * orthographic plan of the active storey. View-state only — not undoable.
+   *
+   * @param mode - `"2d"` or `"3d"` ({@linkcode PluginCameraMode})
+   * @returns `true` once the mode switch has been requested.
+   *
+   * @examplePrompt Switch to 3D view
+   * @examplePrompt Drop into 2D plan mode
+   * @examplePrompt Go back to 3D
+   * @examplePrompt Show the floor plan in 2D
+   *
+   * # Example
+   * ```ts
+   * await snaptrude.core.camera.setMode("3d")
+   * ```
+   */
+  public abstract setMode(mode: PluginCameraMode): PluginApiReturn<boolean>
+
+  /**
+   * Read the camera's current projection: `"perspective"` (the default 3D
+   * view) or `"orthographic"`. In 2D (plan) mode this always reports
+   * `"orthographic"` — a plan is an orthographic projection.
+   *
+   * @returns The current {@linkcode PluginCameraProjection}.
+   *
+   * @examplePrompt Is the camera in perspective or orthographic?
+   * @examplePrompt What projection is the 3D view using?
+   * @examplePrompt Check whether perspective is on
+   *
+   * # Example
+   * ```ts
+   * const projection = await snaptrude.core.camera.getProjection()
+   * console.log(projection) // "perspective" | "orthographic"
+   * ```
+   */
+  public abstract getProjection(): PluginApiReturn<PluginCameraProjection>
+
+  /**
+   * Switch the 3D camera between `"perspective"` and `"orthographic"`
+   * projection — the Perspective/Orthographic control in the Design tab's
+   * View Settings panel. Like {@linkcode PluginCameraApi.setMode}, this is a
+   * transient view-state change: not write-gated, not undoable.
+   *
+   * In 2D (plan) mode the canvas is always an orthographic plan:
+   * `"orthographic"` is accepted as a no-op, while `"perspective"` is
+   * rejected — switch to 3D first via `setMode("3d")`.
+   *
+   * @param projection - `"perspective"` or `"orthographic"` ({@linkcode PluginCameraProjection})
+   * @returns `true` once the projection has been applied.
+   *
+   * @examplePrompt Switch the camera to orthographic
+   * @examplePrompt Turn perspective off
+   * @examplePrompt Give me a perspective view of the model
+   * @examplePrompt Make the 3D view orthographic like an axonometric drawing
+   *
+   * # Example
+   * ```ts
+   * await snaptrude.core.camera.setProjection("orthographic")
+   * const projection = await snaptrude.core.camera.getProjection() // "orthographic"
+   * ```
+   */
+  public abstract setProjection(
+    projection: PluginCameraProjection,
+  ): PluginApiReturn<boolean>
+
+  /**
+   * Zoom (fit) the camera to all geometry in the scene — the "zoom extents"
+   * action. View-state only — not undoable. Canonical home of the zoom-extents
+   * read (the deprecated `core.zoom.extents`).
+   *
+   * @returns `true` once the camera has been framed to the scene.
+   *
+   * @examplePrompt Zoom out so I can see the whole model
+   * @examplePrompt Fit everything in the view
+   * @examplePrompt Frame the entire building in the viewport
+   * @examplePrompt Do a zoom extents on the canvas
+   *
+   * # Example
+   * ```ts
+   * await snaptrude.core.camera.zoomExtents()
+   * ```
+   */
+  public abstract zoomExtents(): PluginApiReturn<boolean>
+
+  /**
+   * Zoom (fit) the camera to the current selection. View-state only — not
+   * undoable. Canonical home of the zoom-to-selection read (the deprecated
+   * `core.zoom.selection`).
+   *
+   * @returns `true` if there was a selection to frame; `false` if nothing is
+   *   selected (no-op).
+   *
+   * @examplePrompt Zoom in on what I have selected
+   * @examplePrompt Frame the selected walls in the view
+   * @examplePrompt Focus the camera on my current selection
+   * @examplePrompt Fit the view to the selected room
+   *
+   * # Example
+   * ```ts
+   * await snaptrude.core.camera.zoomSelection()
+   * ```
+   */
+  public abstract zoomSelection(): PluginApiReturn<boolean>
+}
+
+/**
+ * A standard camera view: the five orthographic elevations (`top`/`front`/
+ * `back`/`left`/`right`) or the 3D isometric perspective (`iso`).
+ */
+export const PluginStandardView = z.enum([
+  "top",
+  "front",
+  "back",
+  "left",
+  "right",
+  "iso",
+])
+export type PluginStandardView = z.infer<typeof PluginStandardView>
+
+/**
+ * The modelling mode: `2d` (orthographic plan) or `3d` (isometric perspective).
+ */
+export const PluginCameraMode = z.enum(["2d", "3d"])
+export type PluginCameraMode = z.infer<typeof PluginCameraMode>
+
+/**
+ * The 3D camera projection: `perspective` (the default) or `orthographic` —
+ * the Perspective/Orthographic control in the Design tab's View Settings panel.
+ */
+export const PluginCameraProjection = z.enum(["perspective", "orthographic"])
+export type PluginCameraProjection = z.infer<typeof PluginCameraProjection>
+
+/**
+ * Arguments for {@linkcode PluginCameraApi.lookFrom}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `eye` | {@linkcode Vec3Handle} | Camera position (world, `babylon` units) |
+ * | `target` | {@linkcode Vec3Handle} | Point the camera looks at |
+ */
+export const PluginCameraLookFromArgs = z.object({
+  eye: Vec3Handle,
+  target: Vec3Handle,
+})
+export type PluginCameraLookFromArgs = z.infer<typeof PluginCameraLookFromArgs>
+
+/**
+ * Arguments for {@linkcode PluginCameraApi.setStandardView}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `view` | {@linkcode PluginStandardView} | The standard view to snap to |
+ */
+export const PluginCameraSetStandardViewArgs = z.object({
+  view: PluginStandardView,
+})
+export type PluginCameraSetStandardViewArgs = z.infer<
+  typeof PluginCameraSetStandardViewArgs
+>
+
+/**
+ * Arguments for {@linkcode PluginCameraApi.setMode}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `mode` | {@linkcode PluginCameraMode} | `"2d"` or `"3d"` |
+ */
+export const PluginCameraSetModeArgs = z.object({
+  mode: PluginCameraMode,
+})
+export type PluginCameraSetModeArgs = z.infer<typeof PluginCameraSetModeArgs>
+
+/**
+ * Arguments for {@linkcode PluginCameraApi.setProjection}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `projection` | {@linkcode PluginCameraProjection} | `"perspective"` or `"orthographic"` |
+ */
+export const PluginCameraSetProjectionArgs = z.object({
+  projection: PluginCameraProjection,
+})
+export type PluginCameraSetProjectionArgs = z.infer<
+  typeof PluginCameraSetProjectionArgs
+>