@snaptrude/plugin-core 0.7.0 → 0.8.0

package/package.json

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

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

@@ -0,0 +1,212 @@
+import * as z from "zod"
+import { PluginApiReturn } from "../../../types"
+import { Vec3Handle } from "../../../handles"
+
+/**
+ * Camera controls.
+ *
+ * Position the viewport camera, snap it to a standard orthographic/isometric
+ * view, and toggle between the 2D (plan) and 3D modelling modes — mirrors the
+ * canvas view menu and the 2D/3D toggle. Like {@linkcode PluginZoomApi}, these
+ * are transient VIEW-STATE changes: they are not model edits, so they are not
+ * write-gated and are not undoable. Accessed via `snaptrude.core.camera`.
+ */
+export abstract class PluginCameraApi {
+  constructor() {}
+
+  /**
+   * Point the camera: place its eye at `eye` looking toward `target` (world
+   * coordinates, internal `babylon` units). View-state only — not undoable.
+   *
+   * @param eye - Camera position as a {@linkcode Vec3Handle}
+   * @param target - Point the camera looks at as a {@linkcode Vec3Handle}
+   * @returns `true` once the camera has been positioned.
+   *
+   * @examplePrompt Look at the model from above the north-east corner
+   * @examplePrompt Position the camera at (50, 30, 50) looking at the origin
+   * @examplePrompt Point the camera at the centre of the building from the side
+   * @examplePrompt Set the eye to this point and aim it at that point
+   *
+   * # Example
+   * ```ts
+   * const { vec3 } = snaptrude.core.math
+   * await snaptrude.core.camera.lookFrom(vec3.new(50, 30, 50), vec3.new(0, 0, 0))
+   * ```
+   */
+  public abstract lookFrom(
+    eye: Vec3Handle,
+    target: Vec3Handle,
+  ): PluginApiReturn<boolean>
+
+  /**
+   * Snap the camera to a standard view — the five orthographic elevations
+   * (`top` / `front` / `back` / `left` / `right`) or the 3D `iso` (isometric
+   * perspective) view. Mirrors the canvas view menu. View-state only — not
+   * undoable. The orthographic presets exit 2D mode first if needed.
+   *
+   * @param view - The standard view to snap to ({@linkcode PluginStandardView})
+   * @returns `true` once the view has been applied.
+   *
+   * @examplePrompt Switch to the top view
+   * @examplePrompt Show me the front elevation
+   * @examplePrompt Go to the isometric view
+   * @examplePrompt Look at the model from the left
+   * @examplePrompt Give me a plan view from the top
+   *
+   * # Example
+   * ```ts
+   * await snaptrude.core.camera.setStandardView("top")
+   * ```
+   */
+  public abstract setStandardView(
+    view: PluginStandardView,
+  ): PluginApiReturn<boolean>
+
+  /**
+   * Toggle the modelling mode between `2d` (plan) and `3d`. Mirrors the canvas
+   * 2D/3D toggle: `3d` enters the isometric perspective view, `2d` drops to the
+   * orthographic plan of the active storey. View-state only — not undoable.
+   *
+   * @param mode - `"2d"` or `"3d"` ({@linkcode PluginCameraMode})
+   * @returns `true` once the mode switch has been requested.
+   *
+   * @examplePrompt Switch to 3D view
+   * @examplePrompt Drop into 2D plan mode
+   * @examplePrompt Go back to 3D
+   * @examplePrompt Show the floor plan in 2D
+   *
+   * # Example
+   * ```ts
+   * await snaptrude.core.camera.setMode("3d")
+   * ```
+   */
+  public abstract setMode(mode: PluginCameraMode): PluginApiReturn<boolean>
+
+  /**
+   * Read the camera's current projection: `"perspective"` (the default 3D
+   * view) or `"orthographic"`. In 2D (plan) mode this always reports
+   * `"orthographic"` — a plan is an orthographic projection.
+   *
+   * @returns The current {@linkcode PluginCameraProjection}.
+   *
+   * @examplePrompt Is the camera in perspective or orthographic?
+   * @examplePrompt What projection is the 3D view using?
+   * @examplePrompt Check whether perspective is on
+   *
+   * # Example
+   * ```ts
+   * const projection = await snaptrude.core.camera.getProjection()
+   * console.log(projection) // "perspective" | "orthographic"
+   * ```
+   */
+  public abstract getProjection(): PluginApiReturn<PluginCameraProjection>
+
+  /**
+   * Switch the 3D camera between `"perspective"` and `"orthographic"`
+   * projection — the Perspective/Orthographic control in the Design tab's
+   * View Settings panel. Like {@linkcode PluginCameraApi.setMode}, this is a
+   * transient view-state change: not write-gated, not undoable.
+   *
+   * In 2D (plan) mode the canvas is always an orthographic plan:
+   * `"orthographic"` is accepted as a no-op, while `"perspective"` is
+   * rejected — switch to 3D first via `setMode("3d")`.
+   *
+   * @param projection - `"perspective"` or `"orthographic"` ({@linkcode PluginCameraProjection})
+   * @returns `true` once the projection has been applied.
+   *
+   * @examplePrompt Switch the camera to orthographic
+   * @examplePrompt Turn perspective off
+   * @examplePrompt Give me a perspective view of the model
+   * @examplePrompt Make the 3D view orthographic like an axonometric drawing
+   *
+   * # Example
+   * ```ts
+   * await snaptrude.core.camera.setProjection("orthographic")
+   * const projection = await snaptrude.core.camera.getProjection() // "orthographic"
+   * ```
+   */
+  public abstract setProjection(
+    projection: PluginCameraProjection,
+  ): PluginApiReturn<boolean>
+}
+
+/**
+ * A standard camera view: the five orthographic elevations (`top`/`front`/
+ * `back`/`left`/`right`) or the 3D isometric perspective (`iso`).
+ */
+export const PluginStandardView = z.enum([
+  "top",
+  "front",
+  "back",
+  "left",
+  "right",
+  "iso",
+])
+export type PluginStandardView = z.infer<typeof PluginStandardView>
+
+/**
+ * The modelling mode: `2d` (orthographic plan) or `3d` (isometric perspective).
+ */
+export const PluginCameraMode = z.enum(["2d", "3d"])
+export type PluginCameraMode = z.infer<typeof PluginCameraMode>
+
+/**
+ * The 3D camera projection: `perspective` (the default) or `orthographic` —
+ * the Perspective/Orthographic control in the Design tab's View Settings panel.
+ */
+export const PluginCameraProjection = z.enum(["perspective", "orthographic"])
+export type PluginCameraProjection = z.infer<typeof PluginCameraProjection>
+
+/**
+ * Arguments for {@linkcode PluginCameraApi.lookFrom}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `eye` | {@linkcode Vec3Handle} | Camera position (world, `babylon` units) |
+ * | `target` | {@linkcode Vec3Handle} | Point the camera looks at |
+ */
+export const PluginCameraLookFromArgs = z.object({
+  eye: Vec3Handle,
+  target: Vec3Handle,
+})
+export type PluginCameraLookFromArgs = z.infer<typeof PluginCameraLookFromArgs>
+
+/**
+ * Arguments for {@linkcode PluginCameraApi.setStandardView}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `view` | {@linkcode PluginStandardView} | The standard view to snap to |
+ */
+export const PluginCameraSetStandardViewArgs = z.object({
+  view: PluginStandardView,
+})
+export type PluginCameraSetStandardViewArgs = z.infer<
+  typeof PluginCameraSetStandardViewArgs
+>
+
+/**
+ * Arguments for {@linkcode PluginCameraApi.setMode}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `mode` | {@linkcode PluginCameraMode} | `"2d"` or `"3d"` |
+ */
+export const PluginCameraSetModeArgs = z.object({
+  mode: PluginCameraMode,
+})
+export type PluginCameraSetModeArgs = z.infer<typeof PluginCameraSetModeArgs>
+
+/**
+ * Arguments for {@linkcode PluginCameraApi.setProjection}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `projection` | {@linkcode PluginCameraProjection} | `"perspective"` or `"orthographic"` |
+ */
+export const PluginCameraSetProjectionArgs = z.object({
+  projection: PluginCameraProjection,
+})
+export type PluginCameraSetProjectionArgs = z.infer<
+  typeof PluginCameraSetProjectionArgs
+>

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

@@ -1,6 +1,6 @@
 import * as z from "zod"
 import { PluginApiReturn } from "../../../types"
-import { Vec3Handle, ComponentHandle } from "../../../handles"
+import { Vec3Handle, ComponentHandle, Vec3Components } from "../../../handles"
 
 /**
  * Comments — create, edit, resolve, tag, and list scene/project comments.
@@ -140,7 +140,10 @@ export abstract class PluginCommentApi {
    * await snaptrude.core.comment.tag(comment, "alex@acme.com")
    * ```
    */
-  public abstract tag(comment: CommentHandle, email: string): PluginApiReturn<boolean>
+  public abstract tag(
+    comment: CommentHandle,
+    email: string,
+  ): PluginApiReturn<boolean>
 
   /**
    * Permanently remove a comment from the project.
@@ -176,6 +179,57 @@ export abstract class PluginCommentApi {
    * ```
    */
   public abstract list(): PluginApiReturn<CommentHandle[]>
+
+  /**
+   * Read a comment's full detail — its text, author, pin location, resolved
+   * state, and reply thread. Comments are otherwise write-only; this is the read
+   * side. Pass a top-level comment handle or a reply handle (a reply has an empty
+   * `thread`). Returns `null` if the handle doesn't match a live comment.
+   *
+   * @param comment - The comment (or reply) to read.
+   * @returns the {@link PluginCommentDetails}, or `null` if not found.
+   *
+   * @examplePrompt Read the comment on this wall and tell me what it says
+   * @examplePrompt Who left this comment and where is it pinned?
+   * @examplePrompt Show me the full thread for this comment
+   * @examplePrompt Get the text and author of the selected comment
+   *
+   * # Example
+   * ```ts
+   * const [first] = await snaptrude.core.comment.list()
+   * const details = await snaptrude.core.comment.get(first)
+   * console.log(details?.content, "by", details?.author?.name)
+   * console.log(`${details?.thread.length ?? 0} replies`)
+   * ```
+   */
+  public abstract get(
+    comment: CommentHandle,
+  ): PluginApiReturn<PluginCommentDetails | null>
+
+  /**
+   * Reply to a comment — posts a new comment threaded under `comment` (which must
+   * be a top-level comment, not itself a reply). Notifies the thread's
+   * participants, mirroring the sidebar Reply action.
+   *
+   * @param comment - The top-level comment to reply to.
+   * @param text - The reply text (emojis = plain unicode).
+   * @returns the new reply's {@link CommentHandle}.
+   *
+   * @examplePrompt Reply to this comment saying I fixed the wall height
+   * @examplePrompt Add a reply to the review note confirming it's done
+   * @examplePrompt Respond to the comment about the door with "looks good now"
+   * @examplePrompt Post a follow-up on the selected comment thread
+   *
+   * # Example
+   * ```ts
+   * const [thread] = await snaptrude.core.comment.list()
+   * const reply = await snaptrude.core.comment.reply(thread, "Fixed 👍")
+   * ```
+   */
+  public abstract reply(
+    comment: CommentHandle,
+    text: string,
+  ): PluginApiReturn<CommentHandle>
 }
 
 /**
@@ -256,3 +310,67 @@ export const PluginCommentTagArgs = z.object({
 })
 
 export type PluginCommentTagArgs = z.infer<typeof PluginCommentTagArgs>
+
+/**
+ * Arguments for {@link PluginCommentApi.reply}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `comment` | {@link CommentHandle} | The top-level comment to reply to |
+ * | `text` | `string` | The reply text (emojis = unicode) |
+ */
+export const PluginCommentReplyArgs = z.object({
+  comment: CommentHandle,
+  text: z.string(),
+})
+
+export type PluginCommentReplyArgs = z.infer<typeof PluginCommentReplyArgs>
+
+/**
+ * The author of a comment or reply — the display name and email of the teammate
+ * who posted it. `null` on the rare comment with no recorded author.
+ */
+export interface PluginCommentAuthor {
+  /** The author's display name (falls back to their email). */
+  name: string
+  /** The author's email. */
+  email: string
+}
+
+/**
+ * One reply in a comment's thread (returned by {@link PluginCommentApi.get}).
+ */
+export interface PluginCommentReply {
+  /** The reply's own {@link CommentHandle}. */
+  id: CommentHandle
+  /** The reply text. */
+  content: string
+  /** Who posted the reply. */
+  author: PluginCommentAuthor | null
+  /** ISO-8601 timestamp of when the reply was posted (empty if unknown). */
+  createdAt: string
+}
+
+/**
+ * The read model of a comment — returned by {@link PluginCommentApi.get}. The
+ * inverse of {@link PluginCommentApi.create}: `content`/`component`/`position`
+ * echo what was posted, plus the resolved state and reply `thread`.
+ */
+export interface PluginCommentDetails {
+  /** The comment's {@link CommentHandle}. */
+  id: CommentHandle
+  /** The comment text. */
+  content: string
+  /** Who posted the comment. */
+  author: PluginCommentAuthor | null
+  /** The pin point (engine world coordinates), or `null` if un-anchored. */
+  position: Vec3Components | null
+  /** The component the comment is anchored to, or `null` if un-anchored. */
+  component: ComponentHandle | null
+  /** Whether the comment has been marked resolved. */
+  isResolved: boolean
+  /** ISO-8601 timestamp of when the comment was posted (empty if unknown). */
+  createdAt: string
+  /** The reply thread, oldest first. Empty for a comment with no replies. */
+  thread: PluginCommentReply[]
+}

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

@@ -20,6 +20,9 @@ export abstract class PluginGeomDeleteApi {
    * 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.
    *
+   * @deprecated Use `core.handles.release([profile])` — the universal, batched
+   * release API for every arena handle kind.
+   *
    * @param profile The transient profile handle to release
    * @returns Nothing
    *
@@ -37,6 +40,9 @@ export abstract class PluginGeomDeleteApi {
    * 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.
    *
+   * @deprecated Use `core.handles.release([contour])` — the universal, batched
+   * release API for every arena handle kind.
+   *
    * @param contour The transient contour handle to release
    * @returns Nothing
    *

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

@@ -0,0 +1,233 @@
+import * as z from "zod"
+import { PluginApiReturn } from "../../../types"
+// Type-only: src/handles.ts type-only-imports ArenaKind from this file, so the
+// cycle stays purely type-level and is erased at emit.
+import type { AnyArenaHandle } from "../../../handles"
+import { Handle } from "../../../handles"
+
+/**
+ * The 12 registry-arena handle kinds — the releasable families. Entity-style
+ * handles (component / material / underlay / terrain / importJob / comment) are
+ * raw engine ids with no arena entry and therefore no lifecycle: passing one to
+ * `release` is a silent no-op like any other unknown id.
+ */
+export const ArenaKind = z.enum([
+  "vec3",
+  "quat",
+  "line",
+  "arc",
+  "circle",
+  "profile",
+  "contour",
+  "brep",
+  "face",
+  "edge",
+  "halfedge",
+  "vertex",
+])
+export type ArenaKind = z.infer<typeof ArenaKind>
+
+/** Max handles accepted by a single `release` / `endScope(retain)` call. */
+export const RELEASE_BATCH_MAX = 10_000
+
+/**
+ * An opaque token identifying a handle scope opened by
+ * {@linkcode PluginCoreHandlesApi.beginScope}. It is NOT an arena handle —
+ * it pins no memory, and `release(token)` is a silent no-op; only
+ * {@linkcode PluginCoreHandlesApi.endScope} consumes it.
+ */
+export type ScopeToken = string
+
+/**
+ * Handle lifecycle — free host-side handle registry entries the plugin no
+ * longer needs, individually ({@linkcode release}), by kind
+ * ({@linkcode releaseAll}), or as a mint-recording region
+ * ({@linkcode beginScope} / {@linkcode endScope}).
+ *
+ * Releasing is a handle-lifecycle operation only: it frees the registry entry
+ * (host memory + quota room) and makes the handle unresolvable. It never
+ * deletes engine-side geometry or scene entities.
+ *
+ * Accessed via `snaptrude.core.handles`.
+ */
+export abstract class PluginCoreHandlesApi {
+  constructor() {}
+
+  /**
+   * Free arena handles in bulk. Unknown, foreign, or already-released ids are
+   * silent no-ops — there is no per-id result and no count, so responses can
+   * never be used as an existence oracle.
+   *
+   * @param handles The handles to release (max {@linkcode RELEASE_BATCH_MAX} per call)
+   * @returns Nothing
+   *
+   * # Example
+   * ```ts
+   * const faces = await snaptrude.core.geom.query.brep.listFaces(brep)
+   * // ... read what you need ...
+   * await snaptrude.core.handles.release(faces)
+   * ```
+   */
+  public abstract release(handles: ReadonlyArray<AnyArenaHandle>): PluginApiReturn<void>
+
+  /**
+   * Free every live arena handle of one kind, or ALL arena handles when the
+   * kind is omitted. Useful at batch boundaries — e.g. a poll loop that mints
+   * a fresh footprint contour per tick.
+   *
+   * @param kind Optional arena kind to restrict the sweep to
+   * @returns Nothing
+   *
+   * # Example
+   * ```ts
+   * const footprint = await snaptrude.design.query.spaces.getFootprint(space)
+   * // ... measure ...
+   * await snaptrude.core.handles.releaseAll("contour")
+   * ```
+   */
+  public abstract releaseAll(kind?: ArenaKind): PluginApiReturn<void>
+
+  /**
+   * Open a mint-recording scope: every arena handle MINTED after this call
+   * (fresh mints only — identity-deduped re-registrations of pre-existing
+   * objects are not captured) is freed when the matching
+   * {@linkcode endScope} runs. Scopes nest, up to 64 deep — always pair
+   * begin/end in try/finally.
+   *
+   * @returns The scope token to pass to {@linkcode endScope}
+   *
+   * # Example
+   * ```ts
+   * for (const space of spaces) {
+   *   const scope = await snaptrude.core.handles.beginScope()
+   *   try {
+   *     const footprint = await snaptrude.design.query.spaces.getFootprint(space)
+   *     const area = await snaptrude.core.geom.query.contour.getArea(footprint)
+   *   } finally {
+   *     await snaptrude.core.handles.endScope(scope) // footprint (and intermediates) freed
+   *   }
+   * }
+   * ```
+   */
+  public abstract beginScope(): PluginApiReturn<ScopeToken>
+
+  /**
+   * Close a scope by its token and free every handle it recorded, except those
+   * listed in `retain`. Retained handles are promoted to the enclosing scope
+   * (if any), so nesting composes like block scopes. Closing is
+   * token-addressed: an out-of-order close (interleaved async tasks) frees
+   * only that scope's mints and leaves other open scopes intact. Always pair
+   * begin/end in try/finally so a thrown body cannot leak the scope.
+   *
+   * @param scope The token returned by the matching {@linkcode beginScope}
+   * @param retain Handles minted inside the scope that must survive it
+   * @returns Nothing
+   *
+   * # Example
+   * ```ts
+   * const scope = await snaptrude.core.handles.beginScope()
+   * const outline = await snaptrude.design.query.spaces.getFootprint(space)
+   * const outer = await snaptrude.core.geom.query.contour.getOuterProfile(outline)
+   * await snaptrude.core.handles.endScope(scope, [outer]) // outline freed, outer survives
+   * ```
+   */
+  public abstract endScope(
+    scope: ScopeToken,
+    retain?: ReadonlyArray<AnyArenaHandle>
+  ): PluginApiReturn<void>
+
+  /**
+   * Live handle-registry statistics for the calling plugin, plus the host
+   * page's JS heap usage (when the browser exposes it). Diagnostic surface for
+   * verifying that releases actually shrink host memory.
+   *
+   * @returns Arena entry counts, open scope depth, and host heap bytes
+   *
+   * # Example
+   * ```ts
+   * const before = await snaptrude.core.handles.stats()
+   * await snaptrude.core.handles.releaseAll("vec3")
+   * const after = await snaptrude.core.handles.stats()
+   * console.log(`freed ${before.values - after.values} value entries`)
+   * ```
+   */
+  public abstract stats(): PluginApiReturn<PluginHandlesStatsResult>
+}
+
+/**
+ * Wire-normalize one handle argument: a raw id string passes through; a live
+ * `Handle` instance (direct host callers — console harness, host-internal) or a
+ * structured-clone-stripped `{id}` / tagged `{__h}` shape collapses to its id.
+ * Deliberately shape-lax beyond that (non-empty string) — a malformed id is
+ * just an id that resolves nowhere (anti-oracle).
+ */
+const handleIdWire = z.preprocess((v) => {
+  if (typeof v === "string") return v
+  if (v instanceof Handle) return v.id
+  if (v && typeof v === "object") {
+    const o = v as Record<string, unknown>
+    if (typeof o.__h === "string") return o.__h
+    if (typeof o.id === "string") return o.id
+  }
+  return v
+}, z.string().min(1))
+
+/**
+ * Arguments for {@linkcode PluginCoreHandlesApi.release}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `handles` | `string[]` | Handles to release (≤ {@linkcode RELEASE_BATCH_MAX}) |
+ */
+export const PluginHandlesReleaseArgs = z.object({
+  handles: z.array(handleIdWire).max(RELEASE_BATCH_MAX),
+})
+export type PluginHandlesReleaseArgs = z.infer<typeof PluginHandlesReleaseArgs>
+
+/**
+ * Arguments for {@linkcode PluginCoreHandlesApi.releaseAll}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `kind` | {@linkcode ArenaKind} (optional) | Restrict the sweep to one kind |
+ */
+export const PluginHandlesReleaseAllArgs = z.object({
+  kind: ArenaKind.optional(),
+})
+export type PluginHandlesReleaseAllArgs = z.infer<typeof PluginHandlesReleaseAllArgs>
+
+/**
+ * Arguments for {@linkcode PluginCoreHandlesApi.endScope}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `scope` | {@linkcode ScopeToken} | Token from the matching `beginScope` |
+ * | `retain` | `string[]` (optional) | Scope-minted handles that must survive |
+ */
+export const PluginHandlesEndScopeArgs = z.object({
+  scope: z.string().regex(/^scope_[A-Za-z0-9_-]+$/, 'expected a "scope" token'),
+  retain: z.array(handleIdWire).max(RELEASE_BATCH_MAX).optional(),
+})
+export type PluginHandlesEndScopeArgs = z.infer<typeof PluginHandlesEndScopeArgs>
+
+/**
+ * Result of {@linkcode PluginCoreHandlesApi.stats}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `resources` | `number` | Live resource-arena entries (profile/contour) |
+ * | `values` | `number` | Live value-arena entries (vec3/quat/line/arc/circle) |
+ * | `topology` | `number` | Live topology-arena entries (brep/face/edge/halfedge/vertex) |
+ * | `scopes` | `number` | Currently open handle scopes |
+ * | `hostHeapUsedBytes` | `number \| null` | Host page `usedJSHeapSize` (null where unsupported) |
+ * | `hostHeapTotalBytes` | `number \| null` | Host page `totalJSHeapSize` (null where unsupported) |
+ */
+export const PluginHandlesStatsResult = z.object({
+  resources: z.number().int().nonnegative(),
+  values: z.number().int().nonnegative(),
+  topology: z.number().int().nonnegative(),
+  scopes: z.number().int().nonnegative(),
+  hostHeapUsedBytes: z.number().nullable(),
+  hostHeapTotalBytes: z.number().nullable(),
+})
+export type PluginHandlesStatsResult = z.infer<typeof PluginHandlesStatsResult>

package/src/api/core/index.ts

@@ -10,7 +10,10 @@ import { PluginCoreBuildingsApi } from "./buildings"
 import { PluginCoreLayersApi } from "./layers"
 import { PluginCoreTagsApi } from "./tags"
 import { PluginCoreIoApi } from "./io"
+import { PluginCoreHandlesApi } from "./handles"
 import { PluginCoreProposalsApi } from "./proposals"
+import { PluginCameraApi } from "./camera"
+import { PluginUserApi } from "./user"
 
 /**
  * Core primitives and infrastructure used across the plugin API.
@@ -20,6 +23,8 @@ import { PluginCoreProposalsApi } from "./proposals"
  * - {@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.camera} — Camera controls — position, standard views, 2D/3D mode
+ * - {@linkcode PluginCoreApi.user} — User locale — timezone & language
  * - {@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
@@ -27,6 +32,7 @@ import { PluginCoreProposalsApi } from "./proposals"
  * - {@linkcode PluginCoreApi.layers} — Read & toggle storey drawing/reference layers
  * - {@linkcode PluginCoreApi.tags} — Tag catalog + assignment
  * - {@linkcode PluginCoreApi.io} — Import files (image/pdf/cad/model/terrain), poll jobs, manage underlays
+ * - {@linkcode PluginCoreApi.handles} — Handle lifecycle: release, releaseAll, scopes
  * - {@linkcode PluginCoreApi.proposals} — Design options: read, create, rename, switch, delete
  */
 export abstract class PluginCoreApi {
@@ -40,6 +46,10 @@ export abstract class PluginCoreApi {
   public abstract units: PluginUnitsApi
   /** Camera zoom controls. See {@linkcode PluginZoomApi}. */
   public abstract zoom: PluginZoomApi
+  /** Camera controls — position, standard views, 2D/3D mode. See {@linkcode PluginCameraApi}. */
+  public abstract camera: PluginCameraApi
+  /** User locale — timezone & language. See {@linkcode PluginUserApi}. */
+  public abstract user: PluginUserApi
   /** Project-level settings and info. See {@linkcode PluginProjectApi}. */
   public abstract project: PluginProjectApi
   /** Comments — create, edit, resolve, tag, list. See {@linkcode PluginCommentApi}. */
@@ -54,6 +64,8 @@ export abstract class PluginCoreApi {
   public abstract tags: PluginCoreTagsApi
   /** I/O — file import, import jobs, and underlay management. See {@linkcode PluginCoreIoApi}. */
   public abstract io: PluginCoreIoApi
+  /** Handle lifecycle — release, releaseAll, and mint-recording scopes. See {@linkcode PluginCoreHandlesApi}. */
+  public abstract handles: PluginCoreHandlesApi
   /** Proposals — design options: read, create, rename, switch, delete. See {@linkcode PluginCoreProposalsApi}. */
   public abstract proposals: PluginCoreProposalsApi
 
@@ -65,6 +77,8 @@ export * from "./geom"
 export * from "./history"
 export * from "./units"
 export * from "./zoom"
+export * from "./camera"
+export * from "./user"
 export * from "./project"
 export * from "./comment"
 export * from "./groups"
@@ -72,4 +86,5 @@ export * from "./buildings"
 export * from "./layers"
 export * from "./tags"
 export * from "./io"
+export * from "./handles"
 export * from "./proposals"