@snaptrude/plugin-core 0.2.9 → 0.5.0

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

@@ -0,0 +1,473 @@
+import * as z from "zod"
+import { PluginApiReturn } from "../../../../types"
+import {
+  ProfileHandle,
+  Vec3Handle,
+  CurveHandle,
+  Vec3Components,
+  BBoxComponents,
+} from "../../../../handles"
+
+/**
+ * Profile queries — read-only geometric questions about a profile (an ordered
+ * loop or chain of curves) and the relationships between two profiles
+ * (all-handle model, §11).
+ *
+ * Every method takes an opaque {@linkcode ProfileHandle} (plus point handles
+ * {@linkcode Vec3Handle} where relevant) and returns plain values — points as
+ * {@linkcode Vec3Components}, areas/perimeters/distances as `number`, predicates
+ * as `boolean`, the bounding box as {@linkcode BBoxComponents}. Methods that
+ * enumerate the profile's child curves return fresh {@linkcode CurveHandle}`[]`.
+ * No query mutates its inputs.
+ *
+ * Accessed via `snaptrude.core.geom.query.profile`.
+ */
+export abstract class PluginGeomQueryProfileApi {
+  constructor() {}
+
+  /**
+   * List the tessellated points along a profile.
+   * @param profile The profile to query
+   * @returns The profile points as {@linkcode Vec3Components}`[]`
+   *
+   * @examplePrompt Give me the corner coordinates of this shape
+   * @examplePrompt List the vertex points along this outline
+   *
+   * # Example
+   * ```ts
+   * const rect = await snaptrude.core.geom.create.profileRect(4, 3)
+   * const points = await snaptrude.core.geom.query.profile.listPoints(rect)
+   * for (const p of points) console.log(p.x, p.y, p.z)
+   * ```
+   */
+  public abstract listPoints(profile: ProfileHandle): PluginApiReturn<Vec3Components[]>
+
+  /**
+   * List the curves that make up a profile. Host API call — mints fresh handles.
+   * @param profile The profile to query
+   * @returns The profile's curves as {@linkcode CurveHandle}`[]`
+   *
+   * # Example
+   * ```ts
+   * const rect = await snaptrude.core.geom.create.profileRect(4, 3)
+   * const curves = await snaptrude.core.geom.query.profile.listCurves(rect)
+   * for (const c of curves) console.log(await snaptrude.core.geom.query.curve.getLength(c))
+   * ```
+   */
+  public abstract listCurves(profile: ProfileHandle): PluginApiReturn<CurveHandle[]>
+
+  /**
+   * Get the (approximate) enclosed area of a profile.
+   * @param profile The profile to query
+   * @returns The area as a `number`
+   *
+   * @examplePrompt What is the area enclosed by this outline?
+   * @examplePrompt Measure the area of this shape
+   *
+   * # Example
+   * ```ts
+   * const rect = await snaptrude.core.geom.create.profileRect(4, 3)
+   * const area = await snaptrude.core.geom.query.profile.getArea(rect) // 12
+   * ```
+   */
+  public abstract getArea(profile: ProfileHandle): PluginApiReturn<number>
+
+  /**
+   * Get the perimeter (total curve length) of a profile.
+   * @param profile The profile to query
+   * @returns The perimeter as a `number`
+   *
+   * @examplePrompt How long is the boundary of this shape in total?
+   * @examplePrompt Measure the perimeter of this outline
+   *
+   * # Example
+   * ```ts
+   * const rect = await snaptrude.core.geom.create.profileRect(4, 3)
+   * const perimeter = await snaptrude.core.geom.query.profile.getPerimeter(rect) // 14
+   * ```
+   */
+  public abstract getPerimeter(profile: ProfileHandle): PluginApiReturn<number>
+
+  /**
+   * Get the axis-aligned bounding box of a profile.
+   * @param profile The profile to query
+   * @returns The bounding box as {@linkcode BBoxComponents}
+   *
+   * @examplePrompt How wide and long is this outline overall?
+   *
+   * # Example
+   * ```ts
+   * const rect = await snaptrude.core.geom.create.profileRect(4, 3)
+   * const { min, max } = await snaptrude.core.geom.query.profile.getBoundingBox(rect)
+   * console.log(max.x - min.x, max.z - min.z) // 4 3
+   * ```
+   */
+  public abstract getBoundingBox(profile: ProfileHandle): PluginApiReturn<BBoxComponents>
+
+  /**
+   * Get the unit normal vector of a profile's plane.
+   * @param profile The profile to query
+   * @returns The normal as {@linkcode Vec3Components}, or `null` if the profile has no well-defined normal
+   *
+   * # Example
+   * ```ts
+   * const rect = await snaptrude.core.geom.create.profileRect(4, 3)
+   * const normal = await snaptrude.core.geom.query.profile.getNormal(rect)
+   * if (normal) console.log(normal.x, normal.y, normal.z)
+   * ```
+   */
+  public abstract getNormal(profile: ProfileHandle): PluginApiReturn<Vec3Components | null>
+
+  /**
+   * Get the point on a profile nearest to an arbitrary point.
+   * @param profile The profile to query
+   * @param point The reference point
+   * @returns The nearest point on the profile as {@linkcode Vec3Components}
+   *
+   * @examplePrompt Find the closest point on this outline to a given point
+   *
+   * # Example
+   * ```ts
+   * const rect = await snaptrude.core.geom.create.profileRect(4, 3)
+   * const point = await snaptrude.core.math.vec3.new(5, 0, 0)
+   * const nearest = await snaptrude.core.geom.query.profile.getNearestPoint(rect, point)
+   * console.log(nearest.x, nearest.y, nearest.z) // 2 0 0
+   * ```
+   */
+  public abstract getNearestPoint(
+    profile: ProfileHandle,
+    point: Vec3Handle,
+  ): PluginApiReturn<Vec3Components>
+
+  /**
+   * Test whether a point lies inside a profile.
+   * @param profile The profile to query
+   * @param point The point to test
+   * @returns `true` if the point is inside the profile, otherwise `false`
+   *
+   * @examplePrompt Does this point fall inside the outline?
+   * @examplePrompt Check if the column location lies within this room boundary
+   *
+   * # Example
+   * ```ts
+   * const rect = await snaptrude.core.geom.create.profileRect(4, 3)
+   * const point = await snaptrude.core.math.vec3.new(1, 0, 1)
+   * const inside = await snaptrude.core.geom.query.profile.hasPoint(rect, point) // true
+   * ```
+   */
+  public abstract hasPoint(
+    profile: ProfileHandle,
+    point: Vec3Handle,
+  ): PluginApiReturn<boolean>
+
+  /**
+   * Test whether a point lies on a profile's boundary.
+   * @param profile The profile to query
+   * @param point The point to test
+   * @returns `true` if the point is on the boundary, otherwise `false`
+   *
+   * # Example
+   * ```ts
+   * const rect = await snaptrude.core.geom.create.profileRect(4, 3)
+   * const point = await snaptrude.core.math.vec3.new(2, 0, 0)
+   * const onEdge = await snaptrude.core.geom.query.profile.isOnBoundary(rect, point) // true
+   * ```
+   */
+  public abstract isOnBoundary(
+    profile: ProfileHandle,
+    point: Vec3Handle,
+  ): PluginApiReturn<boolean>
+
+  /**
+   * Test whether a profile forms a closed loop.
+   * @param profile The profile to query
+   * @returns `true` if the profile is closed, otherwise `false`
+   *
+   * @examplePrompt Is my sketch outline closed or still open?
+   * @examplePrompt Check whether this boundary forms a complete loop
+   *
+   * # Example
+   * ```ts
+   * const rect = await snaptrude.core.geom.create.profileRect(4, 3)
+   * const closed = await snaptrude.core.geom.query.profile.isClosed(rect) // true
+   * ```
+   */
+  public abstract isClosed(profile: ProfileHandle): PluginApiReturn<boolean>
+
+  /**
+   * Test whether a profile is planar.
+   * @param profile The profile to query
+   * @returns `true` if the profile is planar, otherwise `false`
+   *
+   * # Example
+   * ```ts
+   * const rect = await snaptrude.core.geom.create.profileRect(4, 3)
+   * const planar = await snaptrude.core.geom.query.profile.isPlanar(rect) // true
+   * ```
+   */
+  public abstract isPlanar(profile: ProfileHandle): PluginApiReturn<boolean>
+
+  /**
+   * Test whether a profile is wound clockwise on the XZ plane.
+   * @param profile The profile to query
+   * @returns `true` if the profile is clockwise, otherwise `false`
+   *
+   * # Example
+   * ```ts
+   * const rect = await snaptrude.core.geom.create.profileRect(4, 3)
+   * const clockwise = await snaptrude.core.geom.query.profile.isClockwise(rect)
+   * ```
+   */
+  public abstract isClockwise(profile: ProfileHandle): PluginApiReturn<boolean>
+
+  /**
+   * Test whether a profile intersects itself.
+   * @param profile The profile to query
+   * @returns `true` if the profile is self-intersecting, otherwise `false`
+   *
+   * # Example
+   * ```ts
+   * const a = await snaptrude.core.math.vec3.new(0, 0, 0)
+   * const b = await snaptrude.core.math.vec3.new(2, 0, 2)
+   * const c = await snaptrude.core.math.vec3.new(2, 0, 0)
+   * const d = await snaptrude.core.math.vec3.new(0, 0, 2)
+   * const bowtie = await snaptrude.core.geom.create.profileFromLinePoints([a, b, c, d])
+   * const crossed = await snaptrude.core.geom.query.profile.isSelfIntersecting(bowtie) // true
+   * ```
+   */
+  public abstract isSelfIntersecting(profile: ProfileHandle): PluginApiReturn<boolean>
+
+  /**
+   * Test whether a profile contains no curves.
+   * @param profile The profile to query
+   * @returns `true` if the profile is empty, otherwise `false`
+   *
+   * # Example
+   * ```ts
+   * const rect = await snaptrude.core.geom.create.profileRect(4, 3)
+   * const empty = await snaptrude.core.geom.query.profile.isEmpty(rect) // false
+   * ```
+   */
+  public abstract isEmpty(profile: ProfileHandle): PluginApiReturn<boolean>
+
+  /**
+   * Test whether two profiles are geometrically equal.
+   * @param profileA First profile
+   * @param profileB Second profile
+   * @returns `true` if the profiles are equal, otherwise `false`
+   *
+   * # Example
+   * ```ts
+   * const a = await snaptrude.core.geom.create.profileRect(4, 3)
+   * const b = await snaptrude.core.geom.create.profileRect(4, 3)
+   * const same = await snaptrude.core.geom.query.profile.isEqual(a, b) // true
+   * ```
+   */
+  public abstract isEqual(
+    profileA: ProfileHandle,
+    profileB: ProfileHandle,
+  ): PluginApiReturn<boolean>
+}
+
+/**
+ * Arguments for {@linkcode PluginGeomQueryProfileApi.listPoints}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `profile` | {@linkcode ProfileHandle} | The profile to query |
+ */
+export const PluginGeomQueryProfileListPointsArgs = z.object({
+  profile: ProfileHandle,
+})
+
+export type PluginGeomQueryProfileListPointsArgs = z.infer<typeof PluginGeomQueryProfileListPointsArgs>
+
+/**
+ * Arguments for {@linkcode PluginGeomQueryProfileApi.listCurves}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `profile` | {@linkcode ProfileHandle} | The profile to query |
+ */
+export const PluginGeomQueryProfileListCurvesArgs = z.object({
+  profile: ProfileHandle,
+})
+
+export type PluginGeomQueryProfileListCurvesArgs = z.infer<typeof PluginGeomQueryProfileListCurvesArgs>
+
+/**
+ * Arguments for {@linkcode PluginGeomQueryProfileApi.getArea}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `profile` | {@linkcode ProfileHandle} | The profile to query |
+ */
+export const PluginGeomQueryProfileGetAreaArgs = z.object({
+  profile: ProfileHandle,
+})
+
+export type PluginGeomQueryProfileGetAreaArgs = z.infer<typeof PluginGeomQueryProfileGetAreaArgs>
+
+/**
+ * Arguments for {@linkcode PluginGeomQueryProfileApi.getPerimeter}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `profile` | {@linkcode ProfileHandle} | The profile to query |
+ */
+export const PluginGeomQueryProfileGetPerimeterArgs = z.object({
+  profile: ProfileHandle,
+})
+
+export type PluginGeomQueryProfileGetPerimeterArgs = z.infer<typeof PluginGeomQueryProfileGetPerimeterArgs>
+
+/**
+ * Arguments for {@linkcode PluginGeomQueryProfileApi.getBoundingBox}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `profile` | {@linkcode ProfileHandle} | The profile to query |
+ */
+export const PluginGeomQueryProfileGetBoundingBoxArgs = z.object({
+  profile: ProfileHandle,
+})
+
+export type PluginGeomQueryProfileGetBoundingBoxArgs = z.infer<typeof PluginGeomQueryProfileGetBoundingBoxArgs>
+
+/**
+ * Arguments for {@linkcode PluginGeomQueryProfileApi.getNormal}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `profile` | {@linkcode ProfileHandle} | The profile to query |
+ */
+export const PluginGeomQueryProfileGetNormalArgs = z.object({
+  profile: ProfileHandle,
+})
+
+export type PluginGeomQueryProfileGetNormalArgs = z.infer<typeof PluginGeomQueryProfileGetNormalArgs>
+
+/**
+ * Arguments for {@linkcode PluginGeomQueryProfileApi.getNearestPoint}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `profile` | {@linkcode ProfileHandle} | The profile to query |
+ * | `point` | {@linkcode Vec3Handle} | The reference point |
+ */
+export const PluginGeomQueryProfileGetNearestPointArgs = z.object({
+  profile: ProfileHandle,
+  point: Vec3Handle,
+})
+
+export type PluginGeomQueryProfileGetNearestPointArgs = z.infer<typeof PluginGeomQueryProfileGetNearestPointArgs>
+
+/**
+ * Arguments for {@linkcode PluginGeomQueryProfileApi.hasPoint}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `profile` | {@linkcode ProfileHandle} | The profile to query |
+ * | `point` | {@linkcode Vec3Handle} | The point to test |
+ */
+export const PluginGeomQueryProfileHasPointArgs = z.object({
+  profile: ProfileHandle,
+  point: Vec3Handle,
+})
+
+export type PluginGeomQueryProfileHasPointArgs = z.infer<typeof PluginGeomQueryProfileHasPointArgs>
+
+/**
+ * Arguments for {@linkcode PluginGeomQueryProfileApi.isOnBoundary}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `profile` | {@linkcode ProfileHandle} | The profile to query |
+ * | `point` | {@linkcode Vec3Handle} | The point to test |
+ */
+export const PluginGeomQueryProfileIsOnBoundaryArgs = z.object({
+  profile: ProfileHandle,
+  point: Vec3Handle,
+})
+
+export type PluginGeomQueryProfileIsOnBoundaryArgs = z.infer<typeof PluginGeomQueryProfileIsOnBoundaryArgs>
+
+/**
+ * Arguments for {@linkcode PluginGeomQueryProfileApi.isClosed}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `profile` | {@linkcode ProfileHandle} | The profile to query |
+ */
+export const PluginGeomQueryProfileIsClosedArgs = z.object({
+  profile: ProfileHandle,
+})
+
+export type PluginGeomQueryProfileIsClosedArgs = z.infer<typeof PluginGeomQueryProfileIsClosedArgs>
+
+/**
+ * Arguments for {@linkcode PluginGeomQueryProfileApi.isPlanar}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `profile` | {@linkcode ProfileHandle} | The profile to query |
+ */
+export const PluginGeomQueryProfileIsPlanarArgs = z.object({
+  profile: ProfileHandle,
+})
+
+export type PluginGeomQueryProfileIsPlanarArgs = z.infer<typeof PluginGeomQueryProfileIsPlanarArgs>
+
+/**
+ * Arguments for {@linkcode PluginGeomQueryProfileApi.isClockwise}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `profile` | {@linkcode ProfileHandle} | The profile to query |
+ */
+export const PluginGeomQueryProfileIsClockwiseArgs = z.object({
+  profile: ProfileHandle,
+})
+
+export type PluginGeomQueryProfileIsClockwiseArgs = z.infer<typeof PluginGeomQueryProfileIsClockwiseArgs>
+
+/**
+ * Arguments for {@linkcode PluginGeomQueryProfileApi.isSelfIntersecting}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `profile` | {@linkcode ProfileHandle} | The profile to query |
+ */
+export const PluginGeomQueryProfileIsSelfIntersectingArgs = z.object({
+  profile: ProfileHandle,
+})
+
+export type PluginGeomQueryProfileIsSelfIntersectingArgs = z.infer<typeof PluginGeomQueryProfileIsSelfIntersectingArgs>
+
+/**
+ * Arguments for {@linkcode PluginGeomQueryProfileApi.isEmpty}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `profile` | {@linkcode ProfileHandle} | The profile to query |
+ */
+export const PluginGeomQueryProfileIsEmptyArgs = z.object({
+  profile: ProfileHandle,
+})
+
+export type PluginGeomQueryProfileIsEmptyArgs = z.infer<typeof PluginGeomQueryProfileIsEmptyArgs>
+
+/**
+ * Arguments for {@linkcode PluginGeomQueryProfileApi.isEqual}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `profileA` | {@linkcode ProfileHandle} | First profile |
+ * | `profileB` | {@linkcode ProfileHandle} | Second profile |
+ */
+export const PluginGeomQueryProfileIsEqualArgs = z.object({
+  profileA: ProfileHandle,
+  profileB: ProfileHandle,
+})
+
+export type PluginGeomQueryProfileIsEqualArgs = z.infer<typeof PluginGeomQueryProfileIsEqualArgs>

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

@@ -0,0 +1,205 @@
+import * as z from "zod"
+import { PluginApiReturn } from "../../../../types"
+import {
+  BrepHandle,
+  VertexHandle,
+  HalfEdgeHandle,
+  EdgeHandle,
+  FaceHandle,
+  Vec3Components,
+} from "../../../../handles"
+
+/**
+ * Vertex queries — read a single BREP vertex's topology and position (all-handle
+ * model, §11). A {@linkcode VertexHandle} is minted by walking from a brep/face/edge
+ * handle; it is session-ephemeral and goes stale on undo/redo/re-topologize.
+ *
+ * Position lives on the parent brep (indexed by the vertex), so
+ * {@linkcode PluginGeomQueryVertexApi.getPosition} takes both handles. No query
+ * mutates its inputs.
+ *
+ * Accessed via `snaptrude.core.geom.query.vertex`.
+ */
+export abstract class PluginGeomQueryVertexApi {
+  constructor() {}
+
+  /**
+   * Get the index of a vertex within its brep.
+   * @param vertex The vertex to query
+   * @returns The index as a `number` (`-1` if unindexed)
+   *
+   * # Example
+   * ```ts
+   * const [wall] = await snaptrude.design.query.listWalls()
+   * const brep = await snaptrude.design.query.geometry.getBrep(wall)
+   * if (brep) {
+   *   const [vertex] = await snaptrude.core.geom.query.brep.listVertices(brep)
+   *   const index = await snaptrude.core.geom.query.vertex.getIndex(vertex)
+   * }
+   * ```
+   */
+  public abstract getIndex(vertex: VertexHandle): PluginApiReturn<number>
+
+  /**
+   * Get a seed half-edge emanating from a vertex.
+   * @param vertex The vertex to query
+   * @returns The half-edge as a {@linkcode HalfEdgeHandle}, or `null` if uninitialized
+   *
+   * # Example
+   * ```ts
+   * const [wall] = await snaptrude.design.query.listWalls()
+   * const brep = await snaptrude.design.query.geometry.getBrep(wall)
+   * if (brep) {
+   *   const [vertex] = await snaptrude.core.geom.query.brep.listVertices(brep)
+   *   const halfEdge = await snaptrude.core.geom.query.vertex.getHalfEdge(vertex)
+   *   if (halfEdge) {
+   *     const edge = await snaptrude.core.geom.query.halfedge.getEdge(halfEdge)
+   *   }
+   * }
+   * ```
+   */
+  public abstract getHalfEdge(vertex: VertexHandle): PluginApiReturn<HalfEdgeHandle | null>
+
+  /**
+   * Get the position of a vertex (needs the parent brep for coordinates).
+   * @param brep The parent brep (source of coordinates)
+   * @param vertex The vertex whose position to read
+   * @returns The position as {@linkcode Vec3Components}
+   *
+   * @examplePrompt What are the coordinates of this corner point?
+   * @examplePrompt Get the exact x, y, z position of the selected vertex
+   *
+   * # Example
+   * ```ts
+   * const [wall] = await snaptrude.design.query.listWalls()
+   * const brep = await snaptrude.design.query.geometry.getBrep(wall)
+   * if (brep) {
+   *   const [vertex] = await snaptrude.core.geom.query.brep.listVertices(brep)
+   *   const pos = await snaptrude.core.geom.query.vertex.getPosition(brep, vertex)
+   *   console.log(pos.x, pos.y, pos.z)
+   * }
+   * ```
+   */
+  public abstract getPosition(
+    brep: BrepHandle,
+    vertex: VertexHandle
+  ): PluginApiReturn<Vec3Components>
+
+  /**
+   * List the half-edges around a vertex.
+   * @param vertex The vertex to query
+   * @returns The half-edges as {@linkcode HalfEdgeHandle}`[]`
+   *
+   * # Example
+   * ```ts
+   * const [wall] = await snaptrude.design.query.listWalls()
+   * const brep = await snaptrude.design.query.geometry.getBrep(wall)
+   * if (brep) {
+   *   const [vertex] = await snaptrude.core.geom.query.brep.listVertices(brep)
+   *   const halfEdges = await snaptrude.core.geom.query.vertex.listHalfEdges(vertex)
+   *   console.log("half-edges at this vertex:", halfEdges.length)
+   * }
+   * ```
+   */
+  public abstract listHalfEdges(vertex: VertexHandle): PluginApiReturn<HalfEdgeHandle[]>
+
+  /**
+   * List the edges around a vertex.
+   * @param vertex The vertex to query
+   * @returns The edges as {@linkcode EdgeHandle}`[]`
+   *
+   * # Example
+   * ```ts
+   * const [wall] = await snaptrude.design.query.listWalls()
+   * const brep = await snaptrude.design.query.geometry.getBrep(wall)
+   * if (brep) {
+   *   const [vertex] = await snaptrude.core.geom.query.brep.listVertices(brep)
+   *   const edges = await snaptrude.core.geom.query.vertex.listEdges(vertex)
+   *   console.log("edges meeting at this corner:", edges.length)
+   * }
+   * ```
+   */
+  public abstract listEdges(vertex: VertexHandle): PluginApiReturn<EdgeHandle[]>
+
+  /**
+   * List the faces around a vertex.
+   * @param vertex The vertex to query
+   * @returns The faces as {@linkcode FaceHandle}`[]`
+   *
+   * # Example
+   * ```ts
+   * const [wall] = await snaptrude.design.query.listWalls()
+   * const brep = await snaptrude.design.query.geometry.getBrep(wall)
+   * if (brep) {
+   *   const [vertex] = await snaptrude.core.geom.query.brep.listVertices(brep)
+   *   const faces = await snaptrude.core.geom.query.vertex.listFaces(vertex)
+   *   console.log("faces sharing this corner:", faces.length)
+   * }
+   * ```
+   */
+  public abstract listFaces(vertex: VertexHandle): PluginApiReturn<FaceHandle[]>
+
+  /**
+   * List the neighbouring vertices of a vertex.
+   * @param vertex The vertex to query
+   * @returns The neighbours as {@linkcode VertexHandle}`[]`
+   *
+   * # Example
+   * ```ts
+   * const [wall] = await snaptrude.design.query.listWalls()
+   * const brep = await snaptrude.design.query.geometry.getBrep(wall)
+   * if (brep) {
+   *   const [vertex] = await snaptrude.core.geom.query.brep.listVertices(brep)
+   *   const neighbors = await snaptrude.core.geom.query.vertex.listNeighbors(vertex)
+   *   for (const n of neighbors) {
+   *     const pos = await snaptrude.core.geom.query.vertex.getPosition(brep, n)
+   *   }
+   * }
+   * ```
+   */
+  public abstract listNeighbors(vertex: VertexHandle): PluginApiReturn<VertexHandle[]>
+}
+
+const vertexArg = z.object({ vertex: VertexHandle })
+
+/** Arguments for {@linkcode PluginGeomQueryVertexApi.getIndex}. `{ vertex: VertexHandle }` */
+export const PluginGeomQueryVertexGetIndexArgs = vertexArg
+export type PluginGeomQueryVertexGetIndexArgs = z.infer<typeof PluginGeomQueryVertexGetIndexArgs>
+
+/** Arguments for {@linkcode PluginGeomQueryVertexApi.getHalfEdge}. `{ vertex: VertexHandle }` */
+export const PluginGeomQueryVertexGetHalfEdgeArgs = vertexArg
+export type PluginGeomQueryVertexGetHalfEdgeArgs = z.infer<typeof PluginGeomQueryVertexGetHalfEdgeArgs>
+
+/**
+ * Arguments for {@linkcode PluginGeomQueryVertexApi.getPosition}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `brep` | {@linkcode BrepHandle} | The parent brep (source of coordinates) |
+ * | `vertex` | {@linkcode VertexHandle} | The vertex whose position to read |
+ */
+export const PluginGeomQueryVertexGetPositionArgs = z.object({
+  brep: BrepHandle,
+  vertex: VertexHandle,
+})
+export type PluginGeomQueryVertexGetPositionArgs = z.infer<typeof PluginGeomQueryVertexGetPositionArgs>
+
+/** Arguments for {@linkcode PluginGeomQueryVertexApi.listHalfEdges}. `{ vertex: VertexHandle }` */
+export const PluginGeomQueryVertexListHalfEdgesArgs = vertexArg
+export type PluginGeomQueryVertexListHalfEdgesArgs = z.infer<
+  typeof PluginGeomQueryVertexListHalfEdgesArgs
+>
+
+/** Arguments for {@linkcode PluginGeomQueryVertexApi.listEdges}. `{ vertex: VertexHandle }` */
+export const PluginGeomQueryVertexListEdgesArgs = vertexArg
+export type PluginGeomQueryVertexListEdgesArgs = z.infer<typeof PluginGeomQueryVertexListEdgesArgs>
+
+/** Arguments for {@linkcode PluginGeomQueryVertexApi.listFaces}. `{ vertex: VertexHandle }` */
+export const PluginGeomQueryVertexListFacesArgs = vertexArg
+export type PluginGeomQueryVertexListFacesArgs = z.infer<typeof PluginGeomQueryVertexListFacesArgs>
+
+/** Arguments for {@linkcode PluginGeomQueryVertexApi.listNeighbors}. `{ vertex: VertexHandle }` */
+export const PluginGeomQueryVertexListNeighborsArgs = vertexArg
+export type PluginGeomQueryVertexListNeighborsArgs = z.infer<
+  typeof PluginGeomQueryVertexListNeighborsArgs
+>