@snaptrude/plugin-core 0.7.0 → 0.8.0

package/src/api/design/furniture/index.ts

@@ -1,19 +1,78 @@
 import * as z from "zod"
 import { PluginApiReturn } from "../../../types"
+import { ComponentHandle } from "../../../handles"
+import { PluginDesignChangeResult } from "../lock"
 
 /**
  * `snaptrude.design.furniture` — the placeable furniture **catalog** (a library of
- * source items, NOT scene entities). Placement lives at `design.create.furniture`
- * (returns a {@linkcode ComponentHandle}); reads of placed furniture live at
- * `design.query.listFurniture`/`getProperties`.
+ * source items, NOT scene entities) plus dimension reads/edits of PLACED furniture.
+ * Placement lives at `design.create.furniture` (returns a {@linkcode ComponentHandle});
+ * generic reads of placed furniture live at `design.query.listFurniture`/`getProperties`.
  *
  * Catalog items are plain value records ({@linkcode PluginFurnitureCatalogItem}) keyed
  * by a library id (team `_id` or general `fullName`) — not handles. Reads are async
  * (network-backed) but carry no `Async` suffix (§6.6).
+ *
+ * {@linkcode PluginDesignFurnitureApi.getDimensions} / {@linkcode PluginDesignFurnitureApi.setDimensions}
+ * target a PLACED furniture {@linkcode ComponentHandle} (not a catalog id) — `length`
+ * along the object, `width` across it, `height` up. Values are engine units, matching
+ * the length/width/height fields the furniture properties panel shows.
  */
 export abstract class PluginDesignFurnitureApi {
   constructor() {}
 
+  /**
+   * Get the dimensions of a PLACED furniture item — `length` (along the object),
+   * `width` (across it) and `height` (vertical), in engine units. Mirrors the
+   * Length/Width/Height fields of the furniture properties panel.
+   *
+   * @param item The placed furniture to query
+   * @returns The dimensions, or `null` if the geometry is degenerate
+   *
+   * @examplePrompt How big is this sofa?
+   * @examplePrompt What are the dimensions of the selected furniture?
+   * @examplePrompt Measure the length, width and height of this table
+   * @examplePrompt Get the size of the chair I just placed
+   *
+   * # Example
+   * ```ts
+   * const [item] = await snaptrude.design.query.listFurniture({ isSelected: true })
+   * const dims = await snaptrude.design.furniture.getDimensions(item)
+   * if (dims) console.log(dims.length, dims.width, dims.height)
+   * ```
+   */
+  public abstract getDimensions(
+    item: ComponentHandle
+  ): PluginApiReturn<PluginFurnitureDimensions | null>
+
+  /**
+   * Resize a PLACED furniture item along one or more axes — `length`, `width`
+   * and/or `height` (engine units). Omitted axes are left unchanged. Each supplied
+   * axis is an undoable command, mirroring editing the furniture properties panel.
+   *
+   * @param item The placed furniture to resize
+   * @param dimensions New `length` / `width` / `height` (each optional, engine units)
+   * @returns The affected furniture
+   *
+   * @examplePrompt Make this table 1.8m long
+   * @examplePrompt Resize the selected sofa to 2000 wide
+   * @examplePrompt Set this furniture to 800mm tall
+   * @examplePrompt Change the desk to 1500 long and 700 deep
+   *
+   * # Example
+   * ```ts
+   * const [item] = await snaptrude.design.query.listFurniture({ isSelected: true })
+   * const { affected } = await snaptrude.design.furniture.setDimensions(item, {
+   *   length: 1800,
+   *   height: 750
+   * })
+   * ```
+   */
+  public abstract setDimensions(
+    item: ComponentHandle,
+    dimensions: PluginFurnitureDimensionUpdates
+  ): PluginApiReturn<PluginDesignChangeResult>
+
   /**
    * List the categories (Living, Bedroom, Kitchen, …) that organize the
    * furniture catalog — the picker taxonomy, merged from built-in categories,
@@ -159,3 +218,68 @@ export type PluginDesignFurnitureGetCatalogItemArgs = z.infer<
 
 export const PluginDesignFurnitureExistsArgs = PluginDesignFurnitureGetCatalogItemArgs
 export type PluginDesignFurnitureExistsArgs = z.infer<typeof PluginDesignFurnitureExistsArgs>
+
+// ---------------------------------------------------------------------------
+// placed-furniture dimensions
+// ---------------------------------------------------------------------------
+
+/**
+ * A placed furniture item's dimensions (engine units).
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `length` | `number` | Along the object (panel "Length") |
+ * | `width` | `number` | Across the object (panel "Width") |
+ * | `height` | `number` | Vertical (panel "Height") |
+ */
+export const PluginFurnitureDimensions = z.object({
+  length: z.number(),
+  width: z.number(),
+  height: z.number(),
+})
+export type PluginFurnitureDimensions = z.infer<typeof PluginFurnitureDimensions>
+
+/**
+ * Arguments for {@linkcode PluginDesignFurnitureApi.getDimensions}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `item` | {@linkcode ComponentHandle} | The placed furniture to query |
+ */
+export const PluginDesignFurnitureItemArgs = z.object({
+  item: ComponentHandle,
+})
+export type PluginDesignFurnitureItemArgs = z.infer<typeof PluginDesignFurnitureItemArgs>
+
+/**
+ * A partial dimension patch — each axis is optional; omitted axes are unchanged.
+ * Every supplied axis must be a positive engine-unit length.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `length` | `number`? | New length along the object (engine units, > 0) |
+ * | `width` | `number`? | New width across the object (engine units, > 0) |
+ * | `height` | `number`? | New height (engine units, > 0) |
+ */
+export const PluginFurnitureDimensionUpdates = z.object({
+  length: z.number().positive().optional(),
+  width: z.number().positive().optional(),
+  height: z.number().positive().optional(),
+})
+export type PluginFurnitureDimensionUpdates = z.infer<typeof PluginFurnitureDimensionUpdates>
+
+/**
+ * Arguments for {@linkcode PluginDesignFurnitureApi.setDimensions}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `item` | {@linkcode ComponentHandle} | The placed furniture to resize |
+ * | `dimensions` | {@linkcode PluginFurnitureDimensionUpdates} | The axes to change (each optional) |
+ */
+export const PluginDesignFurnitureSetDimensionsArgs = z.object({
+  item: ComponentHandle,
+  dimensions: PluginFurnitureDimensionUpdates,
+})
+export type PluginDesignFurnitureSetDimensionsArgs = z.infer<
+  typeof PluginDesignFurnitureSetDimensionsArgs
+>

package/src/api/design/index.ts

@@ -13,6 +13,8 @@ import { PluginDesignBooleanApi } from "./boolean"
 import { PluginDesignTransformApi } from "./transform"
 import { PluginDesignEditApi } from "./edit"
 import { PluginDesignUpdateApi } from "./update"
+import { PluginDesignVisibilityApi } from "./visibility"
+import { PluginDesignTypesApi } from "./types"
 import { PluginDesignChangeResult } from "./lock"
 
 /**
@@ -27,6 +29,8 @@ import { PluginDesignChangeResult } from "./lock"
  * - {@linkcode PluginDesignApi.boolean} — CSG boolean ops (union / subtract / intersect)
  * - {@linkcode PluginDesignApi.erase} — plan-level adjacency-edge erase (NOT hard delete)
  * - {@linkcode PluginDesignApi.delete} — hard entity removal
+ * - {@linkcode PluginDesignApi.visibility} — hide / isolate / reveal entities
+ * - {@linkcode PluginDesignApi.types} — read-only building type / assembly reference
  * - {@linkcode PluginDesignApi.lock} / {@linkcode PluginDesignApi.unlock} / {@linkcode PluginDesignApi.isLocked} / {@linkcode PluginDesignApi.listLocked} — lock state (top-level design verbs, §2A.1)
  * - {@linkcode PluginDesignApi.lockArea} / {@linkcode PluginDesignApi.unlockArea} / {@linkcode PluginDesignApi.isAreaLocked} / {@linkcode PluginDesignApi.listAreaLocked} — footprint-area lock for Room/Department spaces
  *
@@ -59,6 +63,10 @@ export abstract class PluginDesignApi {
   public abstract edit: PluginDesignEditApi
   /** Update existing entities — properties + geometry. See {@linkcode PluginDesignUpdateApi}. */
   public abstract update: PluginDesignUpdateApi
+  /** Hide / isolate / reveal entities. See {@linkcode PluginDesignVisibilityApi}. */
+  public abstract visibility: PluginDesignVisibilityApi
+  /** Read-only building type / assembly reference. See {@linkcode PluginDesignTypesApi}. */
+  public abstract types: PluginDesignTypesApi
 
   /**
    * Lock entities so they cannot be edited. Undoable. Cascades to void/door/window
@@ -247,3 +255,5 @@ export * from "./boolean"
 export * from "./transform"
 export * from "./edit"
 export * from "./update"
+export * from "./visibility"
+export * from "./types"

package/src/api/design/materials/index.ts

@@ -8,7 +8,9 @@ import { ComponentHandle, MaterialHandle } from "../../../handles"
  * Materials are {@linkcode MaterialHandle}s (entity-style, name-addressed). Reads return
  * a {@linkcode MaterialHandle}/{@linkcode PluginMaterialInfo}; `apply`/`reset` mutate the
  * scene (undoable via `save`, default `true`). `create` mints a material from a
- * {@linkcode PluginMaterialSpec} (idempotent by name).
+ * {@linkcode PluginMaterialSpec} (idempotent by name). `list` reads the materials loaded
+ * in the project; `listPresets` reads the browsable preset/library catalog (handle-less
+ * {@linkcode PluginPresetMaterial} records that become materials via `create`/`apply`).
  *
  * Per-face assignment — {@linkcode PluginDesignMaterialsApi.applyToFaces} /
  * {@linkcode PluginDesignMaterialsApi.resetFaces} plus per-face reads
@@ -24,23 +26,59 @@ export abstract class PluginDesignMaterialsApi {
   constructor() {}
 
   /**
-   * List the project materials.
-   * @param scope Which library to list (optional)
+   * List the materials loaded in the project — every named material in the live
+   * scene (applied finishes, plugin-created materials, and type defaults in use).
+   * For the browsable preset/library catalog (finishes not yet in the project),
+   * use {@linkcode PluginDesignMaterialsApi.listPresets}.
+   *
    * @returns The materials as {@linkcode MaterialHandle}`[]`
    *
    * @examplePrompt List all the materials in this project
    * @examplePrompt What materials do I have available to apply?
-   * @examplePrompt Show me the preset materials library
    * @examplePrompt Which finishes exist in this model?
    * @examplePrompt Get every material in the project palette
    *
    * # Example
    * ```ts
-   * const presets = await snaptrude.design.materials.list("preset")
-   * console.log(presets.length, "preset materials")
+   * const materials = await snaptrude.design.materials.list()
+   * console.log(materials.length, "materials in the project")
    * ```
    */
-  public abstract list(scope?: "project" | "preset"): PluginApiReturn<MaterialHandle[]>
+  public abstract list(): PluginApiReturn<MaterialHandle[]>
+
+  /**
+   * List the preset material library — the catalog the app's material browser
+   * shows (the built-in finishes plus the workspace's uploaded materials),
+   * fetched from the material library service. Library entries are **not**
+   * scene materials and carry no {@linkcode MaterialHandle}; each is a named
+   * texture record. To use one, feed it to
+   * {@linkcode PluginDesignMaterialsApi.create} /
+   * {@linkcode PluginDesignMaterialsApi.apply} as a
+   * {@linkcode PluginMaterialSpec}: `{ name, textureUrl, materialType: category }`.
+   *
+   * @returns The library as {@linkcode PluginPresetMaterial}`[]` (`[]` when the
+   * library service is unreachable)
+   *
+   * @examplePrompt Show me the preset materials library
+   * @examplePrompt What wood finishes are available in the material library?
+   * @examplePrompt Browse the material catalog and apply a brick texture
+   * @examplePrompt Which preset materials can I choose from?
+   *
+   * # Example
+   * ```ts
+   * const presets = await snaptrude.design.materials.listPresets()
+   * const brick = presets.find((p) => p.category.toLowerCase().includes("brick"))
+   * if (brick) {
+   *   const walls = await snaptrude.design.query.listWalls()
+   *   await snaptrude.design.materials.apply(walls, {
+   *     name: brick.name,
+   *     textureUrl: brick.textureUrl,
+   *     materialType: brick.category,
+   *   })
+   * }
+   * ```
+   */
+  public abstract listPresets(): PluginApiReturn<PluginPresetMaterial[]>
 
   /**
    * Read a material's descriptor — its name, color, opacity, and texture
@@ -61,7 +99,43 @@ export abstract class PluginDesignMaterialsApi {
    * if (info) console.log(info.name, info.colorHex, info.alpha)
    * ```
    */
-  public abstract getInfo(material: MaterialHandle): PluginApiReturn<PluginMaterialInfo | null>
+  public abstract getInfo(
+    material: MaterialHandle,
+  ): PluginApiReturn<PluginMaterialInfo | null>
+
+  /**
+   * Read the material applied to a component **as a whole** — the eyedropper. For a
+   * uniformly-painted component this is that single material; for a per-face-painted
+   * component it is the material on the component's base/first face. Use
+   * {@linkcode PluginDesignMaterialsApi.getByFace} /
+   * {@linkcode PluginDesignMaterialsApi.listByFace} for the per-face breakdown.
+   *
+   * @param component The component to sample
+   * @returns The whole-object material as a {@linkcode PluginComponentMaterial} — its
+   * handle (chain it into `apply` / `getInfo`), engine id, name, and whether the
+   * component carries its type `default` or an explicitly `applied` finish — or `null`
+   * if the component carries no material
+   *
+   * @examplePrompt What material is on this wall?
+   * @examplePrompt Eyedrop the finish of the selected object
+   * @examplePrompt Which material does this slab use?
+   * @examplePrompt Read the material on this column so I can paint others with it
+   * @examplePrompt Is this component painted, and with what?
+   *
+   * # Example
+   * ```ts
+   * const [component] = await snaptrude.design.selection.get()
+   * const sampled = await snaptrude.design.materials.get(component)
+   * if (sampled) {
+   *   console.log(sampled.name, sampled.source) // e.g. "Brick Red" "applied"
+   *   const info = await snaptrude.design.materials.getInfo(sampled.material)
+   *   console.log(info?.colorHex)
+   * }
+   * ```
+   */
+  public abstract get(
+    component: ComponentHandle,
+  ): PluginApiReturn<PluginComponentMaterial | null>
 
   /**
    * Apply a material to one or more components — an existing project material by
@@ -90,7 +164,7 @@ export abstract class PluginDesignMaterialsApi {
   public abstract apply(
     targets: ComponentHandle[],
     material: MaterialHandle | PluginMaterialSpec,
-    save?: boolean
+    save?: boolean,
   ): PluginApiReturn<PluginMaterialResult>
 
   /**
@@ -116,7 +190,7 @@ export abstract class PluginDesignMaterialsApi {
    */
   public abstract reset(
     components: ComponentHandle[],
-    save?: boolean
+    save?: boolean,
   ): PluginApiReturn<PluginMaterialResult>
 
   /**
@@ -155,7 +229,7 @@ export abstract class PluginDesignMaterialsApi {
     component: ComponentHandle,
     faces: number[],
     material: MaterialHandle | PluginMaterialSpec,
-    save?: boolean
+    save?: boolean,
   ): PluginApiReturn<PluginMaterialResult>
 
   /**
@@ -183,7 +257,7 @@ export abstract class PluginDesignMaterialsApi {
   public abstract resetFaces(
     component: ComponentHandle,
     faces: number[],
-    save?: boolean
+    save?: boolean,
   ): PluginApiReturn<PluginMaterialResult>
 
   /**
@@ -207,7 +281,7 @@ export abstract class PluginDesignMaterialsApi {
    */
   public abstract getByFace(
     component: ComponentHandle,
-    face: number
+    face: number,
   ): PluginApiReturn<MaterialHandle | null>
 
   /**
@@ -230,7 +304,7 @@ export abstract class PluginDesignMaterialsApi {
    * ```
    */
   public abstract listByFace(
-    component: ComponentHandle
+    component: ComponentHandle,
   ): PluginApiReturn<PluginFaceMaterial[]>
 
   /**
@@ -253,7 +327,9 @@ export abstract class PluginDesignMaterialsApi {
    * await snaptrude.design.materials.apply(walls, glass)
    * ```
    */
-  public abstract create(spec: PluginMaterialSpec): PluginApiReturn<MaterialHandle>
+  public abstract create(
+    spec: PluginMaterialSpec,
+  ): PluginApiReturn<MaterialHandle>
 
   /**
    * Get the default material for a component's type.
@@ -272,7 +348,9 @@ export abstract class PluginDesignMaterialsApi {
    * if (defaultMaterial) console.log(await snaptrude.design.materials.getInfo(defaultMaterial))
    * ```
    */
-  public abstract getDefault(component: ComponentHandle): PluginApiReturn<MaterialHandle | null>
+  public abstract getDefault(
+    component: ComponentHandle,
+  ): PluginApiReturn<MaterialHandle | null>
 
   /**
    * Test whether a component carries its (type) default material.
@@ -291,7 +369,9 @@ export abstract class PluginDesignMaterialsApi {
    * console.log(untouched ? "still default" : "has been painted")
    * ```
    */
-  public abstract isDefault(component: ComponentHandle): PluginApiReturn<boolean>
+  public abstract isDefault(
+    component: ComponentHandle,
+  ): PluginApiReturn<boolean>
 
   /**
    * Test whether a component has a single (uniform) material across all faces.
@@ -310,7 +390,9 @@ export abstract class PluginDesignMaterialsApi {
    * console.log(uniform ? "one material all over" : "painted per face")
    * ```
    */
-  public abstract isUniform(component: ComponentHandle): PluginApiReturn<boolean>
+  public abstract isUniform(
+    component: ComponentHandle,
+  ): PluginApiReturn<boolean>
 
   /**
    * Test whether a material has a texture.
@@ -392,18 +474,54 @@ export const PluginFaceMaterial = z.object({
 })
 export type PluginFaceMaterial = z.infer<typeof PluginFaceMaterial>
 
-/** Arguments for {@linkcode PluginDesignMaterialsApi.list}. */
-export const PluginDesignMaterialsListArgs = z.object({
-  scope: z.enum(["project", "preset"]).optional(),
+/**
+ * The material on a component **as a whole** — the eyedropper read returned by
+ * {@linkcode PluginDesignMaterialsApi.get} (value record, plus a reusable handle).
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `material` | {@linkcode MaterialHandle} | The whole-object material — chain into `apply` / `getInfo` |
+ * | `id` | `string` | Engine material id |
+ * | `name` | `string` | Material name (== the handle token) |
+ * | `source` | `"default" \| "applied"` | Whether it is the component's type default or an explicitly-applied finish |
+ */
+export const PluginComponentMaterial = z.object({
+  material: MaterialHandle,
+  id: z.string(),
+  name: z.string(),
+  source: z.enum(["default", "applied"]),
+})
+export type PluginComponentMaterial = z.infer<typeof PluginComponentMaterial>
+
+/**
+ * A preset material library entry (value record — NOT a handle), returned by
+ * {@linkcode PluginDesignMaterialsApi.listPresets}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `name` | `string` | Display name of the library entry |
+ * | `category` | `string` | Library category (camelCase, e.g. `"wood"`, `"colors"`, `"brick"`) |
+ * | `textureUrl` | `string` | Texture/swatch image URL — feed to {@linkcode PluginMaterialSpec}`.textureUrl` |
+ */
+export const PluginPresetMaterial = z.object({
+  name: z.string(),
+  category: z.string(),
+  textureUrl: z.string(),
 })
-export type PluginDesignMaterialsListArgs = z.infer<typeof PluginDesignMaterialsListArgs>
+export type PluginPresetMaterial = z.infer<typeof PluginPresetMaterial>
 
 /** Arguments for {@linkcode PluginDesignMaterialsApi.getInfo} / `hasTexture`. */
-export const PluginDesignMaterialsGetInfoArgs = z.object({ material: MaterialHandle })
-export type PluginDesignMaterialsGetInfoArgs = z.infer<typeof PluginDesignMaterialsGetInfoArgs>
+export const PluginDesignMaterialsGetInfoArgs = z.object({
+  material: MaterialHandle,
+})
+export type PluginDesignMaterialsGetInfoArgs = z.infer<
+  typeof PluginDesignMaterialsGetInfoArgs
+>
 
 /** Arguments for component-scoped predicates (`getDefault`/`isDefault`/`isUniform`). */
-export const PluginDesignMaterialsComponentArgs = z.object({ component: ComponentHandle })
+export const PluginDesignMaterialsComponentArgs = z.object({
+  component: ComponentHandle,
+})
 export type PluginDesignMaterialsComponentArgs = z.infer<
   typeof PluginDesignMaterialsComponentArgs
 >
@@ -422,18 +540,26 @@ export const PluginDesignMaterialsApplyArgs = z.object({
   material: z.union([MaterialHandle, PluginMaterialSpec]),
   save: z.boolean().optional(),
 })
-export type PluginDesignMaterialsApplyArgs = z.infer<typeof PluginDesignMaterialsApplyArgs>
+export type PluginDesignMaterialsApplyArgs = z.infer<
+  typeof PluginDesignMaterialsApplyArgs
+>
 
 /** Arguments for {@linkcode PluginDesignMaterialsApi.reset}. */
 export const PluginDesignMaterialsResetArgs = z.object({
   components: z.array(ComponentHandle),
   save: z.boolean().optional(),
 })
-export type PluginDesignMaterialsResetArgs = z.infer<typeof PluginDesignMaterialsResetArgs>
+export type PluginDesignMaterialsResetArgs = z.infer<
+  typeof PluginDesignMaterialsResetArgs
+>
 
 /** Arguments for {@linkcode PluginDesignMaterialsApi.create}. */
-export const PluginDesignMaterialsCreateArgs = z.object({ spec: PluginMaterialSpec })
-export type PluginDesignMaterialsCreateArgs = z.infer<typeof PluginDesignMaterialsCreateArgs>
+export const PluginDesignMaterialsCreateArgs = z.object({
+  spec: PluginMaterialSpec,
+})
+export type PluginDesignMaterialsCreateArgs = z.infer<
+  typeof PluginDesignMaterialsCreateArgs
+>
 
 /**
  * Arguments for {@linkcode PluginDesignMaterialsApi.applyToFaces}.
@@ -475,7 +601,8 @@ export type PluginDesignMaterialsGetByFaceArgs = z.infer<
 >
 
 /** Arguments for {@linkcode PluginDesignMaterialsApi.listByFace} (component only). */
-export const PluginDesignMaterialsListByFaceArgs = PluginDesignMaterialsComponentArgs
+export const PluginDesignMaterialsListByFaceArgs =
+  PluginDesignMaterialsComponentArgs
 export type PluginDesignMaterialsListByFaceArgs = z.infer<
   typeof PluginDesignMaterialsListByFaceArgs
 >

package/src/api/design/query/index.ts

@@ -168,6 +168,7 @@ export type PluginDesignQueryComponentsArgs = z.infer<
  * | `spaceType` | {@linkcode PluginSpaceType} | Space-type (spaces only) |
  * | `areaClass` | {@linkcode PluginAreaClass} | Area classification (spaces only) |
  * | `departmentId` | `string` | Department (masses only) |
+ * | `buildingType` | `string` | Assigned building type NAME (walls / slabs / floors / roofs / ceilings only) — the Object Properties panel's Wall/Slab/Floor/Roof/Ceiling Type dropdown value, matching the names from `design.types.list(kind)` |
  * | `isLocked` | `boolean` | Lock flag |
  * | `isHidden` | `boolean` | User-hidden flag |
  * | `isSelected` | `boolean` | Current selection state |
@@ -186,6 +187,7 @@ export const PluginEntityProperties = z
     spaceType: PluginSpaceType,
     areaClass: PluginAreaClass,
     departmentId: z.string(),
+    buildingType: z.string(),
     isLocked: z.boolean(),
     isHidden: z.boolean(),
     isSelected: z.boolean(),
@@ -201,17 +203,28 @@ export type PluginEntityProperties = z.infer<typeof PluginEntityProperties>
  * entity's type computes them (area: floors/masses/slabs/roofs/beams/columns;
  * volume: all; length: walls/beams).
  *
+ * `thickness` and `height` are the Object Properties panel's dimension reads
+ * (the same engine source `design.update.wall` / `design.update.slab` etc.
+ * write through), in engine units. `thickness`: walls (the plan thickness —
+ * present only for straight orthogonal walls, exactly when the panel shows it)
+ * and slabs/floors/roofs/ceilings (the vertical extent the panel calls
+ * Thickness). `height`: walls only.
+ *
  * | Property | Type | Description |
  * |---|---|---|
  * | `area` | `number`? | Bottom-face area |
  * | `volume` | `number`? | Solid volume |
  * | `length` | `number`? | Running length (linear elements) |
+ * | `thickness` | `number`? | Panel Thickness — walls (straight orthogonal only) and the slab family |
+ * | `height` | `number`? | Panel Height — walls only |
  * | `boundingBox` | {@linkcode BBoxComponents} | World-space AABB (always present) |
  */
 export const PluginEntityMeasurements = z.object({
   area: z.number().optional(),
   volume: z.number().optional(),
   length: z.number().optional(),
+  thickness: z.number().optional(),
+  height: z.number().optional(),
   boundingBox: BBoxComponents,
 })
 export type PluginEntityMeasurements = z.infer<typeof PluginEntityMeasurements>
@@ -755,9 +768,7 @@ export abstract class PluginDesignQueryApi {
    * }
    * ```
    */
-  public abstract exists(
-    id: ComponentHandle,
-  ): PluginApiReturn<boolean>
+  public abstract exists(id: ComponentHandle): PluginApiReturn<boolean>
 
   /**
    * Get the kind of BIM entity a handle refers to — wall, door, space, slab,
@@ -811,9 +822,7 @@ export abstract class PluginDesignQueryApi {
    * }
    * ```
    */
-  public abstract getLabel(
-    component: ComponentHandle,
-  ): PluginApiReturn<string>
+  public abstract getLabel(component: ComponentHandle): PluginApiReturn<string>
 
   /**
    * Get a serializable, persistable reference to an entity. Under the all-handle
@@ -897,13 +906,16 @@ export abstract class PluginDesignQueryApi {
    * Read an entity's common properties as a {@linkcode PluginEntityProperties}
    * record (only applicable fields are present). For spaces/masses this includes
    * `adjacency` — the per-entity adjacency read (bulk form:
-   * `program.adjacency.getMatrix`).
+   * `program.adjacency.getMatrix`). For walls and the slab family (slab / floor
+   * / roof / ceiling) this includes `buildingType` — the assigned building type
+   * NAME the panel's type dropdown shows, matching `design.types.list(kind)`.
    *
    * @param component - the entity's {@linkcode ComponentHandle}
    * @returns the property record
    *
    * @examplePrompt Show me all the details of the selected object
    * @examplePrompt What storey is this wall on?
+   * @examplePrompt Which wall type is assigned to this wall?
    * @examplePrompt Which department does this room belong to?
    * @examplePrompt Is this element locked or hidden?
    * @examplePrompt Get the adjacencies of this space
@@ -933,11 +945,20 @@ export abstract class PluginDesignQueryApi {
    * Measure an entity — read its area, volume, and/or running length (whichever
    * its type supports) together with its world-space bounding box in one call.
    *
+   * For walls and the slab family this also carries the Object Properties
+   * panel's dimension reads in engine units: `thickness` (walls — straight
+   * orthogonal only, exactly when the panel shows it; slabs / floors / roofs /
+   * ceilings — the vertical extent the panel calls Thickness) and `height`
+   * (walls). These are the read side of `design.update.wall` /
+   * `design.update.slab` / `.floor` / `.roof` / `.ceiling`.
+   *
    * @param component - the entity's {@linkcode ComponentHandle}
    * @returns a {@linkcode PluginEntityMeasurements}, or `null` if the entity is gone
    *
    * @examplePrompt What's the area of this room?
    * @examplePrompt How long is the selected wall?
+   * @examplePrompt How thick is this wall?
+   * @examplePrompt Get the thickness of the slab on level 2
    * @examplePrompt Get the volume of this mass
    * @examplePrompt Give me the dimensions of the selected element
    * @examplePrompt What's the floor area of the kitchen?
@@ -947,6 +968,11 @@ export abstract class PluginDesignQueryApi {
    * const [space] = await snaptrude.design.query.listSpaces()
    * const m = await snaptrude.design.query.measure(space)
    * console.log(m?.area, m?.volume)
+   *
+   * // wall dimensions — the panel's Thickness / Height, in engine units
+   * const [wall] = await snaptrude.design.query.listWalls()
+   * const wm = await snaptrude.design.query.measure(wall)
+   * console.log(wm?.thickness, wm?.height)
    * ```
    */
   public abstract measure(