@snaptrude/plugin-core 0.2.2 → 0.2.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@snaptrude/plugin-core",
-  "version": "0.2.2",
+  "version": "0.2.4",
   "type": "module",
   "main": "./dist/index.js",
   "module": "./dist/index.js",

package/src/api/entity/space.ts

@@ -5,7 +5,7 @@ import { PQuat } from "../core/math/quat"
 import { PProfile } from "../core/geom/profile"
 
 /**
- * Space (room/mass) management — create, query, and delete spaces.
+ * Space (room/mass) management — create, query, update, and delete spaces.
  *
  * A **space** is a 3D volume representing a room or mass in the
  * Snaptrude scene. Spaces live on a particular story and carry
@@ -53,18 +53,22 @@ export abstract class PluginSpaceApi {
   /**
    * Create a space by extruding a 2D profile.
    *
-   * The {@linkcode PluginSpaceCreateFromProfileArgs.profile profile} is extruded
-   * upward (along the Y axis) by {@linkcode PluginSpaceCreateFromProfileArgs.extrudeHeight
-   * extrudeHeight}, then offset by {@linkcode PluginSpaceCreateFromProfileArgs.position
-   * position}. The created space is automatically assigned to the active story
-   * and a default department.
+   * The {@linkcode PluginSpaceCreateFromProfileArgs.profile profile} is used as
+   * the outer boundary and extruded upward (along the Y axis) by
+   * {@linkcode PluginSpaceCreateFromProfileArgs.extrudeHeight extrudeHeight},
+   * then offset by {@linkcode PluginSpaceCreateFromProfileArgs.position
+   * position}. Optional {@linkcode PluginSpaceCreateFromProfileArgs.innerProfiles
+   * innerProfiles} are used as holes inside the outer boundary. The created
+   * space is automatically assigned to the active story and a default department.
    *
    * Use {@linkcode PluginProfileApi.fromLinePoints} to quickly build a profile
    * from a list of points.
    *
    * @param args - An object containing:
    *   - {@linkcode PluginSpaceCreateFromProfileArgs.profile args.profile} — A closed
-   *     {@linkcode PProfile} defining the floor shape
+   *     {@linkcode PProfile} defining the outer floor shape
+   *   - {@linkcode PluginSpaceCreateFromProfileArgs.innerProfiles args.innerProfiles} —
+   *     Optional closed {@linkcode PProfile}`[]` loops to subtract as holes
    *   - {@linkcode PluginSpaceCreateFromProfileArgs.extrudeHeight args.extrudeHeight} —
    *     Extrusion height in Babylon units
    *   - {@linkcode PluginSpaceCreateFromProfileArgs.position args.position} — Offset
@@ -77,7 +81,7 @@ export abstract class PluginSpaceApi {
    * ```ts
    * const { vec3 } = snaptrude.core.math
    *
-   * const profile = await snaptrude.core.geom.profile.fromLinePoints({
+   * const outerProfile = await snaptrude.core.geom.profile.fromLinePoints({
    *   points: [
    *     vec3.new(0, 0, 0),
    *     vec3.new(10, 0, 0),
@@ -85,9 +89,18 @@ export abstract class PluginSpaceApi {
    *     vec3.new(0, 0, 8),
    *   ],
    * })
+   * const holeProfile = await snaptrude.core.geom.profile.fromLinePoints({
+   *   points: [
+   *     vec3.new(3, 0, 3),
+   *     vec3.new(7, 0, 3),
+   *     vec3.new(7, 0, 5),
+   *     vec3.new(3, 0, 5),
+   *   ],
+   * })
    *
    * const { spaceId } = await snaptrude.entity.space.createFromProfile({
-   *   profile,
+   *   profile: outerProfile,
+   *   innerProfiles: [holeProfile],
    *   extrudeHeight: 3,
    *   position: vec3.new(0, 0, 0),
    * })
@@ -95,10 +108,66 @@ export abstract class PluginSpaceApi {
    */
   public abstract createFromProfile({
     profile,
+    innerProfiles,
     extrudeHeight,
     position,
   }: PluginSpaceCreateFromProfileArgs): PluginApiReturn<PluginSpaceCreateFromProfileResult>
 
+  /**
+   * Update a space's BRep and mesh geometry by extruding a 2D profile.
+   *
+   * The {@linkcode PluginSpaceUpdateGeometryFromProfileArgs.profile profile} is
+   * extruded upward (along the Y axis) by
+   * {@linkcode PluginSpaceUpdateGeometryFromProfileArgs.extrudeHeight extrudeHeight}
+   * and applied to the existing space. The space keeps the same `spaceId`,
+   * metadata, department, and transform; only its geometry is replaced.
+   *
+   * Profile points are interpreted in scene coordinates. Profiles returned by
+   * {@linkcode PluginSpaceApi.get} with `"profile"` can be passed back directly;
+   * `"planPoints"` can be used to construct line-only profiles in the same X/Z
+   * plan coordinate space.
+   *
+   * Use {@linkcode PluginProfileApi.fromLinePoints} to quickly build a profile
+   * from a list of points.
+   *
+   * @param args - An object containing:
+   *   - {@linkcode PluginSpaceUpdateGeometryFromProfileArgs.spaceId args.spaceId} —
+   *     The unique space ID to update
+   *   - {@linkcode PluginSpaceUpdateGeometryFromProfileArgs.profile args.profile} —
+   *     A closed {@linkcode PProfile} defining the new floor shape
+   *   - {@linkcode PluginSpaceUpdateGeometryFromProfileArgs.extrudeHeight
+   *     args.extrudeHeight} — New extrusion height in Babylon units
+   * @returns A {@linkcode PluginSpaceUpdateGeometryFromProfileResult} with the
+   *   `spaceId` of the updated space
+   * @throws If the space does not exist, the component is not a space/mass, the
+   *   height is not positive, or the profile cannot create valid geometry
+   *
+   * # Example
+   * ```ts
+   * const { vec3 } = snaptrude.core.math
+   *
+   * const profile = await snaptrude.core.geom.profile.fromLinePoints({
+   *   points: [
+   *     vec3.new(0, 0, 0),
+   *     vec3.new(12, 0, 0),
+   *     vec3.new(12, 0, 6),
+   *     vec3.new(0, 0, 6),
+   *   ],
+   * })
+   *
+   * const { spaceId } = await snaptrude.entity.space.updateGeometryFromProfile({
+   *   spaceId: "some-space-id",
+   *   profile,
+   *   extrudeHeight: 4,
+   * })
+   * ```
+   */
+  public abstract updateGeometryFromProfile({
+    spaceId,
+    profile,
+    extrudeHeight,
+  }: PluginSpaceUpdateGeometryFromProfileArgs): PluginApiReturn<PluginSpaceUpdateGeometryFromProfileResult>
+
   /**
    * Get the IDs of all spaces in the current project.
    *
@@ -195,7 +264,7 @@ export abstract class PluginSpaceApi {
    * ```
    */
   public abstract update(
-    args: PluginSpaceUpdateArgs
+    args: PluginSpaceUpdateArgs,
   ): PluginApiReturn<PluginSpaceUpdateResult>
 }
 
@@ -240,12 +309,14 @@ export type PluginSpaceCreateRectangularResult = z.infer<
  *
  * | Property | Type | Description |
  * |---|---|---|
- * | `profile` | {@linkcode PProfile} | Closed 2D profile defining the floor shape |
+ * | `profile` | {@linkcode PProfile} | Closed 2D profile defining the outer floor shape |
+ * | `innerProfiles` | {@linkcode PProfile}`[]` | Optional closed profiles to subtract as holes |
  * | `extrudeHeight` | `number` | Extrusion height in Babylon units |
  * | `position` | {@linkcode PVec3} | Offset position in Babylon units |
  */
 export const PluginSpaceCreateFromProfileArgs = z.object({
   profile: PProfile,
+  innerProfiles: z.array(PProfile).optional(),
   extrudeHeight: z.number(),
   position: PVec3,
 })
@@ -269,6 +340,40 @@ export type PluginSpaceCreateFromProfileResult = z.infer<
   typeof PluginSpaceCreateFromProfileResult
 >
 
+/**
+ * Arguments for {@linkcode PluginSpaceApi.updateGeometryFromProfile}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `spaceId` | `string` | Space to update |
+ * | `profile` | {@linkcode PProfile} | Closed 2D profile defining the new floor shape |
+ * | `extrudeHeight` | `number` | New extrusion height in Babylon units |
+ */
+export const PluginSpaceUpdateGeometryFromProfileArgs = z.object({
+  spaceId: z.string(),
+  profile: PProfile,
+  extrudeHeight: z.number(),
+})
+
+export type PluginSpaceUpdateGeometryFromProfileArgs = z.infer<
+  typeof PluginSpaceUpdateGeometryFromProfileArgs
+>
+
+/**
+ * Result of {@linkcode PluginSpaceApi.updateGeometryFromProfile}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `spaceId` | `string` | Unique ID of the updated space |
+ */
+export const PluginSpaceUpdateGeometryFromProfileResult = z.object({
+  spaceId: z.string(),
+})
+
+export type PluginSpaceUpdateGeometryFromProfileResult = z.infer<
+  typeof PluginSpaceUpdateGeometryFromProfileResult
+>
+
 /**
  * Available properties that can be queried on a space.
  *
@@ -306,6 +411,7 @@ export type PluginSpaceCreateFromProfileResult = z.infer<
  * | Value | Return Type | Description |
  * |---|---|---|
  * | `"planPoints"` | {@linkcode PVec3}`[]` | Bottom outer profile points in world space with `y = 0` (2D plan). No closing duplicate point. |
+ * | `"profile"` | {@linkcode PProfile} | Bottom outer profile in world space, preserving line/arc curve data. |
  */
 export const PluginSpaceGetProperty = z.enum([
   // Basic
@@ -331,6 +437,7 @@ export const PluginSpaceGetProperty = z.enum([
   "rotationQuaternion",
   // Derived from brep
   "planPoints",
+  "profile",
 ])
 
 /**
@@ -376,7 +483,7 @@ export const PluginSpaceType = z.enum([
   "Pool",
   "Walkway",
   "Envelope",
-  "Parking"
+  "Parking",
 ])
 
 /**
@@ -410,6 +517,7 @@ export const PluginSpaceGetResult = z
     rotationQuaternion: PQuat.nullable(),
     // Derived from brep
     planPoints: z.array(PVec3),
+    profile: PProfile,
   })
   .partial()
 

package/dist/api/core/geom/arc.d.ts

@@ -1,81 +0,0 @@
-import * as z from "zod";
-import { PVec3 } from "../math/vec3";
-/**
- * Arc construction.
- *
- * A {@linkcode PArc} represents a circular arc in 3D space, defined by
- * start/end points, a centre, and a rotation axis. Arcs can be wrapped
- * as a {@linkcode PCurve} and combined into a {@linkcode PProfile}.
- *
- * Accessed via `snaptrude.core.geom.arc`.
- */
-export declare abstract class PluginArcApi {
-    constructor();
-    /**
-     * Create a new arc from start, end, centre, and axis.
-     *
-     * The arc sweeps from {@linkcode startPoint} to {@linkcode endPoint}
-     * along the circle centred at {@linkcode centrePoint}, in the
-     * direction determined by the right-hand rule around {@linkcode axis}.
-     *
-     * @param startPoint - The start point as a {@linkcode PVec3}
-     * @param endPoint - The end point as a {@linkcode PVec3}
-     * @param centrePoint - The centre of the arc's circle as a {@linkcode PVec3}
-     * @param axis - The arc's rotation axis as a {@linkcode PVec3}
-     *   (perpendicular to the arc's plane)
-     * @returns A new {@linkcode PArc}
-     *
-     * # Example
-     * ```ts
-     * const { vec3 } = snaptrude.core.math
-     * const { arc } = snaptrude.core.geom
-     *
-     * // Quarter-circle arc on the XZ plane
-     * const a = arc.new(
-     *   vec3.new(1, 0, 0),  // start
-     *   vec3.new(0, 0, 1),  // end
-     *   vec3.new(0, 0, 0),  // centre
-     *   vec3.new(0, 1, 0),  // Y-up axis
-     * )
-     * ```
-     */
-    new(startPoint: PVec3, endPoint: PVec3, centrePoint: PVec3, axis: PVec3): PArc;
-}
-/**
- * A circular arc defined by start, end, centre, and axis.
- *
- * Discriminated by `curveType: "Arc"` within the {@linkcode PCurve} union.
- *
- * | Property | Type | Description |
- * |---|---|---|
- * | `curveType` | `"Arc"` | Discriminator tag |
- * | `startPoint` | {@linkcode PVec3} | Start point of the arc |
- * | `endPoint` | {@linkcode PVec3} | End point of the arc |
- * | `centrePoint` | {@linkcode PVec3} | Centre of the arc's circle |
- * | `axis` | {@linkcode PVec3} | Rotation axis (normal to the arc's plane) |
- */
-export declare const PArc: z.ZodObject<{
-    curveType: z.ZodLiteral<"Arc">;
-    startPoint: z.ZodObject<{
-        x: z.ZodNumber;
-        y: z.ZodNumber;
-        z: z.ZodNumber;
-    }, z.core.$strip>;
-    endPoint: z.ZodObject<{
-        x: z.ZodNumber;
-        y: z.ZodNumber;
-        z: z.ZodNumber;
-    }, z.core.$strip>;
-    centrePoint: z.ZodObject<{
-        x: z.ZodNumber;
-        y: z.ZodNumber;
-        z: z.ZodNumber;
-    }, z.core.$strip>;
-    axis: z.ZodObject<{
-        x: z.ZodNumber;
-        y: z.ZodNumber;
-        z: z.ZodNumber;
-    }, z.core.$strip>;
-}, z.core.$strip>;
-export type PArc = z.infer<typeof PArc>;
-//# sourceMappingURL=arc.d.ts.map

package/dist/api/core/geom/arc.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"arc.d.ts","sourceRoot":"","sources":["../../../../src/api/core/geom/arc.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AACxB,OAAO,EAAE,KAAK,EAAE,MAAM,cAAc,CAAA;AAEpC;;;;;;;;GAQG;AACH,8BAAsB,YAAY;;IAGhC;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2BG;IACH,GAAG,CAAC,UAAU,EAAE,KAAK,EAAE,QAAQ,EAAE,KAAK,EAAE,WAAW,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,GAAG,IAAI;CAG/E;AAED;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,IAAI;;;;;;;;;;;;;;;;;;;;;;iBAMf,CAAA;AAEF,MAAM,MAAM,IAAI,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,IAAI,CAAC,CAAA"}

package/dist/api/core/geom/curve.d.ts

@@ -1,70 +0,0 @@
-import * as z from "zod";
-import { PLine } from "./line";
-import { PArc } from "./arc";
-/**
- * Unified curve wrapper — either a {@linkcode PLine} or a {@linkcode PArc}.
- *
- * Use this to build heterogeneous curve lists (mixing lines and arcs)
- * when constructing a {@linkcode PProfile}.
- *
- * Accessed via `snaptrude.core.geom.curve`.
- */
-export declare abstract class PluginCurveApi {
-    constructor();
-    /**
-     * Wrap a {@linkcode PLine} or {@linkcode PArc} as a {@linkcode PCurve}.
-     *
-     * This is an identity operation — it simply returns the input unchanged.
-     * It exists for type-level clarity when building mixed curve lists.
-     *
-     * @param curve - A {@linkcode PLine} or {@linkcode PArc} to wrap
-     * @returns The same value typed as {@linkcode PCurve}
-     */
-    new(curve: PLine | PArc): PCurve;
-}
-/**
- * A discriminated union of {@linkcode PLine} and {@linkcode PArc}.
- *
- * Discriminated on the `curveType` field:
- * - `"Line"` → {@linkcode PLine}
- * - `"Arc"` → {@linkcode PArc}
- *
- * Use `curve.curveType` to narrow the type in a switch or if-statement.
- */
-export declare const PCurve: z.ZodDiscriminatedUnion<[z.ZodObject<{
-    curveType: z.ZodLiteral<"Line">;
-    startPoint: z.ZodObject<{
-        x: z.ZodNumber;
-        y: z.ZodNumber;
-        z: z.ZodNumber;
-    }, z.core.$strip>;
-    endPoint: z.ZodObject<{
-        x: z.ZodNumber;
-        y: z.ZodNumber;
-        z: z.ZodNumber;
-    }, z.core.$strip>;
-}, z.core.$strip>, z.ZodObject<{
-    curveType: z.ZodLiteral<"Arc">;
-    startPoint: z.ZodObject<{
-        x: z.ZodNumber;
-        y: z.ZodNumber;
-        z: z.ZodNumber;
-    }, z.core.$strip>;
-    endPoint: z.ZodObject<{
-        x: z.ZodNumber;
-        y: z.ZodNumber;
-        z: z.ZodNumber;
-    }, z.core.$strip>;
-    centrePoint: z.ZodObject<{
-        x: z.ZodNumber;
-        y: z.ZodNumber;
-        z: z.ZodNumber;
-    }, z.core.$strip>;
-    axis: z.ZodObject<{
-        x: z.ZodNumber;
-        y: z.ZodNumber;
-        z: z.ZodNumber;
-    }, z.core.$strip>;
-}, z.core.$strip>], "curveType">;
-export type PCurve = z.infer<typeof PCurve>;
-//# sourceMappingURL=curve.d.ts.map

package/dist/api/core/geom/curve.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"curve.d.ts","sourceRoot":"","sources":["../../../../src/api/core/geom/curve.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AACxB,OAAO,EAAE,KAAK,EAAE,MAAM,QAAQ,CAAA;AAC9B,OAAO,EAAE,IAAI,EAAE,MAAM,OAAO,CAAA;AAE5B;;;;;;;GAOG;AACH,8BAAsB,cAAc;;IAGlC;;;;;;;;OAQG;IACH,GAAG,CAAC,KAAK,EAAE,KAAK,GAAG,IAAI,GAAG,MAAM;CAGjC;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gCAAmD,CAAA;AAEtE,MAAM,MAAM,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,MAAM,CAAC,CAAA"}

package/dist/api/core/geom/index.d.ts

@@ -1,32 +0,0 @@
-import { PluginLineApi } from "./line";
-import { PluginArcApi } from "./arc";
-import { PluginCurveApi } from "./curve";
-import { PluginProfileApi } from "./profile";
-/**
- * Geometry primitives for constructing 2D/3D shapes.
- *
- * Build geometry bottom-up: points ({@linkcode PVec3}) → lines/arcs → curves → profiles.
- * Profiles can then be used with entity creation methods like
- * {@linkcode PluginSpaceApi.createFromProfile}.
- *
- * - {@linkcode PluginGeomApi.line} — Line segment construction
- * - {@linkcode PluginGeomApi.arc} — Arc construction
- * - {@linkcode PluginGeomApi.curve} — Unified curve wrapper (line or arc)
- * - {@linkcode PluginGeomApi.profile} — Closed loop of curves
- */
-export declare abstract class PluginGeomApi {
-    /** Line segment construction. See {@linkcode PluginLineApi}. */
-    abstract line: PluginLineApi;
-    /** Arc construction. See {@linkcode PluginArcApi}. */
-    abstract arc: PluginArcApi;
-    /** Unified curve wrapper. See {@linkcode PluginCurveApi}. */
-    abstract curve: PluginCurveApi;
-    /** Closed profile (loop of curves). See {@linkcode PluginProfileApi}. */
-    abstract profile: PluginProfileApi;
-    constructor();
-}
-export * from "./line";
-export * from "./arc";
-export * from "./curve";
-export * from "./profile";
-//# sourceMappingURL=index.d.ts.map

package/dist/api/core/geom/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/api/core/geom/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,QAAQ,CAAA;AACtC,OAAO,EAAE,YAAY,EAAE,MAAM,OAAO,CAAA;AACpC,OAAO,EAAE,cAAc,EAAE,MAAM,SAAS,CAAA;AACxC,OAAO,EAAE,gBAAgB,EAAE,MAAM,WAAW,CAAA;AAE5C;;;;;;;;;;;GAWG;AACH,8BAAsB,aAAa;IACjC,gEAAgE;IAChE,SAAgB,IAAI,EAAE,aAAa,CAAA;IACnC,sDAAsD;IACtD,SAAgB,GAAG,EAAE,YAAY,CAAA;IACjC,6DAA6D;IAC7D,SAAgB,KAAK,EAAE,cAAc,CAAA;IACrC,yEAAyE;IACzE,SAAgB,OAAO,EAAE,gBAAgB,CAAA;;CAG1C;AAED,cAAc,QAAQ,CAAA;AACtB,cAAc,OAAO,CAAA;AACrB,cAAc,SAAS,CAAA;AACvB,cAAc,WAAW,CAAA"}

package/dist/api/core/geom/line.d.ts

@@ -1,56 +0,0 @@
-import * as z from "zod";
-import { PVec3 } from "../math/vec3";
-/**
- * Line segment construction.
- *
- * A {@linkcode PLine} is the simplest curve primitive — a straight
- * segment between two 3D points. Lines can be wrapped as a
- * {@linkcode PCurve} and combined into a {@linkcode PProfile}.
- *
- * Accessed via `snaptrude.core.geom.line`.
- */
-export declare abstract class PluginLineApi {
-    constructor();
-    /**
-     * Create a new line segment between two points.
-     *
-     * @param startPoint - The start point as a {@linkcode PVec3}
-     * @param endPoint - The end point as a {@linkcode PVec3}
-     * @returns A new {@linkcode PLine}
-     *
-     * # Example
-     * ```ts
-     * const { vec3 } = snaptrude.core.math
-     * const { line } = snaptrude.core.geom
-     *
-     * const edge = line.new(vec3.new(0, 0, 0), vec3.new(5, 0, 0))
-     * ```
-     */
-    new(startPoint: PVec3, endPoint: PVec3): PLine;
-}
-/**
- * A line segment defined by a start and end point.
- *
- * Discriminated by `curveType: "Line"` within the {@linkcode PCurve} union.
- *
- * | Property | Type | Description |
- * |---|---|---|
- * | `curveType` | `"Line"` | Discriminator tag |
- * | `startPoint` | {@linkcode PVec3} | Start point of the segment |
- * | `endPoint` | {@linkcode PVec3} | End point of the segment |
- */
-export declare const PLine: z.ZodObject<{
-    curveType: z.ZodLiteral<"Line">;
-    startPoint: z.ZodObject<{
-        x: z.ZodNumber;
-        y: z.ZodNumber;
-        z: z.ZodNumber;
-    }, z.core.$strip>;
-    endPoint: z.ZodObject<{
-        x: z.ZodNumber;
-        y: z.ZodNumber;
-        z: z.ZodNumber;
-    }, z.core.$strip>;
-}, z.core.$strip>;
-export type PLine = z.infer<typeof PLine>;
-//# sourceMappingURL=line.d.ts.map

package/dist/api/core/geom/line.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"line.d.ts","sourceRoot":"","sources":["../../../../src/api/core/geom/line.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AACxB,OAAO,EAAE,KAAK,EAAE,MAAM,cAAc,CAAA;AAEpC;;;;;;;;GAQG;AACH,8BAAsB,aAAa;;IAGjC;;;;;;;;;;;;;;OAcG;IACH,GAAG,CAAC,UAAU,EAAE,KAAK,EAAE,QAAQ,EAAE,KAAK,GAAG,KAAK;CAG/C;AAED;;;;;;;;;;GAUG;AACH,eAAO,MAAM,KAAK;;;;;;;;;;;;iBAIhB,CAAA;AAEF,MAAM,MAAM,KAAK,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,KAAK,CAAC,CAAA"}

package/dist/api/core/geom/profile.d.ts

@@ -1,121 +0,0 @@
-import * as z from "zod";
-import { PluginApiReturn } from "../../../types";
-import { PCurve } from "./curve";
-/**
- * Profile construction — a closed loop of {@linkcode PCurve}s.
- *
- * Profiles are the primary 2D shape primitive used for creating
- * extruded entities like spaces. Build profiles either from an
- * explicit list of curves or from a list of points (auto-connected
- * with line segments).
- *
- * Accessed via `snaptrude.core.geom.profile`.
- */
-export declare abstract class PluginProfileApi {
-    constructor();
-    /**
-     * Create a profile from an ordered list of curves.
-     *
-     * The curves should form a closed loop — the end point of each curve
-     * should coincide with the start point of the next.
-     *
-     * @param curves - An ordered array of {@linkcode PCurve}s forming a closed loop
-     * @returns A new {@linkcode PProfile}
-     */
-    new(curves: PCurve[]): PProfile;
-    /**
-     * Create a profile by connecting a list of points with line segments.
-     *
-     * The points are connected in order, with the last point automatically
-     * connected back to the first to close the loop.
-     *
-     * This is a **host API call** — it returns a `Promise`.
-     *
-     * @param args - An object containing:
-     *   - {@linkcode PluginProfileFromLinePointsArgs.points args.points} — An ordered
-     *     array of {@linkcode PVec3} forming the profile vertices
-     * @returns A {@linkcode PProfile} with line-segment curves connecting the points
-     *
-     * # Example
-     * ```ts
-     * const { vec3 } = snaptrude.core.math
-     *
-     * // Create an L-shaped profile
-     * const profile = await snaptrude.core.geom.profile.fromLinePoints({
-     *   points: [
-     *     vec3.new(0, 0, 0),
-     *     vec3.new(10, 0, 0),
-     *     vec3.new(10, 0, 5),
-     *     vec3.new(5, 0, 5),
-     *     vec3.new(5, 0, 10),
-     *     vec3.new(0, 0, 10),
-     *   ],
-     * })
-     * ```
-     */
-    abstract fromLinePoints(args: PluginProfileFromLinePointsArgs): PluginApiReturn<PProfile>;
-}
-/**
- * Arguments for {@linkcode PluginProfileApi.fromLinePoints}.
- *
- * | Property | Type | Description |
- * |---|---|---|
- * | `points` | {@linkcode PVec3}`[]` | Ordered vertices of the profile |
- */
-export declare const PluginProfileFromLinePointsArgs: z.ZodObject<{
-    points: z.ZodArray<z.ZodObject<{
-        x: z.ZodNumber;
-        y: z.ZodNumber;
-        z: z.ZodNumber;
-    }, z.core.$strip>>;
-}, z.core.$strip>;
-export type PluginProfileFromLinePointsArgs = z.infer<typeof PluginProfileFromLinePointsArgs>;
-/**
- * A closed profile composed of an ordered list of curves.
- *
- * Profiles are used as input to entity creation methods like
- * {@linkcode PluginSpaceApi.createFromProfile}.
- *
- * | Property | Type | Description |
- * |---|---|---|
- * | `curves` | {@linkcode PCurve}`[]` | Ordered curves forming a closed loop |
- */
-export declare const PProfile: z.ZodObject<{
-    curves: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
-        curveType: z.ZodLiteral<"Line">;
-        startPoint: z.ZodObject<{
-            x: z.ZodNumber;
-            y: z.ZodNumber;
-            z: z.ZodNumber;
-        }, z.core.$strip>;
-        endPoint: z.ZodObject<{
-            x: z.ZodNumber;
-            y: z.ZodNumber;
-            z: z.ZodNumber;
-        }, z.core.$strip>;
-    }, z.core.$strip>, z.ZodObject<{
-        curveType: z.ZodLiteral<"Arc">;
-        startPoint: z.ZodObject<{
-            x: z.ZodNumber;
-            y: z.ZodNumber;
-            z: z.ZodNumber;
-        }, z.core.$strip>;
-        endPoint: z.ZodObject<{
-            x: z.ZodNumber;
-            y: z.ZodNumber;
-            z: z.ZodNumber;
-        }, z.core.$strip>;
-        centrePoint: z.ZodObject<{
-            x: z.ZodNumber;
-            y: z.ZodNumber;
-            z: z.ZodNumber;
-        }, z.core.$strip>;
-        axis: z.ZodObject<{
-            x: z.ZodNumber;
-            y: z.ZodNumber;
-            z: z.ZodNumber;
-        }, z.core.$strip>;
-    }, z.core.$strip>], "curveType">>;
-}, z.core.$strip>;
-export type PProfile = z.infer<typeof PProfile>;
-//# sourceMappingURL=profile.d.ts.map

package/dist/api/core/geom/profile.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"profile.d.ts","sourceRoot":"","sources":["../../../../src/api/core/geom/profile.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AACxB,OAAO,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAA;AAEhD,OAAO,EAAE,MAAM,EAAE,MAAM,SAAS,CAAA;AAEhC;;;;;;;;;GASG;AACH,8BAAsB,gBAAgB;;IAGpC;;;;;;;;OAQG;IACH,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,QAAQ;IAI/B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6BG;aACa,cAAc,CAC5B,IAAI,EAAE,+BAA+B,GACpC,eAAe,CAAC,QAAQ,CAAC;CAC7B;AAED;;;;;;GAMG;AACH,eAAO,MAAM,+BAA+B;;;;;;iBAE1C,CAAA;AAEF,MAAM,MAAM,+BAA+B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,+BAA+B,CAAC,CAAA;AAE7F;;;;;;;;;GASG;AACH,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAEnB,CAAA;AAEF,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,QAAQ,CAAC,CAAA"}

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

@@ -1,18 +0,0 @@
-import { PluginMathApi } from "./math";
-import { PluginGeomApi } from "./geom";
-/**
- * Core primitives used across the plugin API.
- *
- * - {@linkcode PluginCoreApi.math} — Vector and quaternion operations
- * - {@linkcode PluginCoreApi.geom} — Geometry primitives (lines, arcs, curves, profiles)
- */
-export declare abstract class PluginCoreApi {
-    /** Vector and quaternion math utilities. See {@linkcode PluginMathApi}. */
-    abstract math: PluginMathApi;
-    /** Geometry primitives and constructors. See {@linkcode PluginGeomApi}. */
-    abstract geom: PluginGeomApi;
-    constructor();
-}
-export * from "./math";
-export * from "./geom";
-//# sourceMappingURL=index.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/api/core/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,QAAQ,CAAA;AACtC,OAAO,EAAE,aAAa,EAAE,MAAM,QAAQ,CAAA;AAEtC;;;;;GAKG;AACH,8BAAsB,aAAa;IACjC,2EAA2E;IAC3E,SAAgB,IAAI,EAAE,aAAa,CAAA;IACnC,2EAA2E;IAC3E,SAAgB,IAAI,EAAE,aAAa,CAAA;;CAGpC;AAED,cAAc,QAAQ,CAAA;AACtB,cAAc,QAAQ,CAAA"}

package/dist/api/core/math/index.d.ts

@@ -1,18 +0,0 @@
-import { PluginVec3Api } from "./vec3";
-import { PluginQuatApi } from "./quat";
-/**
- * Math primitives for 3D vector and quaternion operations.
- *
- * - {@linkcode PluginMathApi.vec3} — 3D vector creation and arithmetic
- * - {@linkcode PluginMathApi.quat} — Quaternion creation and rotation operations
- */
-export declare abstract class PluginMathApi {
-    /** 3D vector operations. See {@linkcode PluginVec3Api}. */
-    abstract vec3: PluginVec3Api;
-    /** Quaternion operations. See {@linkcode PluginQuatApi}. */
-    abstract quat: PluginQuatApi;
-    constructor();
-}
-export * from "./vec3";
-export * from "./quat";
-//# sourceMappingURL=index.d.ts.map

package/dist/api/core/math/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/api/core/math/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,QAAQ,CAAA;AACtC,OAAO,EAAE,aAAa,EAAE,MAAM,QAAQ,CAAA;AAEtC;;;;;GAKG;AACH,8BAAsB,aAAa;IACjC,2DAA2D;IAC3D,SAAgB,IAAI,EAAE,aAAa,CAAA;IACnC,4DAA4D;IAC5D,SAAgB,IAAI,EAAE,aAAa,CAAA;;CAGpC;AAED,cAAc,QAAQ,CAAA;AACtB,cAAc,QAAQ,CAAA"}