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

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/core/io/import/index.ts

@@ -183,7 +183,10 @@ export abstract class PluginCoreIoImportApi {
    * if (cad) console.log("DWG imported as CAD underlay:", cad)
    * ```
    */
-  public abstract dwg(source: string, storey?: number): PluginApiReturn<ImportJobHandle>
+  public abstract dwg(
+    source: string,
+    storey?: number,
+  ): PluginApiReturn<ImportJobHandle>
 
   /**
    * Sketch a CAD underlay from **already-parsed CAD JSON** — synchronous, with no
@@ -214,7 +217,10 @@ export abstract class PluginCoreIoImportApi {
    * )
    * ```
    */
-  public abstract cadJson(cad: CadJsonInput, storey?: number): PluginApiReturn<UnderlayHandle>
+  public abstract cadJson(
+    cad: CadJsonInput,
+    storey?: number,
+  ): PluginApiReturn<UnderlayHandle>
 
   /**
    * Import a **3D model** file and place it in the scene as a component.
@@ -239,7 +245,9 @@ export abstract class PluginCoreIoImportApi {
    * @returns the placed {@linkcode ComponentHandle}.
    * @throws if writes are disabled, the source can't be loaded, the format is
    *   unsupported, conversion/placement fails, or the converted model cannot be
-   *   found in the library after upload.
+   *   found in the library after upload; `PRECONDITION_FAILED`
+   *   (`details.engineCode: "TOOL_ACTIVE"`) while the interactive furniture tool is
+   *   active — finish or cancel it first.
    *
    * @examplePrompt Import this SketchUp model onto storey 1
    * @examplePrompt Bring in this OBJ file and place it at the origin

package/src/api/design/create/bulk-items.ts

@@ -0,0 +1,186 @@
+import * as z from "zod"
+import { ContourHandle, ProfileHandle, Vec3Handle } from "../../../handles"
+import { PluginOpeningBaseOptions } from "./opening-fields"
+
+/**
+ * Maximum items per bulk `design.create.*` call. A bounded request keeps
+ * validation, command capture and rollback work finite; split a larger import
+ * into separate awaited batches, each with its own undo entry.
+ */
+export const PLUGIN_CREATE_BATCH_LIMIT = 1000
+
+// ---------------------------------------------------------------------------
+// wallRuns
+// ---------------------------------------------------------------------------
+
+/**
+ * One wall run to create via {@linkcode PluginDesignCreateApi.wallRuns} — the
+ * same inputs as {@linkcode PluginDesignCreateApi.walls}, one run per item.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `profile` | {@linkcode ProfileHandle} | Ordered curve chain (wall centerlines) |
+ * | `height` | `number`? | Wall height (Snaptrude units, > 0; default engine default) |
+ * | `thickness` | `number`? | Wall thickness (Snaptrude units, > 0; default: `wallType`'s total layer thickness when given, else engine default) |
+ * | `wallType` | `string`? | Wall type name from `design.types.list("wall")` — layers/material/thickness defaults (default generic) |
+ * | `storey` | `number`? (int) | Target storey (must exist) — the run's walls are assigned + lifted to its base in the same undo entry (default: geometry-derived) |
+ */
+export const PluginCreateWallRunItem = z.object({
+  profile: ProfileHandle,
+  height: z.number().optional(),
+  thickness: z.number().optional(),
+  wallType: z.string().min(1).optional(),
+  storey: z.number().int().optional(),
+})
+export type PluginCreateWallRunItem = z.infer<typeof PluginCreateWallRunItem>
+
+/** The `items` array of {@linkcode PluginDesignCreateApi.wallRuns} (1…1000). */
+export const PluginCreateWallRunItems = z
+  .array(PluginCreateWallRunItem)
+  .min(1)
+  .max(PLUGIN_CREATE_BATCH_LIMIT)
+export type PluginCreateWallRunItems = z.infer<typeof PluginCreateWallRunItems>
+
+// ---------------------------------------------------------------------------
+// floors
+// ---------------------------------------------------------------------------
+
+/**
+ * One floor to create via {@linkcode PluginDesignCreateApi.floors} — the same
+ * footprint-extrude inputs as {@linkcode PluginDesignCreateApi.floor}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `contour` | {@linkcode ContourHandle} | Footprint (outer profile + holes) |
+ * | `thickness` | `number` | Floor thickness (Snaptrude units, > 0) |
+ * | `position` | {@linkcode Vec3Handle}? | Offset from origin (default origin) |
+ */
+export const PluginCreateFloorItem = z.object({
+  contour: ContourHandle,
+  thickness: z.number(),
+  position: Vec3Handle.optional(),
+})
+export type PluginCreateFloorItem = z.infer<typeof PluginCreateFloorItem>
+
+/** The `items` array of {@linkcode PluginDesignCreateApi.floors} (1…1000). */
+export const PluginCreateFloorItems = z
+  .array(PluginCreateFloorItem)
+  .min(1)
+  .max(PLUGIN_CREATE_BATCH_LIMIT)
+export type PluginCreateFloorItems = z.infer<typeof PluginCreateFloorItems>
+
+// ---------------------------------------------------------------------------
+// doors / windows
+// ---------------------------------------------------------------------------
+
+/**
+ * One door to place via {@linkcode PluginDesignCreateApi.doors} — the same
+ * fields as a `"door"` {@linkcode PluginDesignCreateOpeningOptions}, so the
+ * size overrides singular {@linkcode PluginDesignCreateApi.door} lacks are
+ * available per item. `facing` and `hinge` are WORLD POINTS, not directions:
+ * `facing` on the side of the wall the door swings open to, `hinge` near the
+ * jamb it is hinged on. Rejects unknown fields.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `catalogId` | `string` | Library id: team `_id` or general `fullName` |
+ * | `hostWall` | {@linkcode ComponentHandle} | The wall to host the door |
+ * | `position` | {@linkcode Vec3Handle} | World point projected onto the wall |
+ * | `facing` | {@linkcode Vec3Handle}? | World point on the side the door swings open to (default engine-chosen) |
+ * | `hinge` | {@linkcode Vec3Handle}? | World point near the jamb the door is hinged on (default the catalog item's authored side) |
+ * | `label` | `string`? | Instance name (optional) |
+ * | `width` | `number`? | Width override (Snaptrude units, > 0; default the catalog item's) |
+ * | `height` | `number`? | Height override (Snaptrude units, > 0; default the catalog item's) |
+ */
+export const PluginCreateDoorItem = z
+  .object({ ...PluginOpeningBaseOptions })
+  .strict()
+export type PluginCreateDoorItem = z.infer<typeof PluginCreateDoorItem>
+
+/** The `items` array of {@linkcode PluginDesignCreateApi.doors} (1…1000). */
+export const PluginCreateDoorItems = z
+  .array(PluginCreateDoorItem)
+  .min(1)
+  .max(PLUGIN_CREATE_BATCH_LIMIT)
+export type PluginCreateDoorItems = z.infer<typeof PluginCreateDoorItems>
+
+/**
+ * One window to place via {@linkcode PluginDesignCreateApi.windows} — the same
+ * fields as a `"window"` {@linkcode PluginDesignCreateOpeningOptions}.
+ * `sillHeight` is a nonnegative Snaptrude-unit distance from the host wall's
+ * base to the BOTTOM of the window, not to its center. `facing` and `hinge`
+ * are WORLD POINTS, not directions: `facing` on the side of the wall the
+ * window opens to, `hinge` near the jamb it is hinged on. Rejects unknown
+ * fields.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `catalogId` | `string` | Library id: team `_id` or general `fullName` |
+ * | `hostWall` | {@linkcode ComponentHandle} | The wall to host the window |
+ * | `position` | {@linkcode Vec3Handle} | World point projected onto the wall |
+ * | `facing` | {@linkcode Vec3Handle}? | World point on the side the window opens to (default engine-chosen) |
+ * | `hinge` | {@linkcode Vec3Handle}? | World point near the jamb the window is hinged on (default the catalog item's authored side) |
+ * | `label` | `string`? | Instance name (optional) |
+ * | `width` | `number`? | Width override (Snaptrude units, > 0; default the catalog item's) |
+ * | `height` | `number`? | Height override (Snaptrude units, > 0; default the catalog item's) |
+ * | `sillHeight` | `number`? | Wall base to window bottom (Snaptrude units, ≥ 0; default the catalog item's) |
+ */
+export const PluginCreateWindowItem = z
+  .object({
+    ...PluginOpeningBaseOptions,
+    sillHeight: z.number().finite().nonnegative().optional(),
+  })
+  .strict()
+export type PluginCreateWindowItem = z.infer<typeof PluginCreateWindowItem>
+
+/** The `items` array of {@linkcode PluginDesignCreateApi.windows} (1…1000). */
+export const PluginCreateWindowItems = z
+  .array(PluginCreateWindowItem)
+  .min(1)
+  .max(PLUGIN_CREATE_BATCH_LIMIT)
+export type PluginCreateWindowItems = z.infer<typeof PluginCreateWindowItems>
+
+// ---------------------------------------------------------------------------
+// furnitureItems
+// ---------------------------------------------------------------------------
+
+/**
+ * One furniture instance to place via
+ * {@linkcode PluginDesignCreateApi.furnitureItems} — the same inputs as
+ * {@linkcode PluginDesignCreateApi.furniture} minus `createNewSourceMesh`: in a
+ * batch the host owns source-mesh persistence (a source is recorded once per
+ * call, however many items reuse it).
+ *
+ * `position.y` is the REST elevation: the item is grounded so its bounding-box
+ * base sits exactly at `position.y` (the same surface-flush contract as
+ * interactive drag-drop) — pass the floor/storey elevation to stand furniture
+ * on it; never add half the item's height yourself.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `catalogId` | `string` | Library id: team `_id` or general `fullName` |
+ * | `position` | {@linkcode Vec3Handle} | Absolute world placement point (`y` = rest elevation) |
+ * | `label` | `string`? | Instance name and readable label (default auto `${name}Ins${n}`) |
+ * | `angleInDegrees` | `number`? | Rotation about the vertical axis, in degrees (default unrotated) |
+ */
+export const PluginCreateFurnitureItem = z.object({
+  catalogId: z.string().min(1),
+  position: Vec3Handle,
+  label: z.string().optional(),
+  angleInDegrees: z.number().optional(),
+})
+export type PluginCreateFurnitureItem = z.infer<
+  typeof PluginCreateFurnitureItem
+>
+
+/**
+ * The `items` array of {@linkcode PluginDesignCreateApi.furnitureItems}
+ * (1…1000).
+ */
+export const PluginCreateFurnitureItems = z
+  .array(PluginCreateFurnitureItem)
+  .min(1)
+  .max(PLUGIN_CREATE_BATCH_LIMIT)
+export type PluginCreateFurnitureItems = z.infer<
+  typeof PluginCreateFurnitureItems
+>