@snaptrude/plugin-core 0.0.0-dev-20260907135026 → 0.0.0-dev-20260908074328

package/src/api/core/geom/query/brep.ts

@@ -174,11 +174,6 @@ export abstract class PluginGeomQueryBrepApi {
    * | `"line"` | `startPoint`, `endPoint`, `length` |
    * | `"arc"` | `startPoint`, `endPoint`, `centre`, `axis`, `radius`, `length` |
    * | `"circle"` | `centre`, `axis`, `radius`, `length` — a full-circle edge (e.g. a cylinder cap rim) |
-   * | `"spline"` | `startPoint`, `endPoint`, `degree`, `controlPoints`, `knots`, `length` — a free-form NURBS edge |
-   *
-   * For a `"spline"` edge, `knots` is the **expanded** knot vector — each knot
-   * repeated by its multiplicity, the textbook NURBS form — so
-   * `knots.length === controlPoints.length + degree + 1`.
    *
    * @param brep The brep the edge belongs to
    * @param edge The edge whose curve to read
@@ -189,7 +184,6 @@ export abstract class PluginGeomQueryBrepApi {
    * @examplePrompt Is this edge straight or an arc?
    * @examplePrompt Get the exact start and end points of this edge
    * @examplePrompt Measure the length of each edge of this mass
-   * @examplePrompt Read the control points of this curved edge
    *
    * # Example
    * ```ts
@@ -225,16 +219,6 @@ export abstract class PluginGeomQueryBrepApi {
         radius: number
         length: number
       }
-    | {
-        type: "spline"
-        startPoint: Vec3Components
-        endPoint: Vec3Components
-        degree: number
-        controlPoints: Vec3Components[]
-        /** Expanded by multiplicity: `controlPoints.length + degree + 1` entries. */
-        knots: number[]
-        length: number
-      }
   >
 
   /**
@@ -382,37 +366,6 @@ export abstract class PluginGeomQueryBrepApi {
    */
   public abstract getBoundingBox(brep: BrepHandle): PluginApiReturn<BBoxComponents>
 
-  /**
-   * Get the enclosed **volume** of a closed solid, integrated from its exact
-   * surfaces. Curved faces are measured analytically, not from their
-   * tessellation — a real sphere of radius 5 reports 523.6, whatever its
-   * triangle count. That makes this the reliable way to confirm a solid is the
-   * shape you intended (a torus should measure 2·π²·R·r²).
-   *
-   * Runs on the OpenCascade kernel (the first kernel call loads a wasm of tens
-   * of MB — expect a pause of seconds).
-   *
-   * @param brep The solid to measure
-   * @returns The enclosed volume in cubic raw Babylon units
-   * @throws OPERATION_FAILED if the kernel cannot compute the volume (the brep
-   *   is not a closed solid)
-   *
-   * @examplePrompt What is the volume of this mass?
-   * @examplePrompt How much concrete is in this shape?
-   * @examplePrompt Check the volume of the dome I just made
-   *
-   * # Example
-   * ```ts
-   * const [mass] = await snaptrude.design.query.listMasses()
-   * const brep = await snaptrude.design.query.geometry.getBrep(mass)
-   * if (brep) {
-   *   const volume = await snaptrude.core.geom.query.brep.getVolume(brep)
-   *   console.log("volume:", volume)
-   * }
-   * ```
-   */
-  public abstract getVolume(brep: BrepHandle): PluginApiReturn<number>
-
   /**
    * Test whether two breps are geometrically equal.
    * @param brepA First brep
@@ -581,10 +534,6 @@ export type PluginGeomQueryBrepGetBoundingBoxArgs = z.infer<
   typeof PluginGeomQueryBrepGetBoundingBoxArgs
 >
 
-/** Arguments for {@linkcode PluginGeomQueryBrepApi.getVolume}. `{ brep: BrepHandle }` */
-export const PluginGeomQueryBrepGetVolumeArgs = brepArg
-export type PluginGeomQueryBrepGetVolumeArgs = z.infer<typeof PluginGeomQueryBrepGetVolumeArgs>
-
 /**
  * Arguments for {@linkcode PluginGeomQueryBrepApi.isEqual}.
  *

package/src/api/core/geom/query/curve.ts

@@ -3,8 +3,8 @@ import { PluginApiReturn } from "../../../../types"
 import { Vec3Handle, CurveHandle, LineHandle, Vec3Components } from "../../../../handles"
 
 /**
- * Curve queries — read-only geometric questions about curves (lines, arcs and
- * splines) and the relationships between two curves (all-handle model, §11).
+ * Curve queries — read-only geometric questions about curves (lines and arcs)
+ * and the relationships between two curves (all-handle model, §11).
  *
  * Every method takes opaque curve handles ({@linkcode CurveHandle}/{@linkcode LineHandle})
  * and point handles ({@linkcode Vec3Handle}) and returns plain values — points as
@@ -13,29 +13,6 @@ import { Vec3Handle, CurveHandle, LineHandle, Vec3Components } from "../../../..
  * {@linkcode CurveHandle} (or `null` when there is no result). No query mutates its
  * inputs.
  *
- * ## Splines
- *
- * A {@linkcode CurveHandle} is a line, an arc, or a NURBS spline (minted by
- * `core.geom.create.splineFromPoints`). Every method here accepts a spline at
- * compile time, but only the reads backed by the engine's spline math answer
- * for one today. The rest throw `PRECONDITION_FAILED` ("not supported for
- * splines yet") — a typed refusal, never a quietly wrong answer.
- *
- * | Splines | Members |
- * |---|---|
- * | **supported** | {@linkcode PluginGeomQueryCurveApi.getStartPoint}, {@linkcode PluginGeomQueryCurveApi.getEndPoint}, {@linkcode PluginGeomQueryCurveApi.getLength}, {@linkcode PluginGeomQueryCurveApi.getTangent}, {@linkcode PluginGeomQueryCurveApi.listPoints}, {@linkcode PluginGeomQueryCurveApi.getNearestPoint} |
- * | **not yet** | `getMidPoint`, `getChordLength`, `getNormal`, `getProjection`, `getPointAtDistance`, `getParameterAtPoint`, `getCurvature`, `getDistanceToPoint`, `getDistanceAlong`, `listSubdivisions`, `isLinear`, `isOnCurve`, `hasPoint`, `isEqual`, `isOverlapping`, `getCommonPart`, `listIntersections`, `getMergedCurve`, `isContinuous`, `isParallel`, `getShortestGap`, `getDistanceBetween` |
- *
- * {@linkcode PluginGeomQueryCurveApi.isOverlapping} is deliberately in the
- * second row: its line/arc path falls back to structural equality, which would
- * answer a spline pair wrongly rather than not at all.
- *
- * To work around the second row, sample the curve —
- * {@linkcode PluginGeomQueryCurveApi.listPoints} then the ordinary
- * `core.math.vec3` operations — or read a spline brep edge exactly with
- * `core.geom.query.brep.getEdgeCurve`, which returns its degree, control points
- * and knots.
- *
  * Accessed via `snaptrude.core.geom.query.curve`.
  */
 export abstract class PluginGeomQueryCurveApi {

package/src/api/core/geom/query/edge.ts

@@ -69,9 +69,9 @@ export abstract class PluginGeomQueryEdgeApi {
   public abstract listVertices(edge: EdgeHandle): PluginApiReturn<VertexHandle[]>
 
   /**
-   * Get the underlying curve geometry of an edge (a line, arc or spline).
+   * Get the underlying curve geometry of an edge (a line or arc).
    * @param edge The edge to query
-   * @returns The curve as a {@linkcode CurveHandle} (`line_`, `arc_` or `spline_`), or `null` if it is a circle or unset
+   * @returns The curve as a {@linkcode CurveHandle}, or `null` if it is a circle or unset
    *
    * # Example
    * ```ts

package/src/api/core/geom/query/face.ts

@@ -59,49 +59,6 @@ export abstract class PluginGeomQueryFaceApi {
    */
   public abstract getMaterialIndex(face: FaceHandle): PluginApiReturn<number>
 
-  /**
-   * Read what KIND of surface a face lies on. This is the one read that tells a
-   * genuinely curved face from a faceted approximation of one: every face of a
-   * 200-triangle "dome" answers `"plane"`, while a real dome has faces
-   * answering `"sphere"`. Use it to confirm a curved solid actually came out
-   * curved.
-   *
-   * | Value | Surface |
-   * |---|---|
-   * | `"plane"` | Flat face |
-   * | `"cylinder"` | Cylindrical face — constant radius about an axis |
-   * | `"cone"` | Conical face — a tapered ring (a cone or frustum side) |
-   * | `"sphere"` | Spherical face |
-   * | `"torus"` | Toroidal face — the ring surface of a donut |
-   * | `"spline"` | Free-form NURBS face |
-   *
-   * Pure read: no geometry kernel is loaded.
-   *
-   * @param face The face to query
-   * @returns The surface kind (see the table), or `null` when the face carries
-   *   no surface classification
-   *
-   * @examplePrompt Is this face flat or curved?
-   * @examplePrompt Check that this dome is a real sphere, not a faceted approximation
-   * @examplePrompt What kind of surface is this face?
-   * @examplePrompt How many curved faces does this mass have?
-   *
-   * # Example
-   * ```ts
-   * const [mass] = await snaptrude.design.query.listMasses()
-   * const brep = await snaptrude.design.query.geometry.getBrep(mass)
-   * if (brep) {
-   *   const faces = await snaptrude.core.geom.query.brep.listFaces(brep)
-   *   const kinds = []
-   *   for (const face of faces) kinds.push(await snaptrude.core.geom.query.face.getSurfaceKind(face))
-   *   console.log("spherical faces:", kinds.filter((k) => k === "sphere").length)
-   * }
-   * ```
-   */
-  public abstract getSurfaceKind(
-    face: FaceHandle,
-  ): PluginApiReturn<"plane" | "cylinder" | "cone" | "sphere" | "torus" | "spline" | null>
-
   /**
    * Get a seed half-edge of a face's outer loop.
    * @param face The face to query
@@ -355,12 +312,6 @@ export type PluginGeomQueryFaceGetMaterialIndexArgs = z.infer<
   typeof PluginGeomQueryFaceGetMaterialIndexArgs
 >
 
-/** Arguments for {@linkcode PluginGeomQueryFaceApi.getSurfaceKind}. `{ face: FaceHandle }` */
-export const PluginGeomQueryFaceGetSurfaceKindArgs = faceArg
-export type PluginGeomQueryFaceGetSurfaceKindArgs = z.infer<
-  typeof PluginGeomQueryFaceGetSurfaceKindArgs
->
-
 /** Arguments for {@linkcode PluginGeomQueryFaceApi.getHalfEdge}. `{ face: FaceHandle }` */
 export const PluginGeomQueryFaceGetHalfEdgeArgs = faceArg
 export type PluginGeomQueryFaceGetHalfEdgeArgs = z.infer<typeof PluginGeomQueryFaceGetHalfEdgeArgs>

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

@@ -217,11 +217,26 @@ export abstract class PluginDesignCreateApi {
    * Create a **floor** by extruding a footprint contour by `thickness`
    * (extruded upward).
    *
+   * The parametric engine owns floor topology and may resolve the request
+   * differently than asked: drawing against existing floors can **split** the
+   * footprint into several floors, or **merge** it into a pre-existing
+   * neighbour (that floor's region grows; nothing new is created). The call
+   * honors the engine's resolution and returns **every floor that covers the
+   * requested footprint after the operation** — the newly created floor(s),
+   * and/or the pre-existing floor that absorbed it. The array is never empty
+   * on success; a lone independently-created floor comes back as `[floor]`.
+   *
+   * **Breaking change in 0.11.0** — previously returned a single
+   * {@linkcode ComponentHandle}; callers must switch to the array (the first
+   * element preserves the old single-floor behavior for simple creates).
+   *
    * @param contour - Footprint (outer + holes)
    * @param thickness - Floor thickness (> 0)
    * @param position - Offset from origin
-   * @returns the {@linkcode ComponentHandle} of the created floor
-   * @throws if the contour is invalid or the thickness is not positive
+   * @returns the {@linkcode ComponentHandle}s of every floor covering the
+   *   requested footprint after parametric resolution (created and/or absorbing)
+   * @throws if the contour is invalid, the thickness is not positive, or the
+   *   engine rejected the operation (nothing covers the footprint)
    *
    * @examplePrompt Create a floor from this room outline
    * @examplePrompt Add a 100mm thick floor over the footprint
@@ -232,14 +247,14 @@ export abstract class PluginDesignCreateApi {
    * ```ts
    * const rect = await snaptrude.core.geom.create.profileRect(5, 4)
    * const contour = await snaptrude.core.geom.create.contourFromProfile(rect)
-   * const floor = await snaptrude.design.create.floor(contour, 0.1)
+   * const [floor, ...siblings] = await snaptrude.design.create.floor(contour, 0.1)
    * ```
    */
   public abstract floor(
     contour: ContourHandle,
     thickness: number,
     position?: Vec3Handle,
-  ): PluginApiReturn<ComponentHandle>
+  ): PluginApiReturn<ComponentHandle[]>
 
   /**
    * Create a **roof** by extruding a footprint contour by `thickness`. Created
@@ -395,7 +410,13 @@ export abstract class PluginDesignCreateApi {
    *   single undo entry. The storey must already exist
    *   (`core.storeys.create` first). Default: geometry-derived — a profile
    *   drawn at y = 0 lands on storey 1; the ACTIVE storey is NOT consulted.
-   * @returns a {@linkcode ComponentHandle}`[]` (one per wall), in profile order
+   * @returns the actually-created wall {@linkcode ComponentHandle}s. The
+   *   parametric engine owns wall topology — curves touching existing walls
+   *   may merge into or split against them, so the returned count can differ
+   *   from the input curve count. Profile-ordered 1:1 matches come first,
+   *   then the remaining merged/split products in creation order. Re-query
+   *   (e.g. `design.query.spaces.listGeneratedBim`) rather than assuming a
+   *   wall per input curve.
    * @throws if the profile is empty, `wallType` names no wall type in the
    *   project, `storey` does not exist, or wall creation fails
    *
@@ -537,7 +558,9 @@ export abstract class PluginDesignCreateApi {
    *   the item's height yourself.
    * @param options - Optional placement options: `label` — instance name
    *   (default auto `${name}Ins${n}`); `createNewSourceMesh` — emit a
-   *   source-mesh creation command (default `true`)
+   *   source-mesh creation command (default `true`). `position.y` is always
+   *   grounded: the placed instance's bounding-box bottom rests at it (the
+   *   surface-flush grounding described above)
    * @param angleInDegrees - Optional signed rotation about the vertical axis, in
    *   degrees (same convention as {@linkcode PluginDesignTransformApi.rotate}).
    *   Applied at creation time so it is part of the placement's single undo entry.
@@ -571,7 +594,10 @@ export abstract class PluginDesignCreateApi {
   public abstract furniture(
     catalogId: string,
     position: Vec3Handle,
-    options?: { label?: string; createNewSourceMesh?: boolean },
+    options?: {
+      label?: string
+      createNewSourceMesh?: boolean
+    },
     angleInDegrees?: number,
   ): PluginApiReturn<ComponentHandle>
 
@@ -1219,7 +1245,7 @@ export const PluginDesignCreateWallsArgs = z.object({
 export type PluginDesignCreateWallsArgs = z.infer<
   typeof PluginDesignCreateWallsArgs
 >
-// TRANSPORT: positional signature shipped — storey is the trailing 5th arg:
+// TRANSPORT: positional signature shipped:
 //   walls(profile: ProfileHandle, height?: number, thickness?: number, wallType?: string, storey?: number)
 
 // ---------------------------------------------------------------------------

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

@@ -20,6 +20,22 @@ export const PluginDesignDeleteEntitiesArgs = z.object({
 })
 export type PluginDesignDeleteEntitiesArgs = z.infer<typeof PluginDesignDeleteEntitiesArgs>
 
+/**
+ * Result of {@linkcode PluginDesignDeleteApi.entities} — the shared
+ * change-result shape plus the delete cascade. Deliberately a delete-specific
+ * extension of {@linkcode PluginDesignChangeResult} (which other change
+ * mutations keep unchanged).
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `affected` | {@linkcode ComponentHandle}`[]` | The entities that were deleted (the resolved input set) |
+ * | `cascaded` | {@linkcode ComponentHandle}`[]`? | Components PG2 removed as a consequence — derived walls/floors/slabs of deleted spaces; returned so callers can invalidate cached handles |
+ */
+export const PluginDesignDeleteResult = PluginDesignChangeResult.extend({
+  cascaded: z.array(ComponentHandle).optional(),
+})
+export type PluginDesignDeleteResult = z.infer<typeof PluginDesignDeleteResult>
+
 /**
  * `snaptrude.design.delete.*` — **hard removal** of scene BIM entities.
  *
@@ -43,6 +59,9 @@ export abstract class PluginDesignDeleteApi {
    * @returns The entities that were deleted, as {@linkcode ComponentHandle}`[]`
    *   (echoed host-side from the resolved+deleted set — the engine returns no ids).
    *   Deleted handles are **stale** afterwards: re-resolving one throws `HANDLE_INVALID`.
+   *   When the parametric engine removes further components as a consequence
+   *   (derived walls/floors/slabs of deleted spaces), those are reported in the
+   *   optional `cascaded` array — invalidate any cached handles to them too.
    * @throws If any supplied handle is unknown/forged (`HANDLE_INVALID`) — the whole
    *   call rejects before anything is deleted (all-or-nothing resolution).
    *
@@ -66,5 +85,5 @@ export abstract class PluginDesignDeleteApi {
    */
   public abstract entities(
     components: ComponentHandle[],
-  ): PluginApiReturn<PluginDesignChangeResult>
+  ): PluginApiReturn<PluginDesignDeleteResult>
 }

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

@@ -34,25 +34,10 @@ export abstract class PluginDesignQueryGeometryApi {
    * scene entity, as a reusable {@linkcode BrepHandle} for the
    * `core.geom.query.brep.*` reads.
    *
-   * **Frame.** By default the brep comes back in the component's own LOCAL frame
-   * (its vertices are relative to the mesh origin, exactly as stored) — the
-   * behaviour every 0.9.x caller relies on. Pass `{ frame: "world" }` to get the
-   * same solid placed where it sits in the scene (world coordinates, like
-   * `getBottomContour` / `getTriangulatedMeshes` and every `design.query.measure`
-   * read). Use `"world"` whenever the handle will be COMBINED with other scene
-   * geometry or committed back beside its source: booleans between two scene
-   * masses, `brepFromFillet` / `brepFromShell` / `brepFromOffset` /
-   * `brepFromChamfer` on a scene mass followed by `massFromBrep`, or comparing
-   * its vertices with a bounding box. A world-frame handle from a parametrically
-   * live mass also carries that mass's recipe, so an operation result keeps an
-   * editable record.
-   *
    * @param component - The scene component to read
-   * @param options - `frame`: `"local"` (default, mesh-local coordinates) or `"world"` (scene coordinates)
    * @returns The brep as a {@linkcode BrepHandle}, or `null` if the component has no brep geometry
    *
    * @examplePrompt Get the 3D solid geometry of the selected wall
-   * @examplePrompt Round the top rim of this column and put it back where it is
    * @examplePrompt How many faces does this mass have?
    * @examplePrompt Inspect the mesh of this slab so I can look at its faces and edges
    * @examplePrompt Read the vertices of the selected column's geometry
@@ -63,16 +48,10 @@ export abstract class PluginDesignQueryGeometryApi {
    * if (brep) {
    *   const faces = await snaptrude.core.geom.query.brep.listFaces(brep)
    * }
-   *
-   * // Operate on a scene mass and commit the result where the mass sits:
-   * const placed = await snaptrude.design.query.geometry.getBrep(mass, { frame: "world" })
-   * const rounded = await snaptrude.core.geom.create.brepFromFillet(placed, edges, 0.2)
-   * await snaptrude.design.create.massFromBrep(rounded, "Rounded")
    * ```
    */
   public abstract getBrep(
     component: ComponentHandle,
-    options?: PluginDesignQueryGeometryGetBrepOptions,
   ): PluginApiReturn<BrepHandle | null>
 
   /**
@@ -210,16 +189,8 @@ export abstract class PluginDesignQueryGeometryApi {
  * |---|---|---|
  * | `component` | {@linkcode ComponentHandle} | The scene component to read |
  */
-/** Options for {@linkcode PluginDesignQueryGeometryApi.getBrep}: `frame` defaults to `"local"`. */
-export type PluginDesignQueryGeometryGetBrepOptions = { frame?: "local" | "world" }
-export const PluginDesignQueryGeometryGetBrepOptions: z.ZodType<
-  PluginDesignQueryGeometryGetBrepOptions,
-  PluginDesignQueryGeometryGetBrepOptions
-> = z.object({ frame: z.enum(["local", "world"]).optional() })
-
 export const PluginDesignQueryGeometryGetBrepArgs = z.object({
   component: ComponentHandle,
-  options: PluginDesignQueryGeometryGetBrepOptions.optional(),
 })
 
 export type PluginDesignQueryGeometryGetBrepArgs = z.infer<

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

@@ -1,7 +1,6 @@
 import * as z from "zod"
 import { PluginApiReturn } from "../../../types"
 import { ComponentHandle, BBoxComponents } from "../../../handles"
-import type { MassParametersRecord } from "../../../massParameters"
 import {
   PluginSpaceType,
   PluginMassType,
@@ -176,6 +175,7 @@ export type PluginDesignQueryComponentsArgs = z.infer<
  * | `isLocked` | `boolean` | Lock flag |
  * | `isHidden` | `boolean` | User-hidden flag |
  * | `isSelected` | `boolean` | Current selection state |
+ * | `isVisible` | `boolean` | Whether the entity currently has a visible representation on canvas (user hide flag AND LOD/mode gating both considered); read-only |
  * | `boundingBox` | {@linkcode BBoxComponents} | World-space AABB |
  * | `adjacency` | `{ spaceId: string; value: number }[]` | Adjacency relationships (spaces/masses only). `value`: `2` = Direct (required), `1` = Indirect or physical contact, `-1` = Restricted; `0` entries are filtered out. `[]` when adjacency has never been computed — see `program.adjacency.compute`. |
  */
@@ -195,6 +195,7 @@ export const PluginEntityProperties = z
     isLocked: z.boolean(),
     isHidden: z.boolean(),
     isSelected: z.boolean(),
+    isVisible: z.boolean(),
     boundingBox: BBoxComponents,
     adjacency: z.array(z.object({ spaceId: z.string(), value: z.number() })),
   })
@@ -1015,55 +1016,6 @@ export abstract class PluginDesignQueryApi {
     staircase: ComponentHandle,
   ): PluginApiReturn<PluginStaircaseParams | null>
 
-  /**
-   * Read a mass's creation-parameter record — the recipe it was built from
-   * (`kind` plus the values that constructor was called with). Present on
-   * masses committed from a `core.geom.create` brep constructor that carries a
-   * recipe: {@linkcode MassParametersRecord} covers the four primitives
-   * (sphere, cylinder, cone, torus), extrusions, revolutions, lofts and sweeps.
-   *
-   * A fillet, chamfer, shell or offset of a recorded solid keeps the record
-   * too: `kind` stays the base constructor and the operation is appended to the
-   * record's `operations` list. Edit any of it with `design.update.parameters`.
-   *
-   * `null` for everything else — drawn masses, imported geometry, booleans,
-   * split parts, `brepFromFaces` / `brepFromMesh`, and results built on a
-   * source that carried no record — and for a mass whose record no longer
-   * matches what is on
-   * screen (a later free-form edit dropped the recipe, or the mass carries a
-   * baked scale). `null` too when the recipe was not recordable: the record
-   * schema has its own caps (a sweep path of at most 512 points, a loft of at
-   * most 32 sections, at most 8 chained `operations`, at most 256 curves in one
-   * profile loop and 64 holes in one contour), and a mass built past one of
-   * them — through a route that does not enforce the matching creator cap —
-   * commits as ordinary geometry carrying no record. The `operations` cap is
-   * the one an agent can walk into by accident: a 9th chained
-   * fillet/chamfer/shell/offset drops the record silently, so the result
-   * commits as ordinary geometry and reads back `null` here. A record is never
-   * reported unless it is still the truth.
-   *
-   * Points and axes come back in **world** coordinates. Pure read — nothing is
-   * created or modified.
-   *
-   * @param component - the mass's {@linkcode ComponentHandle}
-   * @returns the {@linkcode MassParametersRecord}, or `null`
-   *
-   * @examplePrompt What radius is this sphere?
-   * @examplePrompt Is this mass parametric?
-   * @examplePrompt Read back the dome's creation parameters
-   * @examplePrompt How tall was this cylinder made?
-   *
-   * # Example
-   * ```ts
-   * const [mass] = await snaptrude.design.query.listMasses({ isSelected: true })
-   * const params = await snaptrude.design.query.getParameters(mass)
-   * if (params?.kind === "sphere") console.log("radius:", params.values.radius)
-   * ```
-   */
-  public abstract getParameters(
-    component: ComponentHandle,
-  ): PluginApiReturn<MassParametersRecord | null>
-
   /**
    * Get the **union** axis-aligned bounding box enclosing a set of entities.
    *

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

@@ -124,6 +124,41 @@ export abstract class PluginDesignQuerySpacesApi {
   public abstract getEnclosure(
     space: ComponentHandle,
   ): PluginApiReturn<PluginSpaceEnclosure | null>
+
+  /**
+   * List the space's **engine-generated BIM components** — the walls, floors
+   * and slabs the parametric engine derived from this space, grouped by kind.
+   *
+   * Unlike {@linkcode getEnclosure} (a geometric best-effort match), this read
+   * reports the engine's own derivation records, so every returned handle is a
+   * component the engine created *for this space*.
+   *
+   * The derived set is NOT stable across writes: a merge/split/rebuild of the
+   * space graph retires members and creates successors — re-query after any
+   * write that touches the space. This is the churn-recovery anchor: when a
+   * cached derived handle goes stale, call this again to pick up the current
+   * set.
+   *
+   * @param space - The space (room mass) to read
+   * @returns the generated component handles, grouped by kind
+   *   ({@linkcode PluginSpaceGeneratedBim}); a group is `[]` when the engine
+   *   derived nothing of that kind
+   * @throws If the space does not exist or the component is not a space/mass
+   *
+   * @examplePrompt Which walls did this room generate?
+   * @examplePrompt List the BIM components derived from the selected space
+   * @examplePrompt Get the floors and slabs that belong to this room
+   *
+   * # Example
+   * ```ts
+   * const [space] = await snaptrude.design.query.listSpaces()
+   * const bim = await snaptrude.design.query.spaces.listGeneratedBim(space)
+   * console.log(`${bim.walls.length} walls, ${bim.floors.length} floors`)
+   * ```
+   */
+  public abstract listGeneratedBim(
+    space: ComponentHandle,
+  ): PluginApiReturn<PluginSpaceGeneratedBim>
 }
 
 /**
@@ -273,3 +308,36 @@ export const PluginSpaceEnclosure = z.object({
   adjacentSpaces: z.array(PluginAdjacentSpace),
 })
 export type PluginSpaceEnclosure = z.infer<typeof PluginSpaceEnclosure>
+
+/**
+ * Arguments for {@linkcode PluginDesignQuerySpacesApi.listGeneratedBim}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `space` | {@linkcode ComponentHandle} | The space (room mass) to read |
+ */
+export const PluginDesignQuerySpacesListGeneratedBimArgs = z.object({
+  space: ComponentHandle,
+})
+export type PluginDesignQuerySpacesListGeneratedBimArgs = z.infer<
+  typeof PluginDesignQuerySpacesListGeneratedBimArgs
+>
+
+/**
+ * Result of {@linkcode PluginDesignQuerySpacesApi.listGeneratedBim} — the
+ * space's engine-generated BIM component handles, grouped by kind. The set
+ * changes whenever a write merges/splits/rebuilds the space graph — re-query
+ * after writes rather than caching it.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `walls` | {@linkcode ComponentHandle}`[]` | Walls the engine derived from the space |
+ * | `floors` | {@linkcode ComponentHandle}`[]` | Floors the engine derived from the space |
+ * | `slabs` | {@linkcode ComponentHandle}`[]` | Slabs the engine derived from the space |
+ */
+export const PluginSpaceGeneratedBim = z.object({
+  walls: z.array(ComponentHandle),
+  floors: z.array(ComponentHandle),
+  slabs: z.array(ComponentHandle),
+})
+export type PluginSpaceGeneratedBim = z.infer<typeof PluginSpaceGeneratedBim>

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

@@ -9,7 +9,6 @@ import {
   PluginSpaceUpdateResult,
 } from "../../entity/space"
 import { PluginDesignChangeResult } from "../lock"
-import { MassParametersPatch, type MassParametersRecord } from "../../../massParameters"
 import {
   PluginBuildableEnvelopePolygonVertex,
   PluginBuildableEnvelopeSetbackTier,
@@ -137,22 +136,6 @@ export type PluginDesignUpdateStaircaseArgs = z.infer<
   typeof PluginDesignUpdateStaircaseArgs
 >
 
-/**
- * Arguments for {@linkcode PluginDesignUpdateApi.parameters}.
- *
- * | Property | Type | Description |
- * |---|---|---|
- * | `component` | {@linkcode ComponentHandle} | The parametric mass to edit |
- * | `patch` | {@linkcode MassParametersPatch} | Partial `values` (+ optional `operations`), or the full edited record |
- */
-export const PluginDesignUpdateParametersArgs = z.object({
-  component: ComponentHandle,
-  patch: MassParametersPatch,
-})
-export type PluginDesignUpdateParametersArgs = z.infer<
-  typeof PluginDesignUpdateParametersArgs
->
-
 /**
  * Sparse edits for a wall (all optional; at least one required). Only the
  * fields you provide change. Dimensions are in **engine units** (the same
@@ -426,83 +409,6 @@ export abstract class PluginDesignUpdateApi {
     params: PluginStaircaseParamUpdates,
   ): PluginApiReturn<PluginDesignChangeResult>
 
-  /**
-   * Edit a parametric mass by patching its creation recipe and rebuilding the
-   * solid in place — the mass keeps its id, storey, materials, position and
-   * linked copies; only the geometry changes. Read the current record with
-   * `design.query.getParameters` first.
-   *
-   * `patch` is a partial of `record.values` — or the whole record you read
-   * back, edited. A key you leave out is unchanged (that includes
-   * `operations`). Scalars and points MERGE by key (`{ radius: 8 }` changes
-   * only the radius); arrays (`contour`, `sections`, `path`, `profile`,
-   * `operations`) REPLACE WHOLE when present — send the complete new list;
-   * `{ operations: [] }` drops every operation. A patch that changes nothing
-   * returns the current record and records no edit (no undo step). `kind` and
-   * `version` are immutable: to change the kind, build a new mass. Keys are the
-   * record's `values` keys for its `kind` (sphere: `centre`, `radius`;
-   * cylinder: `base`, `axis`, `radius`, `height`; torus: `centre`, `axis`,
-   * `majorRadius`, `minorRadius`; …) plus `operations`. To change a fillet
-   * radius, edit `operations[i].radius` in the record you read and send
-   * `{ operations }` back. Points and axes are WORLD coordinates in internal
-   * units, exactly as `getParameters` reports them.
-   *
-   * Rebuilds in memory first, then swaps onto the SAME component; every linked
-   * copy regenerates together. One undo step; saves and syncs to collaborators
-   * like any geometry edit. Kernel kinds (revolution, sweep, loft, primitives,
-   * any `operations`) run on OpenCascade — expect a short pause.
-   *
-   * @param component - a mass whose `getParameters` is non-null
-   * @param patch - partial `values` (+ optional `operations`), or the full edited record
-   * @returns the complete post-edit record, world coordinates (what
-   *   `getParameters` now returns)
-   * @throws PRECONDITION_FAILED when the mass carries no live recipe — built
-   *   from a boolean, split, `brepFromFaces`/`brepFromMesh` or drawn; edited
-   *   free-form since (push/pull, move face, boolean); or scaled with the
-   *   transform tool. `getParameters` returns `null` for exactly these.
-   *   Do not retry — rebuild it with a recipe constructor and say so.
-   *   Also PRECONDITION_FAILED when the mass is **locked** (the message says
-   *   so). Locking is invisible to `getParameters` — a locked parametric mass
-   *   still reads back a full record — so this is the one PRECONDITION_FAILED
-   *   the read cannot predict. Unlock the mass and call again; never rebuild
-   *   it, the recipe is intact.
-   *   Also PRECONDITION_FAILED when an `operations` entry's edge/face selectors
-   *   no longer resolve on the rebuilt base (the message names the operation
-   *   and edge): re-select the edges on the new shape and re-apply that
-   *   operation.
-   * @throws VALIDATION for a key the kind does not have (the message lists the
-   *   kind's keys), `kind` or `version` in a partial patch, or a value outside
-   *   the constructor's own rules (torus tube ≥ ring, revolution angle ∉
-   *   (0, 360], a profile crossing its axis, a spline with fewer than
-   *   degree + 1 poles).
-   * @throws OPERATION_FAILED when the kernel cannot build the edited recipe;
-   *   the model is left unchanged.
-   *
-   * @examplePrompt Make the dome's radius 8 metres
-   * @examplePrompt Raise the podium to 5 m
-   * @examplePrompt Widen the vase — move its profile points 20 cm outward
-   * @examplePrompt Change the fillet on the rounded column to 300 mm
-   *
-   * # Example
-   * ```ts
-   * // { kind: "sphere", values: { centre, radius: 19.685 }, … }
-   * const before = await snaptrude.design.query.getParameters(dome)
-   * const after = await snaptrude.design.update.parameters(dome, { radius: 31.496 }) // 8 m in internal units
-   *
-   * // Fillet radius on a recorded result: read → edit → send the array back
-   * const rec = await snaptrude.design.query.getParameters(column)
-   * const operations = rec?.operations ?? []
-   * if (operations[0]?.op === "fillet") {
-   *   operations[0].radius = 1.181
-   *   await snaptrude.design.update.parameters(column, { operations })
-   * }
-   * ```
-   */
-  public abstract parameters(
-    component: ComponentHandle,
-    patch: MassParametersPatch,
-  ): PluginApiReturn<MassParametersRecord>
-
   /**
    * Edit a **wall** — its thickness and/or height (the same command the
    * properties panel's Thickness/Height fields drive) and/or its **wall type**