@snaptrude/plugin-core 0.3.0 → 0.6.0

package/dist/api/analysis/heatmaps.d.ts

@@ -0,0 +1,234 @@
+import * as z from "zod";
+import { PluginApiReturn } from "../../types";
+import { ComponentHandle } from "../../handles";
+/**
+ * Analysis heatmaps — render plugin-computed scalar data as a heatmap.
+ *
+ * Unlike the built-in studies ({@linkcode PluginAnalysisSunlightHoursApi},
+ * {@linkcode PluginAnalysisIlluminanceApi}) where the host computes the
+ * values, here the **plugin brings its own numbers** and the host renders
+ * them. Two render modes:
+ *
+ * - {@linkcode PluginAnalysisHeatmapsApi.renderSpaces} — one flat colour per
+ *   space, painted on the space's top face (occupancy, energy use, any
+ *   per-room metric).
+ * - {@linkcode PluginAnalysisHeatmapsApi.renderGrid} — a coloured grid mesh
+ *   from point samples in world coordinates (wind, noise, microclimate — any
+ *   field sampled over an area).
+ *
+ * Shared semantics:
+ *
+ * - **Single active heatmap** — a render call **replaces** whatever heatmap
+ *   is currently showing (from either mode).
+ * - **Legend** — the host renders a legend card from
+ *   {@linkcode PluginAnalysisHeatmapOptions} (title, unit, min/max, colour
+ *   segments). Values outside `[min, max]` **clamp to the end colours** and
+ *   the legend shows `<` / `>` markers at the clamped ends.
+ * - **Ephemeral** — the heatmap is a transient overlay: never persisted,
+ *   never saved with views, and auto-cleared when a scene-mutating edit
+ *   invalidates it. Re-render after changing the model.
+ *
+ * Accessed via `snaptrude.analysis.heatmaps`.
+ */
+export declare abstract class PluginAnalysisHeatmapsApi {
+    constructor();
+    /**
+     * Render a per-space heatmap — one flat colour per space's top face.
+     *
+     * Each entry maps a space to a scalar value; the value is mapped through
+     * the colour ramp (see {@linkcode PluginAnalysisHeatmapOptions}) and the
+     * space's top face is painted that single flat colour. Replaces any
+     * heatmap currently showing (single active heatmap). Spaces whose top
+     * face is not flat (pitched/sloped tops) are **skipped with a console
+     * warning** — the rest of the heatmap still renders.
+     *
+     * The heatmap is ephemeral: it is auto-cleared by scene-mutating edits
+     * and is never persisted or saved with views.
+     *
+     * @param entries - One {@linkcode PluginAnalysisHeatmapSpaceEntry} per
+     *   space: the space's handle and its scalar value.
+     * @param options - {@linkcode PluginAnalysisHeatmapOptions} — legend
+     *   title/unit, explicit min/max range (auto-derived from the data when
+     *   omitted), and the colour ramp.
+     * @returns A {@linkcode PluginAnalysisHeatmapsRenderResult} —
+     *   `{ success: true }` once the heatmap is rendered.
+     * @throws When `entries` is empty or a handle does not resolve to a space.
+     * @throws When no space had a flat top face to paint (every entry was
+     *   skipped).
+     * @throws When `options.min` is greater than `options.max`.
+     * @throws When a colour in `options.colors` is not a 6-digit hex colour.
+     * @throws When plugin writes are disabled.
+     *
+     * @examplePrompt Color each room by its occupancy count
+     * @examplePrompt Show my energy simulation results as a heatmap per space
+     * @examplePrompt Paint the rooms red to blue by temperature
+     *
+     * # Example
+     * ```ts
+     * const spaces = await snaptrude.design.query.listSpaces()
+     * await snaptrude.analysis.heatmaps.renderSpaces(
+     *   spaces.map((space) => ({ space, value: occupancy[space] ?? 0 })),
+     *   { title: "Occupancy", unit: "people", min: 0, max: 50 },
+     * )
+     * ```
+     */
+    abstract renderSpaces(entries: PluginAnalysisHeatmapSpaceEntry[], options?: PluginAnalysisHeatmapOptions): PluginApiReturn<PluginAnalysisHeatmapsRenderResult>;
+    /**
+     * Render a grid heatmap — a coloured mesh from point samples.
+     *
+     * Each cell is a scalar sample at a **world-coordinate** position
+     * (**y is up** — a ground-level field sits at `y = 0`); the host builds
+     * one square cell of edge `cellSize` per sample — in the same Snaptrude
+     * internal units as `position` (convert real-world lengths via
+     * {@linkcode PluginUnitsApi.convert}) — coloured by mapping the value
+     * through the colour ramp
+     * (see {@linkcode PluginAnalysisHeatmapOptions}). This is the mode for
+     * field data — wind, noise, microclimate — sampled over an area. Replaces
+     * any heatmap currently showing (single active heatmap).
+     *
+     * The heatmap is ephemeral: it is auto-cleared by scene-mutating edits
+     * and is never persisted or saved with views.
+     *
+     * @param cells - One {@linkcode PluginAnalysisHeatmapGridCell} per
+     *   sample: a world-coordinate `position` (y up) and its scalar `value`.
+     * @param cellSize - Edge length of each (square) cell, in the same
+     *   Snaptrude internal units as `position` (see
+     *   {@linkcode PluginUnitsApi.convert}). Must be a positive, finite number.
+     * @param options - {@linkcode PluginAnalysisHeatmapOptions} — legend
+     *   title/unit, explicit min/max range (auto-derived from the data when
+     *   omitted), and the colour ramp.
+     * @returns A {@linkcode PluginAnalysisHeatmapsRenderResult} —
+     *   `{ success: true }` once the heatmap is rendered.
+     * @throws When `cells` is empty or `cellSize` is not a positive, finite number.
+     * @throws When `options.min` is greater than `options.max`.
+     * @throws When a colour in `options.colors` is not a 6-digit hex colour.
+     * @throws When plugin writes are disabled.
+     *
+     * @examplePrompt Overlay my CFD wind simulation results on the site
+     * @examplePrompt Render a noise-level grid around the building
+     * @examplePrompt Show these sampled microclimate values as a colored grid
+     *
+     * # Example
+     * ```ts
+     * // World coordinates are y-up: a ground-level field varies in x/z at y = 0.
+     * await snaptrude.analysis.heatmaps.renderGrid(
+     *   samples.map((s) => ({ position: { x: s.x, y: 0, z: s.z }, value: s.windSpeed })),
+     *   2, // 2-unit square cells
+     *   { title: "Wind speed", unit: "m/s", colors: ["#0000ff", "#00ff00", "#ff0000"] },
+     * )
+     * ```
+     */
+    abstract renderGrid(cells: PluginAnalysisHeatmapGridCell[], cellSize: number, options?: PluginAnalysisHeatmapOptions): PluginApiReturn<PluginAnalysisHeatmapsRenderResult>;
+    /**
+     * Clear the plugin heatmap from the scene.
+     *
+     * Un-applies the rendered heatmap (either mode) and removes its legend.
+     * A no-op (returns `false`) when no plugin heatmap is showing. Does not
+     * touch the built-in study heatmaps (`sunlightHours` / `illuminance`) —
+     * they have their own `reset`.
+     *
+     * @returns `true` when a heatmap was cleared, `false` when none was
+     *   showing.
+     * @throws When plugin writes are disabled.
+     *
+     * @examplePrompt Clear my custom heatmap
+     * @examplePrompt Remove the wind overlay from the model
+     * @examplePrompt Reset the plugin heatmap view
+     *
+     * # Example
+     * ```ts
+     * await snaptrude.analysis.heatmaps.reset()
+     * ```
+     */
+    abstract reset(): PluginApiReturn<boolean>;
+    /**
+     * Is a plugin heatmap currently showing?
+     *
+     * `true` between a successful render and the next
+     * {@linkcode PluginAnalysisHeatmapsApi.reset} — or the scene-mutating
+     * edit that auto-clears it (heatmaps are ephemeral).
+     *
+     * @returns `true` when a plugin heatmap is rendered on the scene.
+     *
+     * @examplePrompt Is my heatmap still showing?
+     * @examplePrompt Check whether the custom heatmap is active
+     * @examplePrompt Do I need to re-render the wind overlay?
+     *
+     * # Example
+     * ```ts
+     * if (!(await snaptrude.analysis.heatmaps.isActive())) {
+     *   await snaptrude.analysis.heatmaps.renderGrid(cells, 2)
+     * }
+     * ```
+     */
+    abstract isActive(): PluginApiReturn<boolean>;
+}
+/**
+ * One space's entry in {@linkcode PluginAnalysisHeatmapsApi.renderSpaces}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `space` | {@linkcode ComponentHandle} | Handle of the space to colour |
+ * | `value` | `number` | The scalar value mapped to a colour |
+ */
+export declare const PluginAnalysisHeatmapSpaceEntry: z.ZodObject<{
+    space: z.ZodPipe<z.ZodString, z.ZodTransform<ComponentHandle, string>>;
+    value: z.ZodNumber;
+}, z.core.$strip>;
+export type PluginAnalysisHeatmapSpaceEntry = z.infer<typeof PluginAnalysisHeatmapSpaceEntry>;
+/**
+ * One grid sample in {@linkcode PluginAnalysisHeatmapsApi.renderGrid}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `position` | `{ x, y, z }` | Cell centre in **world coordinates** (y is up) |
+ * | `value` | `number` | The scalar value mapped to a colour |
+ */
+export declare const PluginAnalysisHeatmapGridCell: z.ZodObject<{
+    position: z.ZodObject<{
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+        z: z.ZodNumber;
+    }, z.core.$strip>;
+    value: z.ZodNumber;
+}, z.core.$strip>;
+export type PluginAnalysisHeatmapGridCell = z.infer<typeof PluginAnalysisHeatmapGridCell>;
+/**
+ * Display options shared by both heatmap render modes.
+ *
+ * The colour ramp maps values to colours: `colors` is an **ordered list of
+ * hex colour stops, low → high** (e.g. `["#0000ff", "#ff0000"]`). When
+ * omitted, the host's default blue → cyan → green → yellow → red ramp is used. Values outside
+ * `[min, max]` clamp to the end colours; the legend marks the clamped ends
+ * with `<` / `>`. `min`/`max` are auto-derived from the data when omitted.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `title` | `string \| undefined` | Legend title |
+ * | `unit` | `string \| undefined` | Unit label shown on the legend (e.g. `"m/s"`) |
+ * | `min` | `number \| undefined` | Value mapped to the first colour stop; data minimum when omitted |
+ * | `max` | `number \| undefined` | Value mapped to the last colour stop; data maximum when omitted |
+ * | `colors` | `string[] \| undefined` | Ordered 6-digit hex colour stops (e.g. `"#0000ff"`), low → high; host blue → cyan → green → yellow → red default |
+ */
+export declare const PluginAnalysisHeatmapOptions: z.ZodObject<{
+    title: z.ZodOptional<z.ZodString>;
+    unit: z.ZodOptional<z.ZodString>;
+    min: z.ZodOptional<z.ZodNumber>;
+    max: z.ZodOptional<z.ZodNumber>;
+    colors: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+export type PluginAnalysisHeatmapOptions = z.infer<typeof PluginAnalysisHeatmapOptions>;
+/**
+ * Result of {@linkcode PluginAnalysisHeatmapsApi.renderSpaces} /
+ * {@linkcode PluginAnalysisHeatmapsApi.renderGrid} — render failures throw,
+ * so a returned value always carries `success: true`.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `success` | `true` | The heatmap is rendered on the scene |
+ */
+export declare const PluginAnalysisHeatmapsRenderResult: z.ZodObject<{
+    success: z.ZodLiteral<true>;
+}, z.core.$strip>;
+export type PluginAnalysisHeatmapsRenderResult = z.infer<typeof PluginAnalysisHeatmapsRenderResult>;
+//# sourceMappingURL=heatmaps.d.ts.map

package/dist/api/analysis/heatmaps.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"heatmaps.d.ts","sourceRoot":"","sources":["../../../src/api/analysis/heatmaps.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AACxB,OAAO,EAAE,eAAe,EAAE,MAAM,aAAa,CAAA;AAC7C,OAAO,EAAE,eAAe,EAAkB,MAAM,eAAe,CAAA;AAE/D;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,8BAAsB,yBAAyB;;IAG7C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAuCG;aACa,YAAY,CAC1B,OAAO,EAAE,+BAA+B,EAAE,EAC1C,OAAO,CAAC,EAAE,4BAA4B,GACrC,eAAe,CAAC,kCAAkC,CAAC;IAEtD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA4CG;aACa,UAAU,CACxB,KAAK,EAAE,6BAA6B,EAAE,EACtC,QAAQ,EAAE,MAAM,EAChB,OAAO,CAAC,EAAE,4BAA4B,GACrC,eAAe,CAAC,kCAAkC,CAAC;IAEtD;;;;;;;;;;;;;;;;;;;;OAoBG;aACa,KAAK,IAAI,eAAe,CAAC,OAAO,CAAC;IAEjD;;;;;;;;;;;;;;;;;;;OAmBG;aACa,QAAQ,IAAI,eAAe,CAAC,OAAO,CAAC;CACrD;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,+BAA+B;;;iBAG1C,CAAA;AACF,MAAM,MAAM,+BAA+B,GAAG,CAAC,CAAC,KAAK,CACnD,OAAO,+BAA+B,CACvC,CAAA;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,6BAA6B;;;;;;;iBAGxC,CAAA;AACF,MAAM,MAAM,6BAA6B,GAAG,CAAC,CAAC,KAAK,CACjD,OAAO,6BAA6B,CACrC,CAAA;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,4BAA4B;;;;;;iBASvC,CAAA;AACF,MAAM,MAAM,4BAA4B,GAAG,CAAC,CAAC,KAAK,CAChD,OAAO,4BAA4B,CACpC,CAAA;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,kCAAkC;;iBAE7C,CAAA;AACF,MAAM,MAAM,kCAAkC,GAAG,CAAC,CAAC,KAAK,CACtD,OAAO,kCAAkC,CAC1C,CAAA"}

package/dist/api/analysis/illuminance.d.ts

@@ -0,0 +1,145 @@
+import { PluginApiReturn } from "../../types";
+import { PluginAnalysisComputeResult, PluginAnalysisJobStateResult } from "./sunlightHours";
+/**
+ * Analysis illuminance — the daylight illuminance (lux) heatmap study.
+ *
+ * Computes interior daylight illuminance over a date range and renders the
+ * result as a heatmap on the scene. **Pro-gated**: every method that starts
+ * a run throws when the workspace is not on a Pro plan.
+ *
+ * Like {@linkcode PluginAnalysisSunlightHoursApi} (`analysis.sunlightHours`),
+ * this is an **asynchronous backend job**:
+ *
+ * 1. {@linkcode PluginAnalysisIlluminanceApi.compute} starts the job and
+ *    returns immediately.
+ * 2. Poll {@linkcode PluginAnalysisIlluminanceApi.get} until `status` is
+ *    `"active"` (heatmap rendered) — a run typically takes minutes. There is
+ *    no completion event; polling is the pattern.
+ * 3. {@linkcode PluginAnalysisIlluminanceApi.cancel} aborts an in-flight
+ *    run; {@linkcode PluginAnalysisIlluminanceApi.reset} clears a rendered
+ *    heatmap.
+ *
+ * Illuminance analyses BIM slab and roof objects (floors, roofs, …) — walls
+ * or bare Masses are not enough — and requires the 3D view. Heatmaps are invalidated by
+ * scene-mutating edits. Dates cross as ISO 8601 date strings
+ * (`"YYYY-MM-DD"`).
+ *
+ * Accessed via `snaptrude.analysis.illuminance`.
+ */
+export declare abstract class PluginAnalysisIlluminanceApi {
+    constructor();
+    /**
+     * Start a daylight-illuminance run for a date range.
+     *
+     * Starts the backend job and **returns immediately** — it does not wait
+     * for the heatmap. Poll {@linkcode PluginAnalysisIlluminanceApi.get} until
+     * `status` is `"active"`. Starting a new run while one is in flight
+     * replaces it. Shadows and the heatmap analyses are mutually exclusive in
+     * the product: starting a run disables real-time shadows and resets/cancels
+     * any {@linkcode PluginAnalysisSunlightHoursApi}
+     * (`analysis.sunlightHours`) study.
+     *
+     * @param startDate - Start of the study range, ISO date `"YYYY-MM-DD"`.
+     * @param endDate - End of the study range, ISO date `"YYYY-MM-DD"` (on or
+     *   after `startDate`).
+     * @returns A {@linkcode PluginAnalysisComputeResult} — `{ success: true }`
+     *   when the job was started. The `{ success: false, error }` arm is
+     *   reserved — not yet emitted (start failures currently throw).
+     * @throws When the workspace is not on a **Pro** plan (illuminance is a
+     *   Pro feature).
+     * @throws When the project has no geo-located site/terrain (no location to
+     *   compute daylight for — there is no fallback location).
+     * @throws When the scene has no slab or roof BIM object to analyse (walls
+     *   or bare Masses are not enough) or the editor is not in the 3D view.
+     * @throws When a date is not a parseable ISO date or the range is inverted.
+     * @throws When plugin writes are disabled.
+     *
+     * @examplePrompt Run a daylight illuminance analysis for December
+     * @examplePrompt Compute the lux levels inside the building for winter
+     * @examplePrompt How much daylight do the interior floors get?
+     *
+     * # Example
+     * ```ts
+     * const { success } = await snaptrude.analysis.illuminance.compute(
+     *   "2026-12-01",
+     *   "2026-12-31",
+     * )
+     * // poll until the heatmap is rendered
+     * let job = await snaptrude.analysis.illuminance.get()
+     * while (job?.status === "running") {
+     *   await new Promise((r) => setTimeout(r, 5000))
+     *   job = await snaptrude.analysis.illuminance.get()
+     * }
+     * ```
+     */
+    abstract compute(startDate: string, endDate: string): PluginApiReturn<PluginAnalysisComputeResult>;
+    /**
+     * Get the state of the illuminance study.
+     *
+     * The polling read for the async job started by
+     * {@linkcode PluginAnalysisIlluminanceApi.compute}. `status` values:
+     *
+     * | Status | Meaning |
+     * |---|---|
+     * | `"running"` | A run is in flight — keep polling |
+     * | `"active"` | The heatmap is rendered on the scene |
+     * | `"inactive"` | A previous run exists but its heatmap is not showing |
+     *
+     * @returns A {@linkcode PluginAnalysisJobStateResult} with the `status` and
+     *   the run's ISO `startDate`/`endDate`, or `null` when no run result is
+     *   available (the study never ran, was cancelled, or the last run failed).
+     *
+     * @examplePrompt Is the illuminance analysis done?
+     * @examplePrompt Check the status of the daylight lux run
+     * @examplePrompt What date range was the illuminance heatmap computed for?
+     *
+     * # Example
+     * ```ts
+     * const job = await snaptrude.analysis.illuminance.get()
+     * if (job?.status === "active") console.log(job.startDate, job.endDate)
+     * ```
+     */
+    abstract get(): PluginApiReturn<PluginAnalysisJobStateResult>;
+    /**
+     * Cancel the in-flight illuminance run.
+     *
+     * Aborts the backend job. A no-op (returns `false`) when nothing is
+     * running.
+     *
+     * @returns `true` when a run was cancelled, `false` when nothing was
+     *   running.
+     * @throws When plugin writes are disabled.
+     *
+     * @examplePrompt Cancel the illuminance analysis
+     * @examplePrompt Stop the running daylight computation
+     * @examplePrompt Abort the lux study
+     *
+     * # Example
+     * ```ts
+     * await snaptrude.analysis.illuminance.cancel()
+     * ```
+     */
+    abstract cancel(): PluginApiReturn<boolean>;
+    /**
+     * Clear the illuminance heatmap from the scene.
+     *
+     * Un-applies the rendered heatmap and restores the normal material view.
+     * A no-op (returns `false`) when no heatmap is showing. Does not cancel an
+     * in-flight run — use {@linkcode PluginAnalysisIlluminanceApi.cancel}.
+     *
+     * @returns `true` when a heatmap was cleared, `false` when none was
+     *   showing.
+     * @throws When plugin writes are disabled.
+     *
+     * @examplePrompt Clear the illuminance heatmap
+     * @examplePrompt Remove the daylight lux colours from the model
+     * @examplePrompt Reset the illuminance analysis view
+     *
+     * # Example
+     * ```ts
+     * await snaptrude.analysis.illuminance.reset()
+     * ```
+     */
+    abstract reset(): PluginApiReturn<boolean>;
+}
+//# sourceMappingURL=illuminance.d.ts.map

package/dist/api/analysis/illuminance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"illuminance.d.ts","sourceRoot":"","sources":["../../../src/api/analysis/illuminance.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,aAAa,CAAA;AAC7C,OAAO,EACL,2BAA2B,EAC3B,4BAA4B,EAC7B,MAAM,iBAAiB,CAAA;AAExB;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,8BAAsB,4BAA4B;;IAGhD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2CG;aACa,OAAO,CACrB,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,MAAM,GACd,eAAe,CAAC,2BAA2B,CAAC;IAE/C;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;aACa,GAAG,IAAI,eAAe,CAAC,4BAA4B,CAAC;IAEpE;;;;;;;;;;;;;;;;;;OAkBG;aACa,MAAM,IAAI,eAAe,CAAC,OAAO,CAAC;IAElD;;;;;;;;;;;;;;;;;;;OAmBG;aACa,KAAK,IAAI,eAAe,CAAC,OAAO,CAAC;CAClD"}

package/dist/api/analysis/index.d.ts

@@ -0,0 +1,44 @@
+import { PluginAnalysisSunpathApi } from "./sunpath";
+import { PluginAnalysisShadowsApi } from "./shadows";
+import { PluginAnalysisSunlightHoursApi } from "./sunlightHours";
+import { PluginAnalysisIlluminanceApi } from "./illuminance";
+import { PluginAnalysisHeatmapsApi } from "./heatmaps";
+/**
+ * Sustainability-analysis APIs.
+ *
+ * Analysis is the environmental-performance layer: sun and daylight studies
+ * computed for the project's geo-located site. The synchronous visual
+ * overlays (sun-path diagram, real-time shadows) toggle instantly; the
+ * heatmap studies (direct sunlight hours, daylight illuminance) are
+ * asynchronous backend jobs — start them, poll their state, and cancel or
+ * clear them. Shadows and the heatmap analyses are **mutually exclusive**
+ * (enabling one resets the other), exactly as in the sustainability sidebar.
+ * Site inputs (location, true north) are read via `program.site`.
+ *
+ * - {@linkcode PluginAnalysisApi.sunpath} — Toggle & query the sun-path diagram overlay
+ * - {@linkcode PluginAnalysisApi.shadows} — Toggle real-time shadows and scrub the sun's date-time
+ * - {@linkcode PluginAnalysisApi.sunlightHours} — Direct-sunlight-hours heatmap job (start / poll / cancel / clear)
+ * - {@linkcode PluginAnalysisApi.illuminance} — Daylight-illuminance heatmap job, Pro-gated (start / poll / cancel / clear)
+ * - {@linkcode PluginAnalysisApi.heatmaps} — Render plugin-computed scalar data as a heatmap (per-space / grid)
+ *
+ * Accessed via `snaptrude.analysis`.
+ */
+export declare abstract class PluginAnalysisApi {
+    /** Sun-path diagram overlay — enable/disable/isActive. See {@linkcode PluginAnalysisSunpathApi}. */
+    abstract sunpath: PluginAnalysisSunpathApi;
+    /** Real-time sun shadows + sun date-time. See {@linkcode PluginAnalysisShadowsApi}. */
+    abstract shadows: PluginAnalysisShadowsApi;
+    /** Direct-sunlight-hours heatmap job. See {@linkcode PluginAnalysisSunlightHoursApi}. */
+    abstract sunlightHours: PluginAnalysisSunlightHoursApi;
+    /** Daylight-illuminance heatmap job (Pro). See {@linkcode PluginAnalysisIlluminanceApi}. */
+    abstract illuminance: PluginAnalysisIlluminanceApi;
+    /** Plugin-supplied scalar-data heatmaps. See {@linkcode PluginAnalysisHeatmapsApi}. */
+    abstract heatmaps: PluginAnalysisHeatmapsApi;
+    constructor();
+}
+export * from "./sunpath";
+export * from "./shadows";
+export * from "./sunlightHours";
+export * from "./illuminance";
+export * from "./heatmaps";
+//# sourceMappingURL=index.d.ts.map

package/dist/api/analysis/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/api/analysis/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,wBAAwB,EAAE,MAAM,WAAW,CAAA;AACpD,OAAO,EAAE,wBAAwB,EAAE,MAAM,WAAW,CAAA;AACpD,OAAO,EAAE,8BAA8B,EAAE,MAAM,iBAAiB,CAAA;AAChE,OAAO,EAAE,4BAA4B,EAAE,MAAM,eAAe,CAAA;AAC5D,OAAO,EAAE,yBAAyB,EAAE,MAAM,YAAY,CAAA;AAEtD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,8BAAsB,iBAAiB;IACrC,oGAAoG;IACpG,SAAgB,OAAO,EAAE,wBAAwB,CAAA;IACjD,uFAAuF;IACvF,SAAgB,OAAO,EAAE,wBAAwB,CAAA;IACjD,yFAAyF;IACzF,SAAgB,aAAa,EAAE,8BAA8B,CAAA;IAC7D,4FAA4F;IAC5F,SAAgB,WAAW,EAAE,4BAA4B,CAAA;IACzD,uFAAuF;IACvF,SAAgB,QAAQ,EAAE,yBAAyB,CAAA;;CAGpD;AAED,cAAc,WAAW,CAAA;AACzB,cAAc,WAAW,CAAA;AACzB,cAAc,iBAAiB,CAAA;AAC/B,cAAc,eAAe,CAAA;AAC7B,cAAc,YAAY,CAAA"}

package/dist/api/analysis/shadows.d.ts

@@ -0,0 +1,165 @@
+import * as z from "zod";
+import { PluginApiReturn } from "../../types";
+/**
+ * Analysis shadows — real-time sun shadows in the scene.
+ *
+ * Shadows are cast for the sun position at a specific date and time at the
+ * project's geographic location. The date-time crosses this API as an **ISO
+ * 8601 date-time string** in the project's local time (e.g.
+ * `"2026-06-21T14:30"`); the engine snaps the time **down** to its half-hour
+ * grid (`14:59` → `14:30`); seconds, if provided, are discarded. The
+ * timezone is derived from the site location by the engine — do not append
+ * a UTC offset.
+ *
+ * Methods that position the sun **throw** when the project has no geo-located
+ * site/terrain — there is no fallback location. Set the site location first;
+ * read it via `program.site.getLocation`.
+ *
+ * Accessed via `snaptrude.analysis.shadows`.
+ */
+export declare abstract class PluginAnalysisShadowsApi {
+    constructor();
+    /**
+     * Turn real-time sun shadows ON, optionally at a specific date and time.
+     *
+     * Without `options.dateTime` the shadows use the current stored sun
+     * position; with it, the sun is moved first (same as
+     * {@linkcode PluginAnalysisShadowsApi.setDateTime}). Enabling shadows
+     * resets any active heatmap analysis (`sunlightHours` / `illuminance`) —
+     * they are mutually exclusive in the product.
+     *
+     * @param options - Optional `dateTime`: ISO 8601 local date-time to
+     *   position the sun at (snapped to the engine's half-hour grid).
+     * @returns `true` — shadows are enabled after the call.
+     * @throws When the project has no geo-located site/terrain.
+     * @throws When `options.dateTime` is not a parseable ISO date-time.
+     * @throws When plugin writes are disabled.
+     *
+     * @examplePrompt Turn on shadows
+     * @examplePrompt Show the shadows at 3pm on June 21st
+     * @examplePrompt Enable sun shadows for the summer solstice afternoon
+     *
+     * # Example
+     * ```ts
+     * await snaptrude.analysis.shadows.enable({ dateTime: "2026-06-21T15:00" })
+     * ```
+     */
+    abstract enable(options?: PluginAnalysisShadowsEnableOptions): PluginApiReturn<boolean>;
+    /**
+     * Turn real-time sun shadows OFF.
+     *
+     * A no-op (returns `false`) when shadows are already off. The stored sun
+     * date-time is kept for the next enable.
+     *
+     * @returns `false` — shadows are disabled after the call.
+     * @throws When plugin writes are disabled.
+     *
+     * @examplePrompt Turn off shadows
+     * @examplePrompt Hide the sun shadows
+     * @examplePrompt Disable shadow rendering in the scene
+     *
+     * # Example
+     * ```ts
+     * await snaptrude.analysis.shadows.disable()
+     * ```
+     */
+    abstract disable(): PluginApiReturn<boolean>;
+    /**
+     * Whether real-time sun shadows are currently enabled.
+     *
+     * A pure read — never mutates, never throws.
+     *
+     * @returns `true` when shadows are rendering.
+     *
+     * @examplePrompt Are shadows on?
+     * @examplePrompt Check whether sun shadows are enabled
+     * @examplePrompt Is the scene showing shadows right now?
+     *
+     * # Example
+     * ```ts
+     * const on = await snaptrude.analysis.shadows.isEnabled()
+     * ```
+     */
+    abstract isEnabled(): PluginApiReturn<boolean>;
+    /**
+     * Move the sun to a specific date and time.
+     *
+     * Takes an ISO 8601 date-time string in the project's local time; the
+     * engine snaps the time down to its half-hour grid and re-renders the shadows
+     * (when they are enabled). The engine stores no year — only the month, day,
+     * and time are applied, and the returned date-time always carries the
+     * **current year** (setting `"2020-12-21T09:30"` returns
+     * `"2026-12-21T09:30"` in 2026). Paired with
+     * {@linkcode PluginAnalysisShadowsApi.getDateTime}.
+     *
+     * @param dateTime - ISO 8601 local date-time, e.g. `"2026-12-21T09:30"`.
+     * @returns A {@linkcode PluginAnalysisShadowsDateTimeResult} — the applied
+     *   ISO date-time after half-hour snapping.
+     * @throws When the project has no geo-located site/terrain.
+     * @throws When `dateTime` is not a parseable ISO date-time.
+     * @throws When plugin writes are disabled.
+     *
+     * @examplePrompt Set the shadow time to 9:30 am on the winter solstice
+     * @examplePrompt Move the sun to noon on March 1st
+     * @examplePrompt Change the shadow study date to December 21
+     *
+     * # Example
+     * ```ts
+     * const applied = await snaptrude.analysis.shadows.setDateTime("2026-12-21T09:30")
+     * console.log(applied) // "2026-12-21T09:30" (snapped to the half-hour grid)
+     * ```
+     */
+    abstract setDateTime(dateTime: string): PluginApiReturn<PluginAnalysisShadowsDateTimeResult>;
+    /**
+     * Get the sun's current date and time.
+     *
+     * Returns the stored sun position as an ISO 8601 local date-time string —
+     * the value shadows render at (whether or not they are enabled). The engine
+     * stores no year, so the returned string always carries the **current
+     * year**, whatever year was passed to
+     * {@linkcode PluginAnalysisShadowsApi.setDateTime} (its pair).
+     *
+     * @returns A {@linkcode PluginAnalysisShadowsDateTimeResult} — the current
+     *   ISO local date-time of the sun.
+     *
+     * @examplePrompt What date and time are the shadows set to?
+     * @examplePrompt Get the current sun position date
+     * @examplePrompt Which time of day is the shadow study showing?
+     *
+     * # Example
+     * ```ts
+     * const dateTime = await snaptrude.analysis.shadows.getDateTime()
+     * ```
+     */
+    abstract getDateTime(): PluginApiReturn<PluginAnalysisShadowsDateTimeResult>;
+}
+/**
+ * Options for {@linkcode PluginAnalysisShadowsApi.enable}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `dateTime` | `string \| undefined` | ISO 8601 local date-time to position the sun at (snapped to the half-hour grid) |
+ */
+export declare const PluginAnalysisShadowsEnableOptions: z.ZodObject<{
+    dateTime: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type PluginAnalysisShadowsEnableOptions = z.infer<typeof PluginAnalysisShadowsEnableOptions>;
+/**
+ * Arguments for {@linkcode PluginAnalysisShadowsApi.setDateTime}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `dateTime` | `string` | ISO 8601 local date-time, e.g. `"2026-06-21T14:30"` |
+ */
+export declare const PluginAnalysisShadowsSetDateTimeArgs: z.ZodObject<{
+    dateTime: z.ZodString;
+}, z.core.$strip>;
+export type PluginAnalysisShadowsSetDateTimeArgs = z.infer<typeof PluginAnalysisShadowsSetDateTimeArgs>;
+/**
+ * Result of {@linkcode PluginAnalysisShadowsApi.setDateTime} /
+ * {@linkcode PluginAnalysisShadowsApi.getDateTime} — the sun's ISO 8601
+ * local date-time (minute precision, on the engine's half-hour grid).
+ */
+export declare const PluginAnalysisShadowsDateTimeResult: z.ZodString;
+export type PluginAnalysisShadowsDateTimeResult = z.infer<typeof PluginAnalysisShadowsDateTimeResult>;
+//# sourceMappingURL=shadows.d.ts.map

package/dist/api/analysis/shadows.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shadows.d.ts","sourceRoot":"","sources":["../../../src/api/analysis/shadows.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AACxB,OAAO,EAAE,eAAe,EAAE,MAAM,aAAa,CAAA;AAE7C;;;;;;;;;;;;;;;;GAgBG;AACH,8BAAsB,wBAAwB;;IAG5C;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;aACa,MAAM,CACpB,OAAO,CAAC,EAAE,kCAAkC,GAC3C,eAAe,CAAC,OAAO,CAAC;IAE3B;;;;;;;;;;;;;;;;;OAiBG;aACa,OAAO,IAAI,eAAe,CAAC,OAAO,CAAC;IAEnD;;;;;;;;;;;;;;;OAeG;aACa,SAAS,IAAI,eAAe,CAAC,OAAO,CAAC;IAErD;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2BG;aACa,WAAW,CACzB,QAAQ,EAAE,MAAM,GACf,eAAe,CAAC,mCAAmC,CAAC;IAEvD;;;;;;;;;;;;;;;;;;;;OAoBG;aACa,WAAW,IAAI,eAAe,CAAC,mCAAmC,CAAC;CACpF;AAED;;;;;;GAMG;AACH,eAAO,MAAM,kCAAkC;;iBAE7C,CAAA;AACF,MAAM,MAAM,kCAAkC,GAAG,CAAC,CAAC,KAAK,CACtD,OAAO,kCAAkC,CAC1C,CAAA;AAED;;;;;;GAMG;AACH,eAAO,MAAM,oCAAoC;;iBAE/C,CAAA;AACF,MAAM,MAAM,oCAAoC,GAAG,CAAC,CAAC,KAAK,CACxD,OAAO,oCAAoC,CAC5C,CAAA;AAED;;;;GAIG;AACH,eAAO,MAAM,mCAAmC,aAAa,CAAA;AAC7D,MAAM,MAAM,mCAAmC,GAAG,CAAC,CAAC,KAAK,CACvD,OAAO,mCAAmC,CAC3C,CAAA"}