@snaptrude/plugin-core 0.3.0 → 0.6.0

package/src/handles.ts

@@ -0,0 +1,194 @@
+import * as z from "zod"
+
+/**
+ * An opaque, kind-tagged reference to a host-side object that crosses the RPC
+ * boundary by IDENTITY rather than by value. See `PLUGIN_API_EXPOSURE_HLD.md` §9.
+ *
+ * The phantom `__handle` brand makes a `Handle<"profile">` incompatible with a
+ * `Handle<"mass">` at compile time. At runtime a handle is just a string of the
+ * form `"<kind>_<token>"` (e.g. `"profile_k3f9a2x"`), so it is structured-clone
+ * safe and engine-free — plugin-core never imports the engine type it points at.
+ */
+export type Handle<K extends string> = string & { readonly __handle: K }
+
+/**
+ * A scene-entity handle. Backed by the host `Component.id` and resolved live via
+ * the host scene index (StructureCollection) — never stored in the resource
+ * registry. Stable across undo/redo and persistable across sessions (§9.2).
+ */
+export type EntityId<K extends string = string> = Handle<K>
+
+/** Resource handle: a host-resident, session-ephemeral geometry object (§9.2). */
+export type ProfileHandle = Handle<"profile">
+
+/** Resource handle: a host-resident contour (outer profile + hole profiles). */
+export type ContourHandle = Handle<"contour">
+
+/** Entity-handle example: a Mass / space scene object (Component.id). */
+export type MassHandle = EntityId<"mass">
+
+/**
+ * A scene BIM entity (wall, space, slab, floor, …). Backed by `Component.id` and
+ * resolved live via the host scene index (StructureCollection) — never stored in
+ * the resource registry. Stable across undo/redo and persistable (§9.2). This is
+ * the canonical return handle for every `design.create.*` creator. The token is
+ * the raw `Component.id` — NO `"component_"` prefix, so it round-trips with the
+ * ids the host already hands out.
+ */
+export type ComponentHandle = EntityId<"component">
+
+/**
+ * A material handle. Like {@linkcode ComponentHandle}/`CommentHandle` this is an
+ * arena-free **entity-style** handle: the token IS the material's stable engine
+ * name (`Material.name`/`.id`), resolved live via `scene.getMaterialByName`
+ * host-side — no registry arena, no quota, no dispose, stable across undo/redo.
+ * Project-scoped, not a scene entity.
+ */
+export type MaterialHandle = EntityId<"material">
+
+/**
+ * A placed **scene underlay** — an imported reference plane the user traces over:
+ * an image `FloorPlan`, a `PDF` overlay, or a `CAD` sketch. Entity-style: the token
+ * IS the raw `Component.id` (`fp_…` / a pdf id / `cad_…`). Resolved live host-side
+ * via the import-order layer walk (`collectStoreyImportItems`) — NOT via
+ * `ComponentUtility.FindComponentById`, which does not index underlays. No arena, no
+ * quota, stable across undo/redo. Returned by `core.io.import.{image,pdf,cadJson}`
+ * and consumed by every `core.io.underlay.*` method.
+ */
+export type UnderlayHandle = EntityId<"underlay">
+
+/**
+ * The project's **site terrain** — a Mapbox-derived topography mesh. Entity-style
+ * and a project **singleton** (one terrain per project): the token is the terrain
+ * `Component.id` (`terrain-…`), resolved live via `TerrainOperations.getTerrain()`
+ * (absent from the level component collections, so NOT `FindComponentById`).
+ * Returned by `core.io.import.terrain`.
+ */
+export type TerrainHandle = EntityId<"terrain">
+
+/**
+ * A handle to an **asynchronous import job** (today: a DWG → Forge conversion, which
+ * can take minutes). Returned immediately by `core.io.import.dwg`; poll it via
+ * `core.io.job.*` (`getStatus` / `isComplete` / `getResult` / `getError`). The token
+ * is the engine's import request id; job state lives in a host-side registry.
+ */
+export type ImportJobHandle = EntityId<"importJob">
+
+// ── Value-kind handles (all-handle model, §11) ──────────────────────────────
+// Under the all-handle decision every structured type is a handle. The only
+// non-handles crossing the boundary are JS primitives (number/string/boolean)
+// and enums — the irreducible construction/read leaves. Value handles are
+// immutable; math/geom operate on them via host RPC (no in-worker compute).
+export type Vec3Handle = Handle<"vec3">
+export type QuatHandle = Handle<"quat">
+export type LineHandle = Handle<"line">
+export type ArcHandle = Handle<"arc">
+/** A curve is a line or an arc — its handle is one of those kinds. */
+export type CurveHandle = LineHandle | ArcHandle
+/**
+ * A circle value handle. A circle is a CLOSED curve — it deliberately does NOT
+ * join {@linkcode CurveHandle} (it has no stable start/end and would break the
+ * shared curve read contract), so it carries its own kind and its own
+ * `core.geom.query.circle` namespace (mirroring `query.arc`).
+ */
+export type CircleHandle = Handle<"circle">
+
+// ── BREP topology handles (geometry-kernel resource family, §2A.2.1) ─────────
+// Session-ephemeral, identity-deduped RESOURCE handles for the boundary-
+// representation topology graph. Read-only via `core.geom.query.{brep,face,edge,
+// halfedge,vertex}`; they go stale on undo/redo/re-topologize. Obtain a brep via
+// `design.query.geometry.getBrep`; every other topology handle is minted by
+// walking from a brep/face/edge/vertex handle already resolved off that brep.
+export type BrepHandle = Handle<"brep">
+export type FaceHandle = Handle<"face">
+export type EdgeHandle = Handle<"edge">
+/** Half-edge kind token is all-lowercase `"halfedge"` per §6.1 (no camelCase namespaces). */
+export type HalfEdgeHandle = Handle<"halfedge">
+export type VertexHandle = Handle<"vertex">
+
+/**
+ * Bare primitive records — how value-handle reads return their components
+ * (§11.4). Curves have **no** by-value record: a curve crosses the boundary as a
+ * {@linkcode CurveHandle} (line/arc), and its coordinates are read via the
+ * `core.geom.query.curve` API. There is no `CurveData` under the all-handle model.
+ */
+export type Vec3Components = { x: number; y: number; z: number }
+export type QuatComponents = { x: number; y: number; z: number; w: number }
+/** Axis-aligned bounding box, read as two primitive corner records. */
+export type BBoxComponents = { min: Vec3Components; max: Vec3Components }
+
+/**
+ * Build a Zod schema validating a handle of the given `kind` at the trust
+ * boundary. It checks only the `"<kind>_"` prefix shape; existence, kind, and
+ * ownership are enforced host-side by the HandleRegistry (§9.7). Keeping it to
+ * the prefix is engine-free and avoids an existence oracle.
+ */
+export const handleSchema = <K extends string>(kind: K) =>
+  z
+    .string()
+    .regex(new RegExp(`^${kind}_[A-Za-z0-9_-]+$`), `expected a "${kind}" handle`)
+    .transform((s) => s as Handle<K>)
+
+export const ProfileHandle = handleSchema("profile")
+export const ContourHandle = handleSchema("contour")
+export const MassHandle = handleSchema("mass")
+
+/**
+ * Entity handles are raw `Component.id` strings (no `"<kind>_"` prefix) — validated
+ * only as a non-empty string, resolved live via the scene index host-side.
+ */
+export const ComponentHandle = z
+  .string()
+  .min(1)
+  .transform((s) => s as ComponentHandle)
+
+/**
+ * Material handles are the raw `Material.name` string (entity-style, no `"<kind>_"`
+ * prefix) — validated only as non-empty, resolved live via `scene.getMaterialByName`.
+ */
+export const MaterialHandle = z
+  .string()
+  .min(1)
+  .transform((s) => s as MaterialHandle)
+
+/**
+ * {@linkcode UnderlayHandle} / {@linkcode TerrainHandle} / {@linkcode ImportJobHandle}
+ * are entity-style handles — raw host ids, validated only as a non-empty string
+ * (no `"<kind>_"` prefix), resolved live host-side (existence enforced there).
+ */
+export const UnderlayHandle = z
+  .string()
+  .min(1)
+  .transform((s) => s as UnderlayHandle)
+export const TerrainHandle = z
+  .string()
+  .min(1)
+  .transform((s) => s as TerrainHandle)
+export const ImportJobHandle = z
+  .string()
+  .min(1)
+  .transform((s) => s as ImportJobHandle)
+
+// Value-kind handle schemas (all-handle model, §11).
+export const Vec3Handle = handleSchema("vec3")
+export const QuatHandle = handleSchema("quat")
+export const LineHandle = handleSchema("line")
+export const ArcHandle = handleSchema("arc")
+export const CurveHandle = z.union([LineHandle, ArcHandle])
+export const CircleHandle = handleSchema("circle")
+
+// BREP topology handle schemas (§2A.2.1). Prefix-shape validation only; existence,
+// kind, and ownership are enforced host-side by the HandleRegistry topology arena.
+export const BrepHandle = handleSchema("brep")
+export const FaceHandle = handleSchema("face")
+export const EdgeHandle = handleSchema("edge")
+export const HalfEdgeHandle = handleSchema("halfedge")
+export const VertexHandle = handleSchema("vertex")
+export const Vec3Components = z.object({ x: z.number(), y: z.number(), z: z.number() })
+export const QuatComponents = z.object({
+  x: z.number(),
+  y: z.number(),
+  z: z.number(),
+  w: z.number(),
+})
+export const BBoxComponents = z.object({ min: Vec3Components, max: Vec3Components })

package/src/host-utils.ts

@@ -13,8 +13,11 @@ type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (
 
 type Flatten<T> = { [K in keyof T]: T[K] }
 
-type MethodArgs<F extends (...args: any[]) => any> =
-  Parameters<F> extends [infer A] ? A : void
+/**
+ * The full parameter tuple of a method — the positional-args transport forwards
+ * the whole argument list (`[]` for no-arg methods).
+ */
+type MethodArgs<F extends (...args: any[]) => any> = Parameters<F>
 
 type MethodReturn<F extends (...args: any[]) => any> = Awaited<ReturnType<F>>
 
@@ -45,10 +48,11 @@ export type PluginApiMethodMap = Flatten<
 
 export type PluginApiMethod = keyof PluginApiMethodMap
 
-export type PluginApiCallPayload<M extends PluginApiMethod = PluginApiMethod> =
-  PluginApiMethodMap[M]["args"] extends void
-    ? { method: M; args?: void }
-    : { method: M; args: PluginApiMethodMap[M]["args"] }
+export type PluginApiCallPayload<M extends PluginApiMethod = PluginApiMethod> = {
+  method: M
+  /** Positional argument tuple, spread back into the method host-side. */
+  args: PluginApiMethodMap[M]["args"]
+}
 
 export type PluginApiCallResult<M extends PluginApiMethod> =
   PluginApiMethodMap[M]["return"]

package/src/index.ts

@@ -1,3 +1,4 @@
 export * from "./api"
 export * from "./types"
 export * from "./host-utils"
+export * from "./handles"

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

@@ -1,81 +0,0 @@
-import * as z from "zod";
-import { PVec3 } from "../math/vec3";
-/**
- * Arc construction.
- *
- * A {@linkcode PArc} represents a circular arc in 3D space, defined by
- * start/end points, a centre, and a rotation axis. Arcs can be wrapped
- * as a {@linkcode PCurve} and combined into a {@linkcode PProfile}.
- *
- * Accessed via `snaptrude.core.geom.arc`.
- */
-export declare abstract class PluginArcApi {
-    constructor();
-    /**
-     * Create a new arc from start, end, centre, and axis.
-     *
-     * The arc sweeps from {@linkcode startPoint} to {@linkcode endPoint}
-     * along the circle centred at {@linkcode centrePoint}, in the
-     * direction determined by the right-hand rule around {@linkcode axis}.
-     *
-     * @param startPoint - The start point as a {@linkcode PVec3}
-     * @param endPoint - The end point as a {@linkcode PVec3}
-     * @param centrePoint - The centre of the arc's circle as a {@linkcode PVec3}
-     * @param axis - The arc's rotation axis as a {@linkcode PVec3}
-     *   (perpendicular to the arc's plane)
-     * @returns A new {@linkcode PArc}
-     *
-     * # Example
-     * ```ts
-     * const { vec3 } = snaptrude.core.math
-     * const { arc } = snaptrude.core.geom
-     *
-     * // Quarter-circle arc on the XZ plane
-     * const a = arc.new(
-     *   vec3.new(1, 0, 0),  // start
-     *   vec3.new(0, 0, 1),  // end
-     *   vec3.new(0, 0, 0),  // centre
-     *   vec3.new(0, 1, 0),  // Y-up axis
-     * )
-     * ```
-     */
-    new(startPoint: PVec3, endPoint: PVec3, centrePoint: PVec3, axis: PVec3): PArc;
-}
-/**
- * A circular arc defined by start, end, centre, and axis.
- *
- * Discriminated by `curveType: "Arc"` within the {@linkcode PCurve} union.
- *
- * | Property | Type | Description |
- * |---|---|---|
- * | `curveType` | `"Arc"` | Discriminator tag |
- * | `startPoint` | {@linkcode PVec3} | Start point of the arc |
- * | `endPoint` | {@linkcode PVec3} | End point of the arc |
- * | `centrePoint` | {@linkcode PVec3} | Centre of the arc's circle |
- * | `axis` | {@linkcode PVec3} | Rotation axis (normal to the arc's plane) |
- */
-export declare const PArc: z.ZodObject<{
-    curveType: z.ZodLiteral<"Arc">;
-    startPoint: z.ZodObject<{
-        x: z.ZodNumber;
-        y: z.ZodNumber;
-        z: z.ZodNumber;
-    }, z.core.$strip>;
-    endPoint: z.ZodObject<{
-        x: z.ZodNumber;
-        y: z.ZodNumber;
-        z: z.ZodNumber;
-    }, z.core.$strip>;
-    centrePoint: z.ZodObject<{
-        x: z.ZodNumber;
-        y: z.ZodNumber;
-        z: z.ZodNumber;
-    }, z.core.$strip>;
-    axis: z.ZodObject<{
-        x: z.ZodNumber;
-        y: z.ZodNumber;
-        z: z.ZodNumber;
-    }, z.core.$strip>;
-}, z.core.$strip>;
-export type PArc = z.infer<typeof PArc>;
-//# sourceMappingURL=arc.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"arc.d.ts","sourceRoot":"","sources":["../../../../src/api/core/geom/arc.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AACxB,OAAO,EAAE,KAAK,EAAE,MAAM,cAAc,CAAA;AAEpC;;;;;;;;GAQG;AACH,8BAAsB,YAAY;;IAGhC;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2BG;IACH,GAAG,CAAC,UAAU,EAAE,KAAK,EAAE,QAAQ,EAAE,KAAK,EAAE,WAAW,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,GAAG,IAAI;CAG/E;AAED;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,IAAI;;;;;;;;;;;;;;;;;;;;;;iBAMf,CAAA;AAEF,MAAM,MAAM,IAAI,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,IAAI,CAAC,CAAA"}

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

@@ -1,70 +0,0 @@
-import * as z from "zod";
-import { PLine } from "./line";
-import { PArc } from "./arc";
-/**
- * Unified curve wrapper — either a {@linkcode PLine} or a {@linkcode PArc}.
- *
- * Use this to build heterogeneous curve lists (mixing lines and arcs)
- * when constructing a {@linkcode PProfile}.
- *
- * Accessed via `snaptrude.core.geom.curve`.
- */
-export declare abstract class PluginCurveApi {
-    constructor();
-    /**
-     * Wrap a {@linkcode PLine} or {@linkcode PArc} as a {@linkcode PCurve}.
-     *
-     * This is an identity operation — it simply returns the input unchanged.
-     * It exists for type-level clarity when building mixed curve lists.
-     *
-     * @param curve - A {@linkcode PLine} or {@linkcode PArc} to wrap
-     * @returns The same value typed as {@linkcode PCurve}
-     */
-    new(curve: PLine | PArc): PCurve;
-}
-/**
- * A discriminated union of {@linkcode PLine} and {@linkcode PArc}.
- *
- * Discriminated on the `curveType` field:
- * - `"Line"` → {@linkcode PLine}
- * - `"Arc"` → {@linkcode PArc}
- *
- * Use `curve.curveType` to narrow the type in a switch or if-statement.
- */
-export declare const PCurve: z.ZodDiscriminatedUnion<[z.ZodObject<{
-    curveType: z.ZodLiteral<"Line">;
-    startPoint: z.ZodObject<{
-        x: z.ZodNumber;
-        y: z.ZodNumber;
-        z: z.ZodNumber;
-    }, z.core.$strip>;
-    endPoint: z.ZodObject<{
-        x: z.ZodNumber;
-        y: z.ZodNumber;
-        z: z.ZodNumber;
-    }, z.core.$strip>;
-}, z.core.$strip>, z.ZodObject<{
-    curveType: z.ZodLiteral<"Arc">;
-    startPoint: z.ZodObject<{
-        x: z.ZodNumber;
-        y: z.ZodNumber;
-        z: z.ZodNumber;
-    }, z.core.$strip>;
-    endPoint: z.ZodObject<{
-        x: z.ZodNumber;
-        y: z.ZodNumber;
-        z: z.ZodNumber;
-    }, z.core.$strip>;
-    centrePoint: z.ZodObject<{
-        x: z.ZodNumber;
-        y: z.ZodNumber;
-        z: z.ZodNumber;
-    }, z.core.$strip>;
-    axis: z.ZodObject<{
-        x: z.ZodNumber;
-        y: z.ZodNumber;
-        z: z.ZodNumber;
-    }, z.core.$strip>;
-}, z.core.$strip>], "curveType">;
-export type PCurve = z.infer<typeof PCurve>;
-//# sourceMappingURL=curve.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"curve.d.ts","sourceRoot":"","sources":["../../../../src/api/core/geom/curve.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AACxB,OAAO,EAAE,KAAK,EAAE,MAAM,QAAQ,CAAA;AAC9B,OAAO,EAAE,IAAI,EAAE,MAAM,OAAO,CAAA;AAE5B;;;;;;;GAOG;AACH,8BAAsB,cAAc;;IAGlC;;;;;;;;OAQG;IACH,GAAG,CAAC,KAAK,EAAE,KAAK,GAAG,IAAI,GAAG,MAAM;CAGjC;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gCAAmD,CAAA;AAEtE,MAAM,MAAM,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,MAAM,CAAC,CAAA"}

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

@@ -1,56 +0,0 @@
-import * as z from "zod";
-import { PVec3 } from "../math/vec3";
-/**
- * Line segment construction.
- *
- * A {@linkcode PLine} is the simplest curve primitive — a straight
- * segment between two 3D points. Lines can be wrapped as a
- * {@linkcode PCurve} and combined into a {@linkcode PProfile}.
- *
- * Accessed via `snaptrude.core.geom.line`.
- */
-export declare abstract class PluginLineApi {
-    constructor();
-    /**
-     * Create a new line segment between two points.
-     *
-     * @param startPoint - The start point as a {@linkcode PVec3}
-     * @param endPoint - The end point as a {@linkcode PVec3}
-     * @returns A new {@linkcode PLine}
-     *
-     * # Example
-     * ```ts
-     * const { vec3 } = snaptrude.core.math
-     * const { line } = snaptrude.core.geom
-     *
-     * const edge = line.new(vec3.new(0, 0, 0), vec3.new(5, 0, 0))
-     * ```
-     */
-    new(startPoint: PVec3, endPoint: PVec3): PLine;
-}
-/**
- * A line segment defined by a start and end point.
- *
- * Discriminated by `curveType: "Line"` within the {@linkcode PCurve} union.
- *
- * | Property | Type | Description |
- * |---|---|---|
- * | `curveType` | `"Line"` | Discriminator tag |
- * | `startPoint` | {@linkcode PVec3} | Start point of the segment |
- * | `endPoint` | {@linkcode PVec3} | End point of the segment |
- */
-export declare const PLine: z.ZodObject<{
-    curveType: z.ZodLiteral<"Line">;
-    startPoint: z.ZodObject<{
-        x: z.ZodNumber;
-        y: z.ZodNumber;
-        z: z.ZodNumber;
-    }, z.core.$strip>;
-    endPoint: z.ZodObject<{
-        x: z.ZodNumber;
-        y: z.ZodNumber;
-        z: z.ZodNumber;
-    }, z.core.$strip>;
-}, z.core.$strip>;
-export type PLine = z.infer<typeof PLine>;
-//# sourceMappingURL=line.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"line.d.ts","sourceRoot":"","sources":["../../../../src/api/core/geom/line.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AACxB,OAAO,EAAE,KAAK,EAAE,MAAM,cAAc,CAAA;AAEpC;;;;;;;;GAQG;AACH,8BAAsB,aAAa;;IAGjC;;;;;;;;;;;;;;OAcG;IACH,GAAG,CAAC,UAAU,EAAE,KAAK,EAAE,QAAQ,EAAE,KAAK,GAAG,KAAK;CAG/C;AAED;;;;;;;;;;GAUG;AACH,eAAO,MAAM,KAAK;;;;;;;;;;;;iBAIhB,CAAA;AAEF,MAAM,MAAM,KAAK,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,KAAK,CAAC,CAAA"}

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

@@ -1,121 +0,0 @@
-import * as z from "zod";
-import { PluginApiReturn } from "../../../types";
-import { PCurve } from "./curve";
-/**
- * Profile construction — a closed loop of {@linkcode PCurve}s.
- *
- * Profiles are the primary 2D shape primitive used for creating
- * extruded entities like spaces. Build profiles either from an
- * explicit list of curves or from a list of points (auto-connected
- * with line segments).
- *
- * Accessed via `snaptrude.core.geom.profile`.
- */
-export declare abstract class PluginProfileApi {
-    constructor();
-    /**
-     * Create a profile from an ordered list of curves.
-     *
-     * The curves should form a closed loop — the end point of each curve
-     * should coincide with the start point of the next.
-     *
-     * @param curves - An ordered array of {@linkcode PCurve}s forming a closed loop
-     * @returns A new {@linkcode PProfile}
-     */
-    new(curves: PCurve[]): PProfile;
-    /**
-     * Create a profile by connecting a list of points with line segments.
-     *
-     * The points are connected in order, with the last point automatically
-     * connected back to the first to close the loop.
-     *
-     * This is a **host API call** — it returns a `Promise`.
-     *
-     * @param args - An object containing:
-     *   - {@linkcode PluginProfileFromLinePointsArgs.points args.points} — An ordered
-     *     array of {@linkcode PVec3} forming the profile vertices
-     * @returns A {@linkcode PProfile} with line-segment curves connecting the points
-     *
-     * # Example
-     * ```ts
-     * const { vec3 } = snaptrude.core.math
-     *
-     * // Create an L-shaped profile
-     * const profile = await snaptrude.core.geom.profile.fromLinePoints({
-     *   points: [
-     *     vec3.new(0, 0, 0),
-     *     vec3.new(10, 0, 0),
-     *     vec3.new(10, 0, 5),
-     *     vec3.new(5, 0, 5),
-     *     vec3.new(5, 0, 10),
-     *     vec3.new(0, 0, 10),
-     *   ],
-     * })
-     * ```
-     */
-    abstract fromLinePoints(args: PluginProfileFromLinePointsArgs): PluginApiReturn<PProfile>;
-}
-/**
- * Arguments for {@linkcode PluginProfileApi.fromLinePoints}.
- *
- * | Property | Type | Description |
- * |---|---|---|
- * | `points` | {@linkcode PVec3}`[]` | Ordered vertices of the profile |
- */
-export declare const PluginProfileFromLinePointsArgs: z.ZodObject<{
-    points: z.ZodArray<z.ZodObject<{
-        x: z.ZodNumber;
-        y: z.ZodNumber;
-        z: z.ZodNumber;
-    }, z.core.$strip>>;
-}, z.core.$strip>;
-export type PluginProfileFromLinePointsArgs = z.infer<typeof PluginProfileFromLinePointsArgs>;
-/**
- * A closed profile composed of an ordered list of curves.
- *
- * Profiles are used as input to entity creation methods like
- * {@linkcode PluginSpaceApi.createFromProfile}.
- *
- * | Property | Type | Description |
- * |---|---|---|
- * | `curves` | {@linkcode PCurve}`[]` | Ordered curves forming a closed loop |
- */
-export declare const PProfile: z.ZodObject<{
-    curves: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
-        curveType: z.ZodLiteral<"Line">;
-        startPoint: z.ZodObject<{
-            x: z.ZodNumber;
-            y: z.ZodNumber;
-            z: z.ZodNumber;
-        }, z.core.$strip>;
-        endPoint: z.ZodObject<{
-            x: z.ZodNumber;
-            y: z.ZodNumber;
-            z: z.ZodNumber;
-        }, z.core.$strip>;
-    }, z.core.$strip>, z.ZodObject<{
-        curveType: z.ZodLiteral<"Arc">;
-        startPoint: z.ZodObject<{
-            x: z.ZodNumber;
-            y: z.ZodNumber;
-            z: z.ZodNumber;
-        }, z.core.$strip>;
-        endPoint: z.ZodObject<{
-            x: z.ZodNumber;
-            y: z.ZodNumber;
-            z: z.ZodNumber;
-        }, z.core.$strip>;
-        centrePoint: z.ZodObject<{
-            x: z.ZodNumber;
-            y: z.ZodNumber;
-            z: z.ZodNumber;
-        }, z.core.$strip>;
-        axis: z.ZodObject<{
-            x: z.ZodNumber;
-            y: z.ZodNumber;
-            z: z.ZodNumber;
-        }, z.core.$strip>;
-    }, z.core.$strip>], "curveType">>;
-}, z.core.$strip>;
-export type PProfile = z.infer<typeof PProfile>;
-//# sourceMappingURL=profile.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"profile.d.ts","sourceRoot":"","sources":["../../../../src/api/core/geom/profile.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AACxB,OAAO,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAA;AAEhD,OAAO,EAAE,MAAM,EAAE,MAAM,SAAS,CAAA;AAEhC;;;;;;;;;GASG;AACH,8BAAsB,gBAAgB;;IAGpC;;;;;;;;OAQG;IACH,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,QAAQ;IAI/B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6BG;aACa,cAAc,CAC5B,IAAI,EAAE,+BAA+B,GACpC,eAAe,CAAC,QAAQ,CAAC;CAC7B;AAED;;;;;;GAMG;AACH,eAAO,MAAM,+BAA+B;;;;;;iBAE1C,CAAA;AAEF,MAAM,MAAM,+BAA+B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,+BAA+B,CAAC,CAAA;AAE7F;;;;;;;;;GASG;AACH,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAEnB,CAAA;AAEF,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,QAAQ,CAAC,CAAA"}

package/dist/api/tools/copy.d.ts

@@ -1,59 +0,0 @@
-import * as z from "zod";
-import type { ComponentId } from "../../types";
-/**
- * Copy mode for `snaptrude.tools.copy`.
- *
- * | Value | Description |
- * |---|---|
- * | `"instance"` | Create instanced copies where possible |
- * | `"unique"` | Create independent geometry copies |
- */
-export declare const PluginCopyMode: z.ZodEnum<{
-    instance: "instance";
-    unique: "unique";
-}>;
-export type PluginCopyMode = z.infer<typeof PluginCopyMode>;
-/**
- * Arguments for `snaptrude.tools.copy`.
- *
- * Creates one or more copies for each component in `componentIds`. Copy `i` is
- * offset by `displacement * i`, where `i` starts at `1`. Source positions are
- * preserved. In `"instance"` mode, a unique source mesh can be replaced by an
- * instance at the same position so the source and copied objects remain in the
- * same instance family. The created copy stack becomes the active editor
- * selection, matching the native paste workflow.
- *
- * | Property | Type | Description |
- * |---|---|---|
- * | `componentIds` | `string[]` | Component IDs to copy |
- * | `displacement` | {@linkcode PVec3} | Offset applied to each copy in Babylon units |
- * | `count` | `number` | Number of copies per component. Defaults to `1` |
- * | `copyMode` | {@linkcode PluginCopyMode} | `"instance"` or `"unique"`. Defaults to `"instance"` |
- */
-export declare const PluginCopyArgs: z.ZodObject<{
-    componentIds: z.ZodArray<z.ZodString>;
-    displacement: z.ZodObject<{
-        x: z.ZodNumber;
-        y: z.ZodNumber;
-        z: z.ZodNumber;
-    }, z.core.$strip>;
-    count: z.ZodOptional<z.ZodNumber>;
-    copyMode: z.ZodOptional<z.ZodEnum<{
-        instance: "instance";
-        unique: "unique";
-    }>>;
-}, z.core.$strip>;
-export type PluginCopyArgs = z.infer<typeof PluginCopyArgs>;
-/**
- * Result of `snaptrude.tools.copy`.
- *
- * Returned IDs are Snaptrude component IDs for the newly created copies, not
- * Babylon mesh IDs.
- */
-export declare const PluginCopyResult: z.ZodObject<{
-    copiedIds: z.ZodArray<z.ZodString>;
-}, z.core.$strip>;
-export type PluginCopyResult = {
-    copiedIds: ComponentId[];
-};
-//# sourceMappingURL=copy.d.ts.map

package/dist/api/tools/copy.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"copy.d.ts","sourceRoot":"","sources":["../../../src/api/tools/copy.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AACxB,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAA;AAG9C;;;;;;;GAOG;AACH,eAAO,MAAM,cAAc;;;EAAiC,CAAA;AAE5D,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAA;AAE3D;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,cAAc;;;;;;;;;;;;iBAKzB,CAAA;AAEF,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAA;AAE3D;;;;;GAKG;AACH,eAAO,MAAM,gBAAgB;;iBAE3B,CAAA;AAEF,MAAM,MAAM,gBAAgB,GAAG;IAC7B,SAAS,EAAE,WAAW,EAAE,CAAA;CACzB,CAAA"}

package/dist/api/tools/index.d.ts

@@ -1,33 +0,0 @@
-import { PluginMaterialApi } from "./material";
-import { PluginSelectionApi } from "./selection";
-import { PluginTransformApi } from "./transform";
-import type { PluginApiReturn } from "../../types";
-import type { PluginCopyArgs, PluginCopyResult } from "./copy";
-import type { PluginOffsetArgs, PluginOffsetResult } from "./offset";
-/**
- * Snaptrude editor tools for querying and manipulating scene components.
- *
- * - {@linkcode PluginToolsApi.selection} — Query the current user selection
- * - {@linkcode PluginToolsApi.transform} — Move and rotate components
- * - {@linkcode PluginToolsApi.copy} — Copy components
- * - {@linkcode PluginToolsApi.offset} — Offset or split component profiles
- */
-export declare abstract class PluginToolsApi {
-    /** Query the current selection. See {@linkcode PluginSelectionApi}. */
-    abstract selection: PluginSelectionApi;
-    /** Move and rotate components. See {@linkcode PluginTransformApi}. */
-    abstract transform: PluginTransformApi;
-    /** Apply materials to the current user selection in the Snaptrude editor or passed component ids if any. See {@linkcode PluginMaterialApi}. */
-    abstract material: PluginMaterialApi;
-    /** Copy components by ID. See {@linkcode PluginCopyArgs}. */
-    abstract copy(args: PluginCopyArgs): PluginApiReturn<PluginCopyResult>;
-    /** Offset or split a component profile. See {@linkcode PluginOffsetArgs}. */
-    abstract offset(args: PluginOffsetArgs): PluginApiReturn<PluginOffsetResult>;
-    constructor();
-}
-export * from "./copy";
-export * from "./offset";
-export * from "./selection";
-export * from "./transform";
-export * from "./material";
-//# sourceMappingURL=index.d.ts.map