@snaptrude/plugin-core 0.3.0 → 0.6.0

package/src/api/core/comment/index.ts

@@ -0,0 +1,258 @@
+import * as z from "zod"
+import { PluginApiReturn } from "../../../types"
+import { Vec3Handle, ComponentHandle } from "../../../handles"
+
+/**
+ * Comments — create, edit, resolve, tag, and list scene/project comments.
+ *
+ * A comment is an opaque {@link CommentHandle} (its server id). Comments may be
+ * anchored to a component at a 3D point, carry @mentions (by email) and emojis,
+ * and be resolved / reopened. Accessed via `snaptrude.core.comment`.
+ */
+export abstract class PluginCommentApi {
+  constructor() {}
+
+  /**
+   * Create a comment in the project — optionally pinned to a component at a 3D
+   * point — with optional @mentions that notify teammates by email.
+   *
+   * @param message - Comment text (emojis = plain unicode).
+   * @param component - Optional component to anchor the comment to.
+   * @param position - Optional pin point; defaults to the component's center.
+   * @param mentions - Optional user emails to @mention (appended as real @mention tags).
+   * @returns the new {@link CommentHandle}.
+   *
+   * @examplePrompt Add a comment on this wall saying the height looks wrong
+   * @examplePrompt Leave a note on the selected room for the design team
+   * @examplePrompt Comment "verify the door swing" and tag alex@acme.com
+   * @examplePrompt Pin a review note at this point on the slab
+   *
+   * # Example
+   * ```ts
+   * const c = await snaptrude.core.comment.create(
+   *   "Check this wall 🎉",
+   *   spaceId,
+   *   undefined,
+   *   ["alex@acme.com"],
+   * )
+   * ```
+   */
+  public abstract create(
+    message: string,
+    component?: ComponentHandle,
+    position?: Vec3Handle,
+    mentions?: string[],
+  ): PluginApiReturn<CommentHandle>
+
+  /**
+   * Edit a comment's message (and optional @mentions).
+   *
+   * @param comment - The comment to edit.
+   * @param message - New message text.
+   * @param mentions - Optional user emails to @mention.
+   *
+   * @examplePrompt Edit my comment to say the beam depth is 600mm
+   * @examplePrompt Change the text of this comment
+   * @examplePrompt Update the note on the wall and mention priya@studio.com
+   * @examplePrompt Reword the comment I just added
+   *
+   * # Example
+   * ```ts
+   * const c = await snaptrude.core.comment.create("Beam depth TBD")
+   * await snaptrude.core.comment.update(c, "Beam depth is 600mm", ["priya@studio.com"])
+   * ```
+   */
+  public abstract update(
+    comment: CommentHandle,
+    message: string,
+    mentions?: string[],
+  ): PluginApiReturn<boolean>
+
+  /**
+   * Mark a comment resolved. Paired with {@link PluginCommentApi.reopen}.
+   *
+   * @param comment - The target comment.
+   *
+   * @examplePrompt Mark this comment as resolved
+   * @examplePrompt Resolve the comment about the staircase
+   * @examplePrompt Close out this review note
+   * @examplePrompt Set that comment to done
+   *
+   * # Example
+   * ```ts
+   * const c = await snaptrude.core.comment.create("Verify the door swing")
+   * await snaptrude.core.comment.resolve(c)
+   * ```
+   */
+  public abstract resolve(comment: CommentHandle): PluginApiReturn<boolean>
+
+  /**
+   * Reopen a resolved comment. Paired with {@link PluginCommentApi.resolve}.
+   *
+   * @param comment - The target comment.
+   *
+   * @examplePrompt Reopen this resolved comment
+   * @examplePrompt Mark the comment as unresolved again
+   * @examplePrompt Bring back the closed note about the window heights
+   * @examplePrompt Un-resolve that comment so we can keep discussing it
+   *
+   * # Example
+   * ```ts
+   * const [comment] = await snaptrude.core.comment.list()
+   * await snaptrude.core.comment.reopen(comment)
+   * ```
+   */
+  public abstract reopen(comment: CommentHandle): PluginApiReturn<boolean>
+
+  /**
+   * Check whether a comment has been marked resolved.
+   *
+   * @param comment - The target comment.
+   *
+   * @examplePrompt Is this comment resolved yet?
+   * @examplePrompt Check if the note about the roof has been closed
+   * @examplePrompt Has my comment been resolved?
+   * @examplePrompt Tell me whether that comment is still open
+   *
+   * # Example
+   * ```ts
+   * const [comment] = await snaptrude.core.comment.list()
+   * const resolved = await snaptrude.core.comment.isResolved(comment)
+   * console.log(resolved ? "resolved" : "still open")
+   * ```
+   */
+  public abstract isResolved(comment: CommentHandle): PluginApiReturn<boolean>
+
+  /**
+   * Tag (mention) a user on an existing comment, by email.
+   *
+   * @param comment - The comment to add a mention to.
+   * @param email - The user's email to @mention.
+   *
+   * @examplePrompt Tag alex@acme.com on this comment
+   * @examplePrompt Mention the structural engineer in that note
+   * @examplePrompt Add priya@studio.com to the comment about the lobby
+   * @examplePrompt Notify a teammate about an existing comment
+   *
+   * # Example
+   * ```ts
+   * const [comment] = await snaptrude.core.comment.list()
+   * await snaptrude.core.comment.tag(comment, "alex@acme.com")
+   * ```
+   */
+  public abstract tag(comment: CommentHandle, email: string): PluginApiReturn<boolean>
+
+  /**
+   * Permanently remove a comment from the project.
+   *
+   * @param comment - The target comment.
+   *
+   * @examplePrompt Delete this comment
+   * @examplePrompt Remove the note about the old layout
+   * @examplePrompt Get rid of my last comment
+   * @examplePrompt Clear that resolved comment off the wall
+   *
+   * # Example
+   * ```ts
+   * const [comment] = await snaptrude.core.comment.list()
+   * await snaptrude.core.comment.delete(comment)
+   * ```
+   */
+  public abstract delete(comment: CommentHandle): PluginApiReturn<boolean>
+
+  /**
+   * List every comment in the project (deleted ones are excluded), returned as
+   * comment handles you can pass to the other comment methods.
+   *
+   * @examplePrompt List all the comments in this project
+   * @examplePrompt How many comments are on this model?
+   * @examplePrompt Show every note in the file
+   * @examplePrompt Get all comments so I can check which are resolved
+   *
+   * # Example
+   * ```ts
+   * const comments = await snaptrude.core.comment.list()
+   * console.log(`${comments.length} comments in the project`)
+   * ```
+   */
+  public abstract list(): PluginApiReturn<CommentHandle[]>
+}
+
+/**
+ * Opaque handle to a comment — its server-assigned id (entity-style: a raw,
+ * persistable string resolved live, not a registry-minted value handle).
+ */
+export type CommentHandle = string & { readonly __handle: "comment" }
+export const CommentHandle = z
+  .string()
+  .min(1)
+  .transform((s) => s as CommentHandle)
+
+/** `ComponentHandle` is defined in `handles.ts` (imported above) and exported from the
+ *  package root via `export * from "./handles"`. Not re-exported here to avoid an
+ *  ambiguous double `export *` at the barrel. */
+
+/**
+ * Arguments for {@link PluginCommentApi.create}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `component` | {@link ComponentHandle}? | Component to anchor the comment to |
+ * | `position` | {@link Vec3Handle}? | Pin point; defaults to the component's center |
+ * | `message` | `string` | Comment text (emojis = unicode) |
+ * | `mentions` | `string[]`? | User emails to @mention |
+ */
+export const PluginCommentCreateArgs = z.object({
+  component: ComponentHandle.optional(),
+  position: Vec3Handle.optional(),
+  message: z.string(),
+  mentions: z.array(z.string()).optional(),
+})
+
+export type PluginCommentCreateArgs = z.infer<typeof PluginCommentCreateArgs>
+
+/**
+ * Arguments for {@link PluginCommentApi.update}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `comment` | {@link CommentHandle} | The comment to edit |
+ * | `message` | `string` | New message text |
+ * | `mentions` | `string[]`? | User emails to @mention |
+ */
+export const PluginCommentUpdateArgs = z.object({
+  comment: CommentHandle,
+  message: z.string(),
+  mentions: z.array(z.string()).optional(),
+})
+
+export type PluginCommentUpdateArgs = z.infer<typeof PluginCommentUpdateArgs>
+
+/**
+ * Arguments for {@link PluginCommentApi.resolve} / {@link PluginCommentApi.reopen}
+ * / {@link PluginCommentApi.isResolved} / {@link PluginCommentApi.delete}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `comment` | {@link CommentHandle} | The target comment |
+ */
+export const PluginCommentRefArgs = z.object({
+  comment: CommentHandle,
+})
+
+export type PluginCommentRefArgs = z.infer<typeof PluginCommentRefArgs>
+
+/**
+ * Arguments for {@link PluginCommentApi.tag}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `comment` | {@link CommentHandle} | The comment to add a mention to |
+ * | `email` | `string` | The user's email to @mention |
+ */
+export const PluginCommentTagArgs = z.object({
+  comment: CommentHandle,
+  email: z.string(),
+})
+
+export type PluginCommentTagArgs = z.infer<typeof PluginCommentTagArgs>

package/src/api/core/geom/create/index.ts

@@ -0,0 +1,293 @@
+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 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)
+   * ```
+   */
+  public 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)
+   * ```
+   */
+  public 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)
+   * ```
+   */
+  public 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)
+   * ```
+   */
+  public 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])
+   * ```
+   */
+  public 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)
+   * ```
+   */
+  public 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)
+   * ```
+   */
+  public 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])
+   * ```
+   */
+  public 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 const PluginGeomCreateLineArgs = z.object({
+  startPoint: Vec3Handle,
+  endPoint: Vec3Handle,
+})
+
+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 const PluginGeomCreateArcArgs = z.object({
+  startPoint: Vec3Handle,
+  endPoint: Vec3Handle,
+  centrePoint: Vec3Handle,
+  axis: Vec3Handle,
+})
+
+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 const PluginGeomCreateCircleArgs = z.object({
+  centrePoint: Vec3Handle,
+  axis: Vec3Handle,
+  radius: z.number(),
+})
+
+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 const PluginGeomCreateProfileFromLinePointsArgs = z.object({
+  points: z.array(Vec3Handle),
+})
+
+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 const PluginGeomCreateProfileFromCurvesArgs = z.object({
+  curves: z.array(CurveHandle),
+})
+
+export type PluginGeomCreateProfileFromCurvesArgs = z.infer<
+  typeof PluginGeomCreateProfileFromCurvesArgs
+>
+
+/**
+ * Arguments for {@linkcode PluginGeomCreateApi.contourFromProfile}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `outer` | {@linkcode ProfileHandle} | The outer boundary loop |
+ */
+export const PluginGeomCreateContourFromProfileArgs = z.object({
+  outer: ProfileHandle,
+})
+
+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 const PluginGeomCreateContourFromProfilesArgs = z.object({
+  outer: ProfileHandle,
+  holes: z.array(ProfileHandle).optional(),
+})
+
+export type PluginGeomCreateContourFromProfilesArgs = z.infer<
+  typeof PluginGeomCreateContourFromProfilesArgs
+>

package/src/api/core/geom/delete/index.ts

@@ -0,0 +1,78 @@
+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 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
+   * ```
+   */
+  public 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
+   * ```
+   */
+  public abstract contour(contour: ContourHandle): PluginApiReturn<void>
+}
+
+/**
+ * Arguments for {@linkcode PluginGeomDeleteApi.profile}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `profile` | {@linkcode ProfileHandle} | The transient profile handle to release |
+ */
+export const PluginGeomDeleteProfileArgs = z.object({
+  profile: ProfileHandle,
+})
+
+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 const PluginGeomDeleteContourArgs = z.object({
+  contour: ContourHandle,
+})
+
+export type PluginGeomDeleteContourArgs = z.infer<typeof PluginGeomDeleteContourArgs>

package/src/api/core/geom/index.ts

@@ -1,34 +1,35 @@
-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 abstract class PluginGeomApi {
-  /** Line segment construction. See {@linkcode PluginLineApi}. */
-  public abstract line: PluginLineApi
-  /** Arc construction. See {@linkcode PluginArcApi}. */
-  public abstract arc: PluginArcApi
-  /** Unified curve wrapper. See {@linkcode PluginCurveApi}. */
-  public abstract curve: PluginCurveApi
-  /** Closed profile (loop of curves). See {@linkcode PluginProfileApi}. */
-  public abstract profile: PluginProfileApi
+  /** Curve and profile construction. See {@linkcode PluginGeomCreateApi}. */
+  public abstract create: PluginGeomCreateApi
+  /** Curve, arc, and profile queries. See {@linkcode PluginGeomQueryApi}. */
+  public abstract query: PluginGeomQueryApi
+  /** Curve and profile editing (derive-new). See {@linkcode PluginGeomUpdateApi}. */
+  public abstract update: PluginGeomUpdateApi
+  /** Resource-handle disposal (profile). See {@linkcode PluginGeomDeleteApi}. */
+  public 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"