@snaptrude/plugin-core 0.3.0 → 0.6.0

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

@@ -0,0 +1,247 @@
+import * as z from "zod";
+import { PluginApiReturn } from "../../../../types";
+import { Vec3Handle, LineHandle, ArcHandle, CircleHandle, CurveHandle, ProfileHandle, ContourHandle } from "../../../../handles";
+/**
+ * Curve creation — construct new geometric curves from point handles (all-handle
+ * model, §11).
+ *
+ * Each method takes point handles ({@linkcode Vec3Handle}) and returns an opaque
+ * curve handle ({@linkcode LineHandle} or {@linkcode ArcHandle}) that you pass to
+ * query, update, or entity-creation methods. Read geometry back as plain values
+ * via the `snaptrude.core.geom.query.*` methods.
+ *
+ * Accessed via `snaptrude.core.geom.create`.
+ */
+export declare abstract class PluginGeomCreateApi {
+    constructor();
+    /**
+     * Create a straight line segment between two point handles. Host API call —
+     * returns a handle.
+     *
+     * @param startPoint Start point of the line segment
+     * @param endPoint End point of the line segment
+     * @returns The new line as a {@linkcode LineHandle}
+     *
+     * @examplePrompt Draw a line from point A to point B
+     * @examplePrompt Draw a straight edge between these two points
+     *
+     * @example
+     * ```ts
+     * const line = snaptrude.core.geom.create.line(startPoint, endPoint)
+     * ```
+     */
+    abstract line(startPoint: Vec3Handle, endPoint: Vec3Handle): PluginApiReturn<LineHandle>;
+    /**
+     * Create a circular arc from its start, end, centre, and axis point handles.
+     * Host API call — returns a handle.
+     *
+     * @param startPoint Start point of the arc
+     * @param endPoint End point of the arc
+     * @param centrePoint Centre point of the arc
+     * @param axis Axis direction of the arc
+     * @returns The new arc as an {@linkcode ArcHandle}
+     *
+     * @examplePrompt Draw an arc between these two points around a centre
+     * @examplePrompt Add a curved segment from A to B
+     *
+     * @example
+     * ```ts
+     * const arc = snaptrude.core.geom.create.arc(startPoint, endPoint, centrePoint, axis)
+     * ```
+     */
+    abstract arc(startPoint: Vec3Handle, endPoint: Vec3Handle, centrePoint: Vec3Handle, axis: Vec3Handle): PluginApiReturn<ArcHandle>;
+    /**
+     * Create a circle from a centre point, an axis (plane normal), and a radius.
+     * Host API call — returns a handle. A circle is a closed curve; read it back via
+     * `snaptrude.core.geom.query.circle.*`.
+     *
+     * @param centrePoint Centre point of the circle
+     * @param axis Axis direction (plane normal) of the circle
+     * @param radius Radius of the circle
+     * @returns The new circle as a {@linkcode CircleHandle}
+     *
+     * @examplePrompt Make a circle of radius 2 at this point
+     * @examplePrompt Draw a circular outline 5m across
+     *
+     * @example
+     * ```ts
+     * const circle = snaptrude.core.geom.create.circle(centrePoint, axis, 2)
+     * ```
+     */
+    abstract circle(centrePoint: Vec3Handle, axis: Vec3Handle, radius: number): PluginApiReturn<CircleHandle>;
+    /**
+     * Create a closed profile from an ordered list of point handles connected by
+     * line segments (last auto-connected to first). Host API call — returns a handle.
+     *
+     * @param points Ordered vertex handles of the profile
+     * @returns The new profile as a {@linkcode ProfileHandle}
+     *
+     * @examplePrompt Draw a closed polygon through these corner points
+     * @examplePrompt Create an L-shaped outline from a list of points
+     *
+     * @example
+     * ```ts
+     * const profile = snaptrude.core.geom.create.profileFromLinePoints(points)
+     * ```
+     */
+    abstract profileFromLinePoints(points: Vec3Handle[]): PluginApiReturn<ProfileHandle>;
+    /**
+     * Create a profile from an ordered list of curve handles forming a closed loop.
+     * Host API call — returns a handle.
+     *
+     * @param curves Ordered curve handles forming a closed loop
+     * @returns The new profile as a {@linkcode ProfileHandle}
+     *
+     * @examplePrompt Join these lines and arcs into one closed shape
+     *
+     * @example
+     * ```ts
+     * const profile = snaptrude.core.geom.create.profileFromCurves([line, arc])
+     * ```
+     */
+    abstract profileFromCurves(curves: CurveHandle[]): PluginApiReturn<ProfileHandle>;
+    /**
+     * Create an axis-aligned **rectangle** profile (XZ plane) of `width` × `depth`,
+     * centred at `center` (defaults to the origin). Host API call — returns a handle.
+     *
+     * Pair with `design.create.space` / `design.create.spaces` to author a rectangular
+     * (box) space — there is no dedicated rectangular-space creator; build the profile
+     * here, then extrude it.
+     *
+     * @param width Extent along X
+     * @param depth Extent along Z
+     * @param center Optional centre point (default origin)
+     * @returns The new rectangle profile as a {@linkcode ProfileHandle}
+     *
+     * @examplePrompt Draw a 4m by 3m rectangle
+     * @examplePrompt Make a rectangular outline for a room footprint
+     *
+     * @example
+     * ```ts
+     * const rect = snaptrude.core.geom.create.profileRect(4, 3)
+     * const contour = snaptrude.core.geom.create.contourFromProfile(rect)
+     * const space = snaptrude.design.create.space(contour, 3)
+     * ```
+     */
+    abstract profileRect(width: number, depth: number, center?: Vec3Handle): PluginApiReturn<ProfileHandle>;
+    /**
+     * Create a contour (an outer profile loop, no holes). Host API call — returns a handle.
+     *
+     * @param outer The outer boundary loop
+     * @returns The new contour as a {@linkcode ContourHandle}
+     * @example
+     * ```ts
+     * const contour = snaptrude.core.geom.create.contourFromProfile(outer)
+     * ```
+     */
+    abstract contourFromProfile(outer: ProfileHandle): PluginApiReturn<ContourHandle>;
+    /**
+     * Create a contour from an outer profile plus zero or more inner profiles (holes).
+     * Host API call — returns a handle.
+     *
+     * @param outer The outer boundary loop
+     * @param holes Optional inner hole loops
+     * @returns The new contour as a {@linkcode ContourHandle}
+     *
+     * @examplePrompt Make a shape with a hole in the middle
+     * @examplePrompt Cut a courtyard opening out of this floor outline
+     *
+     * @example
+     * ```ts
+     * const contour = snaptrude.core.geom.create.contourFromProfiles(outer, [hole])
+     * ```
+     */
+    abstract contourFromProfiles(outer: ProfileHandle, holes?: ProfileHandle[]): PluginApiReturn<ContourHandle>;
+}
+/**
+ * Arguments for {@linkcode PluginGeomCreateApi.line}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `startPoint` | {@linkcode Vec3Handle} | Start point of the line segment |
+ * | `endPoint` | {@linkcode Vec3Handle} | End point of the line segment |
+ */
+export declare const PluginGeomCreateLineArgs: z.ZodObject<{
+    startPoint: z.ZodPipe<z.ZodString, z.ZodTransform<import("../../../..").Handle<"vec3">, string>>;
+    endPoint: z.ZodPipe<z.ZodString, z.ZodTransform<import("../../../..").Handle<"vec3">, string>>;
+}, z.core.$strip>;
+export type PluginGeomCreateLineArgs = z.infer<typeof PluginGeomCreateLineArgs>;
+/**
+ * Arguments for {@linkcode PluginGeomCreateApi.arc}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `startPoint` | {@linkcode Vec3Handle} | Start point of the arc |
+ * | `endPoint` | {@linkcode Vec3Handle} | End point of the arc |
+ * | `centrePoint` | {@linkcode Vec3Handle} | Centre point of the arc |
+ * | `axis` | {@linkcode Vec3Handle} | Axis direction of the arc |
+ */
+export declare const PluginGeomCreateArcArgs: z.ZodObject<{
+    startPoint: z.ZodPipe<z.ZodString, z.ZodTransform<import("../../../..").Handle<"vec3">, string>>;
+    endPoint: z.ZodPipe<z.ZodString, z.ZodTransform<import("../../../..").Handle<"vec3">, string>>;
+    centrePoint: z.ZodPipe<z.ZodString, z.ZodTransform<import("../../../..").Handle<"vec3">, string>>;
+    axis: z.ZodPipe<z.ZodString, z.ZodTransform<import("../../../..").Handle<"vec3">, string>>;
+}, z.core.$strip>;
+export type PluginGeomCreateArcArgs = z.infer<typeof PluginGeomCreateArcArgs>;
+/**
+ * Arguments for {@linkcode PluginGeomCreateApi.circle}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `centrePoint` | {@linkcode Vec3Handle} | Centre point of the circle |
+ * | `axis` | {@linkcode Vec3Handle} | Axis direction (plane normal) of the circle |
+ * | `radius` | `number` | Radius of the circle |
+ */
+export declare const PluginGeomCreateCircleArgs: z.ZodObject<{
+    centrePoint: z.ZodPipe<z.ZodString, z.ZodTransform<import("../../../..").Handle<"vec3">, string>>;
+    axis: z.ZodPipe<z.ZodString, z.ZodTransform<import("../../../..").Handle<"vec3">, string>>;
+    radius: z.ZodNumber;
+}, z.core.$strip>;
+export type PluginGeomCreateCircleArgs = z.infer<typeof PluginGeomCreateCircleArgs>;
+/**
+ * Arguments for {@linkcode PluginGeomCreateApi.profileFromLinePoints}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `points` | {@linkcode Vec3Handle}`[]` | Ordered vertex handles of the profile |
+ */
+export declare const PluginGeomCreateProfileFromLinePointsArgs: z.ZodObject<{
+    points: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("../../../..").Handle<"vec3">, string>>>;
+}, z.core.$strip>;
+export type PluginGeomCreateProfileFromLinePointsArgs = z.infer<typeof PluginGeomCreateProfileFromLinePointsArgs>;
+/**
+ * Arguments for {@linkcode PluginGeomCreateApi.profileFromCurves}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `curves` | {@linkcode CurveHandle}`[]` | Ordered curve handles forming a closed loop |
+ */
+export declare const PluginGeomCreateProfileFromCurvesArgs: z.ZodObject<{
+    curves: z.ZodArray<z.ZodUnion<readonly [z.ZodPipe<z.ZodString, z.ZodTransform<import("../../../..").Handle<"line">, string>>, z.ZodPipe<z.ZodString, z.ZodTransform<import("../../../..").Handle<"arc">, string>>]>>;
+}, z.core.$strip>;
+export type PluginGeomCreateProfileFromCurvesArgs = z.infer<typeof PluginGeomCreateProfileFromCurvesArgs>;
+/**
+ * Arguments for {@linkcode PluginGeomCreateApi.contourFromProfile}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `outer` | {@linkcode ProfileHandle} | The outer boundary loop |
+ */
+export declare const PluginGeomCreateContourFromProfileArgs: z.ZodObject<{
+    outer: z.ZodPipe<z.ZodString, z.ZodTransform<import("../../../..").Handle<"profile">, string>>;
+}, z.core.$strip>;
+export type PluginGeomCreateContourFromProfileArgs = z.infer<typeof PluginGeomCreateContourFromProfileArgs>;
+/**
+ * Arguments for {@linkcode PluginGeomCreateApi.contourFromProfiles}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `outer` | {@linkcode ProfileHandle} | The outer boundary loop |
+ * | `holes` | {@linkcode ProfileHandle}`[]` | Optional inner hole loops |
+ */
+export declare const PluginGeomCreateContourFromProfilesArgs: z.ZodObject<{
+    outer: z.ZodPipe<z.ZodString, z.ZodTransform<import("../../../..").Handle<"profile">, string>>;
+    holes: z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("../../../..").Handle<"profile">, string>>>>;
+}, z.core.$strip>;
+export type PluginGeomCreateContourFromProfilesArgs = z.infer<typeof PluginGeomCreateContourFromProfilesArgs>;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/api/core/geom/create/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AACxB,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAA;AACnD,OAAO,EAAE,UAAU,EAAE,UAAU,EAAE,SAAS,EAAE,YAAY,EAAE,WAAW,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAA;AAEhI;;;;;;;;;;GAUG;AACH,8BAAsB,mBAAmB;;IAGvC;;;;;;;;;;;;;;;OAeG;aACa,IAAI,CAAC,UAAU,EAAE,UAAU,EAAE,QAAQ,EAAE,UAAU,GAAG,eAAe,CAAC,UAAU,CAAC;IAE/F;;;;;;;;;;;;;;;;;OAiBG;aACa,GAAG,CACjB,UAAU,EAAE,UAAU,EACtB,QAAQ,EAAE,UAAU,EACpB,WAAW,EAAE,UAAU,EACvB,IAAI,EAAE,UAAU,GACf,eAAe,CAAC,SAAS,CAAC;IAE7B;;;;;;;;;;;;;;;;;OAiBG;aACa,MAAM,CACpB,WAAW,EAAE,UAAU,EACvB,IAAI,EAAE,UAAU,EAChB,MAAM,EAAE,MAAM,GACb,eAAe,CAAC,YAAY,CAAC;IAEhC;;;;;;;;;;;;;;OAcG;aACa,qBAAqB,CAAC,MAAM,EAAE,UAAU,EAAE,GAAG,eAAe,CAAC,aAAa,CAAC;IAE3F;;;;;;;;;;;;;OAaG;aACa,iBAAiB,CAAC,MAAM,EAAE,WAAW,EAAE,GAAG,eAAe,CAAC,aAAa,CAAC;IAExF;;;;;;;;;;;;;;;;;;;;;;OAsBG;aACa,WAAW,CACzB,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,MAAM,EACb,MAAM,CAAC,EAAE,UAAU,GAClB,eAAe,CAAC,aAAa,CAAC;IAEjC;;;;;;;;;OASG;aACa,kBAAkB,CAAC,KAAK,EAAE,aAAa,GAAG,eAAe,CAAC,aAAa,CAAC;IAExF;;;;;;;;;;;;;;;OAeG;aACa,mBAAmB,CACjC,KAAK,EAAE,aAAa,EACpB,KAAK,CAAC,EAAE,aAAa,EAAE,GACtB,eAAe,CAAC,aAAa,CAAC;CAClC;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,wBAAwB;;;iBAGnC,CAAA;AAEF,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAA;AAE/E;;;;;;;;;GASG;AACH,eAAO,MAAM,uBAAuB;;;;;iBAKlC,CAAA;AAEF,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAA;AAE7E;;;;;;;;GAQG;AACH,eAAO,MAAM,0BAA0B;;;;iBAIrC,CAAA;AAEF,MAAM,MAAM,0BAA0B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAA;AAEnF;;;;;;GAMG;AACH,eAAO,MAAM,yCAAyC;;iBAEpD,CAAA;AAEF,MAAM,MAAM,yCAAyC,GAAG,CAAC,CAAC,KAAK,CAC7D,OAAO,yCAAyC,CACjD,CAAA;AAED;;;;;;GAMG;AACH,eAAO,MAAM,qCAAqC;;iBAEhD,CAAA;AAEF,MAAM,MAAM,qCAAqC,GAAG,CAAC,CAAC,KAAK,CACzD,OAAO,qCAAqC,CAC7C,CAAA;AAED;;;;;;GAMG;AACH,eAAO,MAAM,sCAAsC;;iBAEjD,CAAA;AAEF,MAAM,MAAM,sCAAsC,GAAG,CAAC,CAAC,KAAK,CAC1D,OAAO,sCAAsC,CAC9C,CAAA;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,uCAAuC;;;iBAGlD,CAAA;AAEF,MAAM,MAAM,uCAAuC,GAAG,CAAC,CAAC,KAAK,CAC3D,OAAO,uCAAuC,CAC/C,CAAA"}

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

@@ -0,0 +1,72 @@
+import * as z from "zod";
+import { PluginApiReturn } from "../../../../types";
+import { ProfileHandle, ContourHandle } from "../../../../handles";
+/**
+ * Geometry deletion — release transient geometry resource handles (all-handle model, §11).
+ *
+ * Methods here free a handle's backing registry entry and reclaim its share of the
+ * plugin's resource quota. This is purely a handle-lifecycle operation: it does NOT
+ * tear down or delete any engine-side geometry. Once released, the handle is no
+ * longer resolvable and must not be reused.
+ *
+ * Accessed via `snaptrude.core.geom.delete`.
+ */
+export declare abstract class PluginGeomDeleteApi {
+    constructor();
+    /**
+     * Free a transient profile resource handle — releases its registry entry and
+     * reclaims its share of the plugin's resource quota. This is a handle-lifecycle
+     * operation only and does NOT tear down any engine-side geometry.
+     *
+     * @param profile The transient profile handle to release
+     * @returns Nothing
+     *
+     * # Example
+     * ```ts
+     * const rect = await snaptrude.core.geom.create.profileRect(4, 3)
+     * const area = await snaptrude.core.geom.query.profile.getArea(rect)
+     * await snaptrude.core.geom.delete.profile(rect) // rect is no longer resolvable
+     * ```
+     */
+    abstract profile(profile: ProfileHandle): PluginApiReturn<void>;
+    /**
+     * Free a transient contour resource handle — releases its registry entry and
+     * reclaims its share of the plugin's resource quota. Handle-lifecycle only; does
+     * NOT tear down engine-side geometry, nor the contour's child profile handles.
+     *
+     * @param contour The transient contour handle to release
+     * @returns Nothing
+     *
+     * # Example
+     * ```ts
+     * const rect = await snaptrude.core.geom.create.profileRect(4, 3)
+     * const contour = await snaptrude.core.geom.create.contourFromProfile(rect)
+     * const area = await snaptrude.core.geom.query.contour.getArea(contour)
+     * await snaptrude.core.geom.delete.contour(contour) // contour freed; rect still valid
+     * ```
+     */
+    abstract contour(contour: ContourHandle): PluginApiReturn<void>;
+}
+/**
+ * Arguments for {@linkcode PluginGeomDeleteApi.profile}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `profile` | {@linkcode ProfileHandle} | The transient profile handle to release |
+ */
+export declare const PluginGeomDeleteProfileArgs: z.ZodObject<{
+    profile: z.ZodPipe<z.ZodString, z.ZodTransform<import("../../../..").Handle<"profile">, string>>;
+}, z.core.$strip>;
+export type PluginGeomDeleteProfileArgs = z.infer<typeof PluginGeomDeleteProfileArgs>;
+/**
+ * Arguments for {@linkcode PluginGeomDeleteApi.contour}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `contour` | {@linkcode ContourHandle} | The transient contour handle to release |
+ */
+export declare const PluginGeomDeleteContourArgs: z.ZodObject<{
+    contour: z.ZodPipe<z.ZodString, z.ZodTransform<import("../../../..").Handle<"contour">, string>>;
+}, z.core.$strip>;
+export type PluginGeomDeleteContourArgs = z.infer<typeof PluginGeomDeleteContourArgs>;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/api/core/geom/delete/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AACxB,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAA;AACnD,OAAO,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAA;AAElE;;;;;;;;;GASG;AACH,8BAAsB,mBAAmB;;IAGvC;;;;;;;;;;;;;;OAcG;aACa,OAAO,CAAC,OAAO,EAAE,aAAa,GAAG,eAAe,CAAC,IAAI,CAAC;IAEtE;;;;;;;;;;;;;;;OAeG;aACa,OAAO,CAAC,OAAO,EAAE,aAAa,GAAG,eAAe,CAAC,IAAI,CAAC;CACvE;AAED;;;;;;GAMG;AACH,eAAO,MAAM,2BAA2B;;iBAEtC,CAAA;AAEF,MAAM,MAAM,2BAA2B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAA;AAErF;;;;;;GAMG;AACH,eAAO,MAAM,2BAA2B;;iBAEtC,CAAA;AAEF,MAAM,MAAM,2BAA2B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAA"}

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

@@ -1,32 +1,33 @@
-import { PluginLineApi } from "./line";
-import { PluginArcApi } from "./arc";
-import { PluginCurveApi } from "./curve";
-import { PluginProfileApi } from "./profile";
+import { PluginGeomCreateApi } from "./create";
+import { PluginGeomQueryApi } from "./query";
+import { PluginGeomUpdateApi } from "./update";
+import { PluginGeomDeleteApi } from "./delete";
 /**
- * Geometry primitives for constructing 2D/3D shapes.
+ * Geometry kernel — domain-free construction, query, editing, and disposal of
+ * curves (lines / arcs) and profiles. No BIM/AEC knowledge lives here; build
+ * geometry bottom-up: points ({@linkcode Vec3Handle}) → curves → profiles → entities.
+ *
+ * - {@linkcode PluginGeomApi.create} — construct lines, arcs, and profiles
+ * - {@linkcode PluginGeomApi.query} — read curve / arc / profile geometry and relationships
+ * - {@linkcode PluginGeomApi.update} — derive new curves / profiles (immutable edits)
+ * - {@linkcode PluginGeomApi.delete} — free a transient profile resource handle
  *
- * 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;
+    /** Curve and profile construction. See {@linkcode PluginGeomCreateApi}. */
+    abstract create: PluginGeomCreateApi;
+    /** Curve, arc, and profile queries. See {@linkcode PluginGeomQueryApi}. */
+    abstract query: PluginGeomQueryApi;
+    /** Curve and profile editing (derive-new). See {@linkcode PluginGeomUpdateApi}. */
+    abstract update: PluginGeomUpdateApi;
+    /** Resource-handle disposal (profile). See {@linkcode PluginGeomDeleteApi}. */
+    abstract delete: PluginGeomDeleteApi;
     constructor();
 }
-export * from "./line";
-export * from "./arc";
-export * from "./curve";
-export * from "./profile";
+export * from "./create";
+export * from "./query";
+export * from "./update";
+export * from "./delete";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"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"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/api/core/geom/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,MAAM,UAAU,CAAA;AAC9C,OAAO,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAA;AAC5C,OAAO,EAAE,mBAAmB,EAAE,MAAM,UAAU,CAAA;AAC9C,OAAO,EAAE,mBAAmB,EAAE,MAAM,UAAU,CAAA;AAE9C;;;;;;;;;;;;GAYG;AACH,8BAAsB,aAAa;IACjC,2EAA2E;IAC3E,SAAgB,MAAM,EAAE,mBAAmB,CAAA;IAC3C,2EAA2E;IAC3E,SAAgB,KAAK,EAAE,kBAAkB,CAAA;IACzC,mFAAmF;IACnF,SAAgB,MAAM,EAAE,mBAAmB,CAAA;IAC3C,+EAA+E;IAC/E,SAAgB,MAAM,EAAE,mBAAmB,CAAA;;CAG5C;AAED,cAAc,UAAU,CAAA;AACxB,cAAc,SAAS,CAAA;AACvB,cAAc,UAAU,CAAA;AACxB,cAAc,UAAU,CAAA"}

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

@@ -0,0 +1,169 @@
+import * as z from "zod";
+import { PluginApiReturn } from "../../../../types";
+import { ArcHandle, Vec3Components } from "../../../../handles";
+/**
+ * Arc-specific geometry queries — read circular-arc properties as plain values.
+ *
+ * Every method takes an opaque {@linkcode ArcHandle} and returns plain values
+ * (numbers or {@linkcode Vec3Components}), never a handle. Use these to inspect
+ * the radius, centre, axis, sweep angle, and validity of an arc handle obtained
+ * from {@linkcode PluginGeomCreateApi.arc} or another query.
+ *
+ * Accessed via `snaptrude.core.geom.query.arc`.
+ */
+export declare abstract class PluginGeomQueryArcApi {
+    constructor();
+    /**
+     * Read the radius of an arc.
+     *
+     * @param arc The arc to query
+     * @returns The arc radius as a `number`
+     *
+     * @examplePrompt What is the radius of this curved wall segment?
+     * @examplePrompt Measure the radius of the selected arc
+     *
+     * # Example
+     * ```ts
+     * const start = await snaptrude.core.math.vec3.new(5, 0, 0)
+     * const end = await snaptrude.core.math.vec3.new(0, 0, 5)
+     * const origin = await snaptrude.core.math.vec3.new(0, 0, 0)
+     * const up = await snaptrude.core.math.vec3.new(0, 1, 0)
+     * const arc = await snaptrude.core.geom.create.arc(start, end, origin, up)
+     * const radius = await snaptrude.core.geom.query.arc.getRadius(arc)
+     * ```
+     */
+    abstract getRadius(arc: ArcHandle): PluginApiReturn<number>;
+    /**
+     * Read the centre point of an arc.
+     *
+     * @param arc The arc to query
+     * @returns The arc centre as {@linkcode Vec3Components}
+     *
+     * @examplePrompt Where is the centre of this arc?
+     * @examplePrompt Find the center point of the curved wall
+     *
+     * # Example
+     * ```ts
+     * const start = await snaptrude.core.math.vec3.new(5, 0, 0)
+     * const end = await snaptrude.core.math.vec3.new(0, 0, 5)
+     * const origin = await snaptrude.core.math.vec3.new(0, 0, 0)
+     * const up = await snaptrude.core.math.vec3.new(0, 1, 0)
+     * const arc = await snaptrude.core.geom.create.arc(start, end, origin, up)
+     * const centre = await snaptrude.core.geom.query.arc.getCentre(arc)
+     * console.log(centre.x, centre.y, centre.z)
+     * ```
+     */
+    abstract getCentre(arc: ArcHandle): PluginApiReturn<Vec3Components>;
+    /**
+     * Read the rotation axis of an arc.
+     *
+     * @param arc The arc to query
+     * @returns The arc axis as {@linkcode Vec3Components}
+     *
+     * # Example
+     * ```ts
+     * const start = await snaptrude.core.math.vec3.new(5, 0, 0)
+     * const end = await snaptrude.core.math.vec3.new(0, 0, 5)
+     * const origin = await snaptrude.core.math.vec3.new(0, 0, 0)
+     * const up = await snaptrude.core.math.vec3.new(0, 1, 0)
+     * const arc = await snaptrude.core.geom.create.arc(start, end, origin, up)
+     * const axis = await snaptrude.core.geom.query.arc.getAxis(arc)
+     * console.log(axis.x, axis.y, axis.z)
+     * ```
+     */
+    abstract getAxis(arc: ArcHandle): PluginApiReturn<Vec3Components>;
+    /**
+     * Read the sweep angle of an arc (the angle subtended at its centre).
+     *
+     * @param arc The arc to query
+     * @returns The sweep angle in radians as a `number`
+     *
+     * @examplePrompt What angle does this arc sweep through?
+     * @examplePrompt How many degrees does this curved wall turn?
+     *
+     * # Example
+     * ```ts
+     * const start = await snaptrude.core.math.vec3.new(5, 0, 0)
+     * const end = await snaptrude.core.math.vec3.new(0, 0, 5)
+     * const origin = await snaptrude.core.math.vec3.new(0, 0, 0)
+     * const up = await snaptrude.core.math.vec3.new(0, 1, 0)
+     * const arc = await snaptrude.core.geom.create.arc(start, end, origin, up)
+     * const sweep = await snaptrude.core.geom.query.arc.getSweepAngle(arc)
+     * console.log("degrees:", (sweep * 180) / Math.PI)
+     * ```
+     */
+    abstract getSweepAngle(arc: ArcHandle): PluginApiReturn<number>;
+    /**
+     * Check whether an arc is geometrically valid.
+     *
+     * @param arc The arc to query
+     * @returns `true` if the arc is valid as a `boolean`
+     *
+     * # Example
+     * ```ts
+     * const start = await snaptrude.core.math.vec3.new(5, 0, 0)
+     * const end = await snaptrude.core.math.vec3.new(0, 0, 5)
+     * const origin = await snaptrude.core.math.vec3.new(0, 0, 0)
+     * const up = await snaptrude.core.math.vec3.new(0, 1, 0)
+     * const arc = await snaptrude.core.geom.create.arc(start, end, origin, up)
+     * const ok = await snaptrude.core.geom.query.arc.isValid(arc)
+     * ```
+     */
+    abstract isValid(arc: ArcHandle): PluginApiReturn<boolean>;
+}
+/**
+ * Arguments for {@linkcode PluginGeomQueryArcApi.getRadius}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `arc` | {@linkcode ArcHandle} | The arc to query |
+ */
+export declare const PluginGeomQueryArcGetRadiusArgs: z.ZodObject<{
+    arc: z.ZodPipe<z.ZodString, z.ZodTransform<import("../../../..").Handle<"arc">, string>>;
+}, z.core.$strip>;
+export type PluginGeomQueryArcGetRadiusArgs = z.infer<typeof PluginGeomQueryArcGetRadiusArgs>;
+/**
+ * Arguments for {@linkcode PluginGeomQueryArcApi.getCentre}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `arc` | {@linkcode ArcHandle} | The arc to query |
+ */
+export declare const PluginGeomQueryArcGetCentreArgs: z.ZodObject<{
+    arc: z.ZodPipe<z.ZodString, z.ZodTransform<import("../../../..").Handle<"arc">, string>>;
+}, z.core.$strip>;
+export type PluginGeomQueryArcGetCentreArgs = z.infer<typeof PluginGeomQueryArcGetCentreArgs>;
+/**
+ * Arguments for {@linkcode PluginGeomQueryArcApi.getAxis}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `arc` | {@linkcode ArcHandle} | The arc to query |
+ */
+export declare const PluginGeomQueryArcGetAxisArgs: z.ZodObject<{
+    arc: z.ZodPipe<z.ZodString, z.ZodTransform<import("../../../..").Handle<"arc">, string>>;
+}, z.core.$strip>;
+export type PluginGeomQueryArcGetAxisArgs = z.infer<typeof PluginGeomQueryArcGetAxisArgs>;
+/**
+ * Arguments for {@linkcode PluginGeomQueryArcApi.getSweepAngle}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `arc` | {@linkcode ArcHandle} | The arc to query |
+ */
+export declare const PluginGeomQueryArcGetSweepAngleArgs: z.ZodObject<{
+    arc: z.ZodPipe<z.ZodString, z.ZodTransform<import("../../../..").Handle<"arc">, string>>;
+}, z.core.$strip>;
+export type PluginGeomQueryArcGetSweepAngleArgs = z.infer<typeof PluginGeomQueryArcGetSweepAngleArgs>;
+/**
+ * Arguments for {@linkcode PluginGeomQueryArcApi.isValid}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `arc` | {@linkcode ArcHandle} | The arc to query |
+ */
+export declare const PluginGeomQueryArcIsValidArgs: z.ZodObject<{
+    arc: z.ZodPipe<z.ZodString, z.ZodTransform<import("../../../..").Handle<"arc">, string>>;
+}, z.core.$strip>;
+export type PluginGeomQueryArcIsValidArgs = z.infer<typeof PluginGeomQueryArcIsValidArgs>;
+//# sourceMappingURL=arc.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"arc.d.ts","sourceRoot":"","sources":["../../../../../src/api/core/geom/query/arc.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AACxB,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAA;AACnD,OAAO,EAAE,SAAS,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAA;AAE/D;;;;;;;;;GASG;AACH,8BAAsB,qBAAqB;;IAGzC;;;;;;;;;;;;;;;;;;OAkBG;aACa,SAAS,CAAC,GAAG,EAAE,SAAS,GAAG,eAAe,CAAC,MAAM,CAAC;IAElE;;;;;;;;;;;;;;;;;;;OAmBG;aACa,SAAS,CAAC,GAAG,EAAE,SAAS,GAAG,eAAe,CAAC,cAAc,CAAC;IAE1E;;;;;;;;;;;;;;;;OAgBG;aACa,OAAO,CAAC,GAAG,EAAE,SAAS,GAAG,eAAe,CAAC,cAAc,CAAC;IAExE;;;;;;;;;;;;;;;;;;;OAmBG;aACa,aAAa,CAAC,GAAG,EAAE,SAAS,GAAG,eAAe,CAAC,MAAM,CAAC;IAEtE;;;;;;;;;;;;;;;OAeG;aACa,OAAO,CAAC,GAAG,EAAE,SAAS,GAAG,eAAe,CAAC,OAAO,CAAC;CAClE;AAED;;;;;;GAMG;AACH,eAAO,MAAM,+BAA+B;;iBAA+B,CAAA;AAC3E,MAAM,MAAM,+BAA+B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,+BAA+B,CAAC,CAAA;AAE7F;;;;;;GAMG;AACH,eAAO,MAAM,+BAA+B;;iBAA+B,CAAA;AAC3E,MAAM,MAAM,+BAA+B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,+BAA+B,CAAC,CAAA;AAE7F;;;;;;GAMG;AACH,eAAO,MAAM,6BAA6B;;iBAA+B,CAAA;AACzE,MAAM,MAAM,6BAA6B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,6BAA6B,CAAC,CAAA;AAEzF;;;;;;GAMG;AACH,eAAO,MAAM,mCAAmC;;iBAA+B,CAAA;AAC/E,MAAM,MAAM,mCAAmC,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mCAAmC,CAAC,CAAA;AAErG;;;;;;GAMG;AACH,eAAO,MAAM,6BAA6B;;iBAA+B,CAAA;AACzE,MAAM,MAAM,6BAA6B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,6BAA6B,CAAC,CAAA"}