@snaptrude/plugin-core 0.3.0 → 0.5.0

package/src/api/core/groups.ts

@@ -0,0 +1,521 @@
+import * as z from "zod"
+import { PluginApiReturn } from "../../types"
+import { ComponentHandle, Vec3Components } from "../../handles"
+
+/**
+ * Groups — read and edit the group hierarchy of the active project.
+ *
+ * A **group** is a named, lockable container that bundles components (and other
+ * groups) so they can be selected and transformed as one. This is the
+ * plugin-facing view of that hierarchy: a group's identity, name, member count,
+ * lock state, and parent — never the underlying meshes.
+ *
+ * Reads return plain records and never throw for a missing group (`get` returns
+ * `null`, `list` returns `[]`, `isLocked` returns `false`). Ids are stable public
+ * strings, never engine mesh handles.
+ *
+ * Members are moved and copied through the design operations by group id — use
+ * {@linkcode PluginDesignApi.transform}`.move` and `design.create.copy`, not a method here.
+ * Locking likewise routes through `design.lock`.
+ *
+ * Sub-namespace members typed as optional (`?`) are **authored ahead of the
+ * host** — declared so plugins and codegen can see the shape, but kept out of the
+ * discovery manifest until the host lands them (at which point they are promoted
+ * to required `abstract` members).
+ *
+ * Accessed via `snaptrude.core.groups`.
+ */
+export abstract class PluginCoreGroupsApi {
+  constructor() {}
+
+  /**
+   * List every group in the active project.
+   *
+   * Returns each group's identity, member count, lock state, and parent group
+   * (when nested), for the whole project.
+   *
+   * @returns A {@linkcode PluginCoreGroupsListResult} with a `groups` array
+   *   (empty when the project has none).
+   *
+   * @examplePrompt List all the groups in my project
+   * @examplePrompt What groups do I have and how many things are in each?
+   * @examplePrompt Show every group with its lock state
+   * @examplePrompt How many groups are in this model?
+   *
+   * # Example
+   * ```ts
+   * const { groups } = await snaptrude.core.groups.list()
+   * for (const g of groups) console.log(g.name, g.memberCount, g.isLocked)
+   * ```
+   */
+  public abstract list(): PluginApiReturn<PluginCoreGroupsListResult>
+
+  /**
+   * Get a single group by id.
+   *
+   * @param groupId - The id of the group to read.
+   * @returns The matching {@linkcode PluginCoreGroupRef}, or `null` if no group
+   *   has that id.
+   *
+   * @examplePrompt Get the group with id group-12
+   * @examplePrompt Look up a single group by its id
+   * @examplePrompt Is group-3 locked and how many members does it have?
+   *
+   * # Example
+   * ```ts
+   * const group = await snaptrude.core.groups.get("group-12")
+   * if (group) console.log(group.name, group.memberCount)
+   * ```
+   */
+  public abstract get(
+    groupId: string,
+  ): PluginApiReturn<PluginCoreGroupsGetResult>
+
+  /**
+   * Get the group a component belongs to.
+   *
+   * Returns the **innermost** group directly containing the component, or `null`
+   * if the component is ungrouped or does not exist.
+   *
+   * @param componentId - The `Component.id` of the component to look up.
+   * @returns The innermost {@linkcode PluginCoreGroupRef} containing the
+   *   component, or `null`.
+   *
+   * @examplePrompt Which group is this wall in?
+   * @examplePrompt Find the group that contains component cmp_42
+   * @examplePrompt Is this element grouped, and if so which group?
+   *
+   * # Example
+   * ```ts
+   * const group = await snaptrude.core.groups.getForComponent("cmp_42")
+   * console.log(group ? group.name : "ungrouped")
+   * ```
+   */
+  public abstract getForComponent(
+    componentId: ComponentHandle,
+  ): PluginApiReturn<PluginCoreGroupsGetForComponentResult>
+
+  /**
+   * List the direct members of a group.
+   *
+   * Returns each direct child as an id + kind (`component` or a nested `group`).
+   * Nested groups are returned as members, not flattened.
+   *
+   * @param groupId - The id of the group whose members to read.
+   * @returns A {@linkcode PluginCoreGroupsListMembersResult} with a `members`
+   *   array (empty when the group is empty or missing).
+   *
+   * @examplePrompt What's inside group-12?
+   * @examplePrompt List the members of this group
+   * @examplePrompt Show the components and subgroups in group-3
+   *
+   * # Example
+   * ```ts
+   * const { members } = await snaptrude.core.groups.listMembers("group-12")
+   * for (const m of members) console.log(m.type, m.id)
+   * ```
+   */
+  public abstract listMembers(
+    groupId: string,
+  ): PluginApiReturn<PluginCoreGroupsListMembersResult>
+
+  /**
+   * Report whether a group is locked.
+   *
+   * A predicate: it never mutates and never throws — an unknown group id returns
+   * `false`.
+   *
+   * @param groupId - The id of the group to test.
+   * @returns `true` if the group exists and is locked, otherwise `false`.
+   *
+   * @examplePrompt Is group-12 locked?
+   * @examplePrompt Check whether this group is locked before editing it
+   * @examplePrompt Tell me if the group is locked
+   *
+   * # Example
+   * ```ts
+   * if (await snaptrude.core.groups.isLocked("group-12")) {
+   *   console.log("locked — unlock it first")
+   * }
+   * ```
+   */
+  public abstract isLocked(
+    groupId: string,
+  ): PluginApiReturn<PluginCoreGroupsIsLockedResult>
+
+  /**
+   * Get the axis-aligned bounds of a group.
+   *
+   * Returns the world-space bounding box of everything in the group — its `min`
+   * and `max` corners and the `center` — in internal units, or `null` when the
+   * group is empty (has no meshes) or does not exist. `null` is distinct from a
+   * real group at the origin, whose box is centered on `{0,0,0}`.
+   *
+   * @param groupId - The id of the group to measure.
+   * @returns A {@linkcode PluginCoreGroupsGetBoundsResult} with `min`, `max`, and
+   *   `center` points, or `null` if the group is empty or gone.
+   *
+   * @examplePrompt How big is this group?
+   * @examplePrompt Get the bounding box of group-12
+   * @examplePrompt Where is the center of this group?
+   *
+   * # Example
+   * ```ts
+   * const bounds = await snaptrude.core.groups.getBounds("group-12")
+   * if (bounds) console.log(bounds.center.x, bounds.center.y, bounds.center.z)
+   * ```
+   */
+  public abstract getBounds(
+    groupId: string,
+  ): PluginApiReturn<PluginCoreGroupsGetBoundsResult>
+
+  /**
+   * Group components into a new group.
+   *
+   * Bundles the given components under a new group. Pass a `name` to label it;
+   * otherwise it gets an auto-generated fallback name that you can change later
+   * with {@linkcode PluginCoreGroupsApi.update}.
+   *
+   * @param componentIds - The ids of the components to group (at least one).
+   * @param name - Display name for the new group (auto-generated if omitted).
+   * @returns The new group's id (read the full record back with
+   *   {@linkcode PluginCoreGroupsApi.get}).
+   * @throws If a component id is invalid or the group could not be created.
+   *
+   * @examplePrompt Group the selected components
+   * @examplePrompt Make a group called Kitchen from these elements
+   * @examplePrompt Bundle components cmp_1 and cmp_2 into a group
+   *
+   * # Example
+   * ```ts
+   * const { groupId } = await snaptrude.core.groups.create(["cmp_1", "cmp_2"], "Kitchen")
+   * ```
+   */
+  public abstract create(
+    componentIds: ComponentHandle[],
+    name?: string,
+  ): PluginApiReturn<PluginCoreGroupsCreateResult>
+
+  /**
+   * Update a group's name and/or membership.
+   *
+   * A **sparse** update: omitted fields are left unchanged. `addComponentIds`
+   * and `removeComponentIds` are applied as membership deltas (add before
+   * remove); `name` renames the group.
+   *
+   * @param groupId - The id of the group to update.
+   * @param options - Any of `name`, `addComponentIds`, `removeComponentIds`;
+   *   omitted fields are left unchanged.
+   * @returns The updated {@linkcode PluginCoreGroupRef}.
+   * @throws If no group has the given id, or a component id is invalid.
+   *
+   * @examplePrompt Rename group-12 to Kitchen
+   * @examplePrompt Add these two walls to the group
+   * @examplePrompt Remove cmp_7 from group-3
+   *
+   * # Example
+   * ```ts
+   * const group = await snaptrude.core.groups.update("group-12", {
+   *   name: "Kitchen",
+   *   addComponentIds: ["cmp_9"],
+   * })
+   * ```
+   */
+  public abstract update(
+    groupId: string,
+    options?: {
+      name?: string
+      addComponentIds?: ComponentHandle[]
+      removeComponentIds?: ComponentHandle[]
+    },
+  ): PluginApiReturn<PluginCoreGroupsUpdateResult>
+
+  /**
+   * Delete (dissolve) a group.
+   *
+   * Dissolves the group container. The member elements are **not** deleted —
+   * they are returned to the group's parent (or ungrouped at the top level).
+   *
+   * @param groupId - The id of the group to dissolve.
+   * @returns Confirmation that the group was dissolved.
+   * @throws If no group has the given id.
+   *
+   * @examplePrompt Ungroup group-12
+   * @examplePrompt Dissolve this group but keep its contents
+   * @examplePrompt Delete the group without deleting its members
+   *
+   * # Example
+   * ```ts
+   * await snaptrude.core.groups.delete("group-12")
+   * ```
+   */
+  public abstract delete(
+    groupId: string,
+  ): PluginApiReturn<PluginCoreGroupsDeleteResult>
+}
+
+/**
+ * A group in the active project.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `id` | `string` | Stable public group id (e.g. `"group-12"`) — never a mesh handle |
+ * | `name` | `string` | Display name (auto-generated fallback until the user sets one) |
+ * | `memberCount` | `number` | Number of direct members (components + nested groups) |
+ * | `isLocked` | `boolean` | Whether the group is locked against edits |
+ * | `parentId` | `string \| undefined` | Parent group id when this group is nested, else absent |
+ */
+export const PluginCoreGroupRef = z.object({
+  id: z.string(),
+  name: z.string(),
+  memberCount: z.number().int(),
+  isLocked: z.boolean(),
+  parentId: z.string().optional(),
+})
+export type PluginCoreGroupRef = z.infer<typeof PluginCoreGroupRef>
+
+/**
+ * A direct member of a group.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `id` | `string` | `Component.id` for a component member, or the group id for a nested group |
+ * | `type` | `"component" \| "group"` | Whether this member is a component or a nested group |
+ */
+export const PluginCoreGroupMember = z.object({
+  id: z.string(),
+  type: z.enum(["component", "group"]),
+})
+export type PluginCoreGroupMember = z.infer<typeof PluginCoreGroupMember>
+
+/**
+ * Result of {@linkcode PluginCoreGroupsApi.list}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `groups` | {@linkcode PluginCoreGroupRef}`[]` | Every group in the active project |
+ */
+export const PluginCoreGroupsListResult = z.object({
+  groups: z.array(PluginCoreGroupRef),
+})
+export type PluginCoreGroupsListResult = z.infer<
+  typeof PluginCoreGroupsListResult
+>
+
+/**
+ * Arguments for {@linkcode PluginCoreGroupsApi.get}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `groupId` | `string` | The id of the group to read |
+ */
+export const PluginCoreGroupsGetArgs = z.object({
+  groupId: z.string(),
+})
+export type PluginCoreGroupsGetArgs = z.infer<typeof PluginCoreGroupsGetArgs>
+
+/**
+ * Result of {@linkcode PluginCoreGroupsApi.get} — the group, or `null` when no
+ * group has the given id.
+ */
+export const PluginCoreGroupsGetResult = PluginCoreGroupRef.nullable()
+export type PluginCoreGroupsGetResult = z.infer<
+  typeof PluginCoreGroupsGetResult
+>
+
+/**
+ * Arguments for {@linkcode PluginCoreGroupsApi.getForComponent}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `componentId` | `ComponentHandle` | The `Component.id` to look up |
+ */
+export const PluginCoreGroupsGetForComponentArgs = z.object({
+  componentId: ComponentHandle,
+})
+export type PluginCoreGroupsGetForComponentArgs = z.infer<
+  typeof PluginCoreGroupsGetForComponentArgs
+>
+
+/**
+ * Result of {@linkcode PluginCoreGroupsApi.getForComponent} — the innermost
+ * group containing the component, or `null`.
+ */
+export const PluginCoreGroupsGetForComponentResult =
+  PluginCoreGroupRef.nullable()
+export type PluginCoreGroupsGetForComponentResult = z.infer<
+  typeof PluginCoreGroupsGetForComponentResult
+>
+
+/**
+ * Arguments for {@linkcode PluginCoreGroupsApi.listMembers}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `groupId` | `string` | The id of the group whose members to read |
+ */
+export const PluginCoreGroupsListMembersArgs = z.object({
+  groupId: z.string(),
+})
+export type PluginCoreGroupsListMembersArgs = z.infer<
+  typeof PluginCoreGroupsListMembersArgs
+>
+
+/**
+ * Result of {@linkcode PluginCoreGroupsApi.listMembers}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `members` | {@linkcode PluginCoreGroupMember}`[]` | The group's direct members (empty when the group is empty or missing) |
+ */
+export const PluginCoreGroupsListMembersResult = z.object({
+  members: z.array(PluginCoreGroupMember),
+})
+export type PluginCoreGroupsListMembersResult = z.infer<
+  typeof PluginCoreGroupsListMembersResult
+>
+
+/**
+ * Arguments for {@linkcode PluginCoreGroupsApi.isLocked}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `groupId` | `string` | The id of the group to test |
+ */
+export const PluginCoreGroupsIsLockedArgs = z.object({
+  groupId: z.string(),
+})
+export type PluginCoreGroupsIsLockedArgs = z.infer<
+  typeof PluginCoreGroupsIsLockedArgs
+>
+
+/**
+ * Result of {@linkcode PluginCoreGroupsApi.isLocked} — `true` when the group
+ * exists and is locked, else `false`.
+ */
+export const PluginCoreGroupsIsLockedResult = z.boolean()
+export type PluginCoreGroupsIsLockedResult = z.infer<
+  typeof PluginCoreGroupsIsLockedResult
+>
+
+/**
+ * Arguments for {@linkcode PluginCoreGroupsApi.getBounds}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `groupId` | `string` | The id of the group to measure |
+ */
+export const PluginCoreGroupsGetBoundsArgs = z.object({
+  groupId: z.string(),
+})
+export type PluginCoreGroupsGetBoundsArgs = z.infer<
+  typeof PluginCoreGroupsGetBoundsArgs
+>
+
+/**
+ * Result of {@linkcode PluginCoreGroupsApi.getBounds} — the group's world-space
+ * axis-aligned bounds in internal units, or `null` when the group is empty (has
+ * no meshes) or does not exist.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `min` | {@linkcode Vec3Components} | The minimum corner (`x`, `y`, `z`) |
+ * | `max` | {@linkcode Vec3Components} | The maximum corner (`x`, `y`, `z`) |
+ * | `center` | {@linkcode Vec3Components} | The box center (`x`, `y`, `z`) |
+ */
+export const PluginCoreGroupsGetBoundsResult = z
+  .object({
+    min: Vec3Components,
+    max: Vec3Components,
+    center: Vec3Components,
+  })
+  .nullable()
+export type PluginCoreGroupsGetBoundsResult = z.infer<
+  typeof PluginCoreGroupsGetBoundsResult
+>
+
+/**
+ * Arguments for {@linkcode PluginCoreGroupsApi.create}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `componentIds` | `ComponentHandle[]` | The ids of the components to group (at least one) |
+ * | `name` | `string \| undefined` | Display name for the new group (auto-generated if omitted) |
+ */
+export const PluginCoreGroupsCreateArgs = z.object({
+  componentIds: z.array(ComponentHandle).min(1),
+  name: z.string().optional(),
+})
+export type PluginCoreGroupsCreateArgs = z.infer<
+  typeof PluginCoreGroupsCreateArgs
+>
+
+/**
+ * Result of {@linkcode PluginCoreGroupsApi.create} — the id of the new group.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `groupId` | `string` | The id of the newly created group |
+ */
+export const PluginCoreGroupsCreateResult = z.object({
+  groupId: z.string(),
+})
+export type PluginCoreGroupsCreateResult = z.infer<
+  typeof PluginCoreGroupsCreateResult
+>
+
+/**
+ * Arguments for {@linkcode PluginCoreGroupsApi.update}. Sparse — only the
+ * provided fields are changed.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `groupId` | `string` | The id of the group to update |
+ * | `name` | `string \| undefined` | New display name (unchanged if omitted) |
+ * | `addComponentIds` | `ComponentHandle[] \| undefined` | Components to add to the group |
+ * | `removeComponentIds` | `ComponentHandle[] \| undefined` | Components to remove from the group |
+ */
+export const PluginCoreGroupsUpdateArgs = z.object({
+  groupId: z.string(),
+  name: z.string().optional(),
+  addComponentIds: z.array(ComponentHandle).optional(),
+  removeComponentIds: z.array(ComponentHandle).optional(),
+})
+export type PluginCoreGroupsUpdateArgs = z.infer<
+  typeof PluginCoreGroupsUpdateArgs
+>
+
+/** Result of {@linkcode PluginCoreGroupsApi.update} — the updated group record. */
+export const PluginCoreGroupsUpdateResult = PluginCoreGroupRef
+export type PluginCoreGroupsUpdateResult = z.infer<
+  typeof PluginCoreGroupsUpdateResult
+>
+
+/**
+ * Arguments for {@linkcode PluginCoreGroupsApi.delete}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `groupId` | `string` | The id of the group to dissolve |
+ */
+export const PluginCoreGroupsDeleteArgs = z.object({
+  groupId: z.string(),
+})
+export type PluginCoreGroupsDeleteArgs = z.infer<
+  typeof PluginCoreGroupsDeleteArgs
+>
+
+/**
+ * Result of {@linkcode PluginCoreGroupsApi.delete} — confirmation that the group
+ * was dissolved (its members are preserved).
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `deleted` | `true` | Always `true` on success |
+ */
+export const PluginCoreGroupsDeleteResult = z.object({
+  deleted: z.literal(true),
+})
+export type PluginCoreGroupsDeleteResult = z.infer<
+  typeof PluginCoreGroupsDeleteResult
+>

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

@@ -0,0 +1,84 @@
+import * as z from "zod"
+import { PluginApiReturn } from "../../../types"
+
+/**
+ * Undo / redo of committed history entries.
+ *
+ * History steps operate on Snaptrude's command stack: {@linkcode PluginHistoryApi.undo}
+ * steps back over committed entries, {@linkcode PluginHistoryApi.redo} re-applies
+ * undone ones. Both take an optional step count (default 1) and report how many
+ * steps were actually applied — fewer than requested when the stack runs out.
+ *
+ * Accessed via `snaptrude.core.history`.
+ */
+export abstract class PluginHistoryApi {
+  constructor() {}
+
+  /**
+   * Step back over committed history entries.
+   *
+   * @param steps - (Optional) The number of entries to undo (default 1).
+   * @returns A {@linkcode PluginHistoryStepResult} with `stepsApplied` — the
+   *   entries actually undone (≤ `steps`; fewer if the undo stack ran out).
+   *
+   * @examplePrompt Undo my last change
+   * @examplePrompt Undo the last 3 actions
+   * @examplePrompt Revert what I just did to the model
+   * @examplePrompt Step back one change
+   * @examplePrompt Take back that last edit
+   *
+   * # Example
+   * ```ts
+   * await snaptrude.core.history.undo()   // one step
+   * await snaptrude.core.history.undo(3)  // up to three steps
+   * ```
+   */
+  public abstract undo(steps?: number): PluginApiReturn<PluginHistoryStepResult>
+
+  /**
+   * Step forward over previously undone entries. Symmetric with
+   * {@linkcode PluginHistoryApi.undo}.
+   *
+   * @param steps - (Optional) The number of entries to redo (default 1).
+   * @returns A {@linkcode PluginHistoryStepResult} with `stepsApplied` — the
+   *   entries actually redone (≤ `steps`; fewer if the redo stack ran out).
+   *
+   * @examplePrompt Redo the change I just undid
+   * @examplePrompt Redo the last two undone actions
+   * @examplePrompt Bring back the edit I reverted
+   * @examplePrompt Step forward again in the history
+   *
+   * # Example
+   * ```ts
+   * await snaptrude.core.history.redo()
+   * await snaptrude.core.history.redo(2)
+   * ```
+   */
+  public abstract redo(steps?: number): PluginApiReturn<PluginHistoryStepResult>
+}
+
+/**
+ * Arguments for {@linkcode PluginHistoryApi.undo} / {@linkcode PluginHistoryApi.redo}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `steps` | `number?` | Number of history entries to step (positive integer). Defaults to 1. |
+ */
+export const PluginHistoryStepArgs = z.object({
+  steps: z.number().int().positive().optional(),
+})
+
+export type PluginHistoryStepArgs = z.infer<typeof PluginHistoryStepArgs>
+
+/**
+ * Result of {@linkcode PluginHistoryApi.undo} / {@linkcode PluginHistoryApi.redo}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `stepsApplied` | `number` | History entries actually stepped — `≤ steps`, fewer when the stack ran out. |
+ */
+export const PluginHistoryStepResult = z.object({
+  stepsApplied: z.number().int().nonnegative(),
+})
+
+export type PluginHistoryStepResult = z.infer<typeof PluginHistoryStepResult>

package/src/api/core/index.ts

@@ -1,20 +1,65 @@
 import { PluginMathApi } from "./math"
 import { PluginGeomApi } from "./geom"
+import { PluginHistoryApi } from "./history"
+import { PluginUnitsApi } from "./units"
+import { PluginZoomApi } from "./zoom"
+import { PluginProjectApi } from "./project"
+import { PluginCommentApi } from "./comment"
+import { PluginCoreGroupsApi } from "./groups"
+import { PluginCoreBuildingsApi } from "./buildings"
+import { PluginCoreLayersApi } from "./layers"
+import { PluginCoreTagsApi } from "./tags"
 
 /**
- * Core primitives used across the plugin API.
+ * Core primitives and infrastructure used across the plugin API.
  *
  * - {@linkcode PluginCoreApi.math} — Vector and quaternion operations
  * - {@linkcode PluginCoreApi.geom} — Geometry primitives (lines, arcs, curves, profiles)
+ * - {@linkcode PluginCoreApi.history} — Undo / redo of committed history entries
+ * - {@linkcode PluginCoreApi.units} — Unit-type queries and conversion
+ * - {@linkcode PluginCoreApi.zoom} — Camera zoom controls (extents / selection)
+ * - {@linkcode PluginCoreApi.project} — Project-level settings and info
+ * - {@linkcode PluginCoreApi.comment} — Comments: create, edit, resolve, tag, list
+ * - {@linkcode PluginCoreApi.groups} — Read & edit the group hierarchy
+ * - {@linkcode PluginCoreApi.buildings} — Read & edit buildings and their storeys
+ * - {@linkcode PluginCoreApi.layers} — Read & toggle storey drawing/reference layers
+ * - {@linkcode PluginCoreApi.tags} — Tag catalog + assignment
  */
 export abstract class PluginCoreApi {
   /** Vector and quaternion math utilities. See {@linkcode PluginMathApi}. */
   public abstract math: PluginMathApi
   /** Geometry primitives and constructors. See {@linkcode PluginGeomApi}. */
   public abstract geom: PluginGeomApi
+  /** Undo / redo of committed history entries. See {@linkcode PluginHistoryApi}. */
+  public abstract history: PluginHistoryApi
+  /** Unit-type queries and conversion. See {@linkcode PluginUnitsApi}. */
+  public abstract units: PluginUnitsApi
+  /** Camera zoom controls. See {@linkcode PluginZoomApi}. */
+  public abstract zoom: PluginZoomApi
+  /** Project-level settings and info. See {@linkcode PluginProjectApi}. */
+  public abstract project: PluginProjectApi
+  /** Comments — create, edit, resolve, tag, list. See {@linkcode PluginCommentApi}. */
+  public abstract comment: PluginCommentApi
+  /** Groups — read & edit the group hierarchy. See {@linkcode PluginCoreGroupsApi}. */
+  public abstract groups: PluginCoreGroupsApi
+  /** Buildings — read & edit buildings and their storeys. See {@linkcode PluginCoreBuildingsApi}. */
+  public abstract buildings: PluginCoreBuildingsApi
+  /** Layers — read & toggle storey drawing/reference layers. See {@linkcode PluginCoreLayersApi}. */
+  public abstract layers: PluginCoreLayersApi
+  /** Tags — tag catalog + assignment. See {@linkcode PluginCoreTagsApi}. */
+  public abstract tags: PluginCoreTagsApi
 
   constructor() {}
 }
 
 export * from "./math"
 export * from "./geom"
+export * from "./history"
+export * from "./units"
+export * from "./zoom"
+export * from "./project"
+export * from "./comment"
+export * from "./groups"
+export * from "./buildings"
+export * from "./layers"
+export * from "./tags"