@snaptrude/plugin-core 0.3.0 → 0.5.0

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

@@ -1,51 +0,0 @@
-import * as z from "zod";
-import { PluginApiReturn } from "../../types";
-/**
- * Apply materials to the current user selection in the Snaptrude editor or passed component ids if any.
- *
- * Accessed via `snaptrude.tools.material`.
- */
-export declare abstract class PluginMaterialApi {
-    constructor();
-    /**
-     * Apply materials to the current user selection in the Snaptrude editor or passed component ids if any.
-     *
-     * @param args - An object containing:
-     *   - {@linkcode PluginMaterialArgs.materialName args.materialName} — Material to apply
-     *   - {@linkcode PluginMaterialArgs.componentIds args.componentIds} — Array of component
-     *     ID strings to apply materials to if provided, if not provided, the current user selection will be used
-     */
-    abstract apply({ materialName, componentIds, }: PluginMaterialArgs): PluginApiReturn<void>;
-}
-declare enum DEFAULT_MATERIALS {
-    GLASS = "glass",
-    WOOD = "wood",
-    METAL = "metal",
-    STONE = "stone",
-    TILES = "tiles",
-    CONCRETE = "concrete",
-    BRICK = "brick"
-}
-/**
- * Arguments for {@linkcode PluginMaterialApi.apply}.
- *
- * | Property | Type | Description |
- * |---|---|---|
- * | `materialName` | `DEFAULT_MATERIALS` | Material to apply |
- * | `componentIds` | `string[]` | Component IDs to apply materials to if provided |
- */
-export declare const PluginMaterialArgs: z.ZodObject<{
-    materialName: z.ZodEnum<{
-        glass: DEFAULT_MATERIALS.GLASS;
-        wood: DEFAULT_MATERIALS.WOOD;
-        metal: DEFAULT_MATERIALS.METAL;
-        stone: DEFAULT_MATERIALS.STONE;
-        tiles: DEFAULT_MATERIALS.TILES;
-        concrete: DEFAULT_MATERIALS.CONCRETE;
-        brick: DEFAULT_MATERIALS.BRICK;
-    }>;
-    componentIds: z.ZodArray<z.ZodString>;
-}, z.core.$strip>;
-export type PluginMaterialArgs = z.infer<typeof PluginMaterialArgs>;
-export {};
-//# sourceMappingURL=material.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"material.d.ts","sourceRoot":"","sources":["../../../src/api/tools/material.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AACxB,OAAO,EAAE,eAAe,EAAE,MAAM,aAAa,CAAA;AAE7C;;;;GAIG;AACH,8BAAsB,iBAAiB;;IAGrC;;;;;;;OAOG;aACa,KAAK,CAAC,EACpB,YAAY,EACZ,YAAY,GACb,EAAE,kBAAkB,GAAG,eAAe,CAAC,IAAI,CAAC;CAC9C;AAED,aAAK,iBAAiB;IACpB,KAAK,UAAU;IACf,IAAI,SAAS;IACb,KAAK,UAAU;IACf,KAAK,UAAU;IACf,KAAK,UAAU;IACf,QAAQ,aAAa;IACrB,KAAK,UAAU;CAChB;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,kBAAkB;;;;;;;;;;;iBAG7B,CAAA;AAEF,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAA"}

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

@@ -1,43 +0,0 @@
-import * as z from "zod";
-import type { ComponentId } from "../../types";
-/**
- * Arguments for `snaptrude.tools.offset`.
- *
- * Runs Snaptrude's offset/split operation on the top profile of a scene
- * component. A positive distance offsets outward from the selected profile;
- * a negative distance offsets inward. If `profilePickPoint` is omitted, the
- * outer top profile is used. If `profilePickPoint` is provided, the nearest top
- * contour profile to that point is used, matching the interactive offset tool's
- * pick behavior.
- *
- * | Property | Type | Description |
- * |---|---|---|
- * | `componentId` | `string` | Component ID to offset |
- * | `distance` | `number` | Signed offset distance in Snaptrude units |
- * | `profilePickPoint` | {@linkcode PVec3} | Optional point used to choose a top contour profile |
- */
-export declare const PluginOffsetArgs: z.ZodObject<{
-    componentId: z.ZodString;
-    distance: z.ZodNumber;
-    profilePickPoint: z.ZodOptional<z.ZodObject<{
-        x: z.ZodNumber;
-        y: z.ZodNumber;
-        z: z.ZodNumber;
-    }, z.core.$strip>>;
-}, z.core.$strip>;
-export type PluginOffsetArgs = z.infer<typeof PluginOffsetArgs>;
-/**
- * Result of `snaptrude.tools.offset`.
- *
- * `createdIds` are the components created by the offset operation. `deletedIds`
- * are components removed by split-style offsets.
- */
-export declare const PluginOffsetResult: z.ZodObject<{
-    createdIds: z.ZodArray<z.ZodString>;
-    deletedIds: z.ZodArray<z.ZodString>;
-}, z.core.$strip>;
-export type PluginOffsetResult = {
-    createdIds: ComponentId[];
-    deletedIds: ComponentId[];
-};
-//# sourceMappingURL=offset.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"offset.d.ts","sourceRoot":"","sources":["../../../src/api/tools/offset.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AACxB,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAA;AAG9C;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,gBAAgB;;;;;;;;iBAI3B,CAAA;AAEF,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAA;AAE/D;;;;;GAKG;AACH,eAAO,MAAM,kBAAkB;;;iBAG7B,CAAA;AAEF,MAAM,MAAM,kBAAkB,GAAG;IAC/B,UAAU,EAAE,WAAW,EAAE,CAAA;IACzB,UAAU,EAAE,WAAW,EAAE,CAAA;CAC1B,CAAA"}

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

@@ -1,48 +0,0 @@
-import * as z from "zod";
-import { PluginApiReturn } from "../../types";
-/**
- * Query the current user selection in the Snaptrude editor.
- *
- * Accessed via `snaptrude.tools.selection`.
- */
-export declare abstract class PluginSelectionApi {
-    constructor();
-    /**
-     * Get the IDs of all currently selected components.
-     *
-     * Returns the component IDs from the editor's active selection stack.
-     * If nothing is selected, returns an empty array.
-     *
-     * The returned IDs can be used with {@linkcode PluginTransformApi.move},
-     * {@linkcode PluginTransformApi.rotate}, or entity query methods like
-     * {@linkcode PluginSpaceApi.get}.
-     *
-     * @returns A {@linkcode PluginSelectionGetResult} with a `selected` array
-     *   of component ID strings
-     *
-     * # Example
-     * ```ts
-     * const { selected } = await snaptrude.tools.selection.get()
-     * if (selected.length > 0) {
-     *   // Move selected components 5 units along X
-     *   await snaptrude.tools.transform.move({
-     *     componentIds: selected,
-     *     displacement: snaptrude.core.math.vec3.new(5, 0, 0),
-     *   })
-     * }
-     * ```
-     */
-    abstract get(): PluginApiReturn<PluginSelectionGetResult>;
-}
-/**
- * Result of {@linkcode PluginSelectionApi.get}.
- *
- * | Property | Type | Description |
- * |---|---|---|
- * | `selected` | `string[]` | Component IDs of the current selection |
- */
-export declare const PluginSelectionGetResult: z.ZodObject<{
-    selected: z.ZodArray<z.ZodString>;
-}, z.core.$strip>;
-export type PluginSelectionGetResult = z.infer<typeof PluginSelectionGetResult>;
-//# sourceMappingURL=selection.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"selection.d.ts","sourceRoot":"","sources":["../../../src/api/tools/selection.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AACxB,OAAO,EAAE,eAAe,EAAE,MAAM,aAAa,CAAA;AAE7C;;;;GAIG;AACH,8BAAsB,kBAAkB;;IAGtC;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;aACa,GAAG,IAAI,eAAe,CAAC,wBAAwB,CAAC;CACjE;AAED;;;;;;GAMG;AACH,eAAO,MAAM,wBAAwB;;iBAEnC,CAAA;AAEF,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAA"}

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

@@ -1,114 +0,0 @@
-import * as z from "zod";
-import { PluginApiReturn } from "../../types";
-/**
- * Transform operations — move and rotate scene components.
- *
- * All transform methods accept an array of component IDs and apply the
- * transformation to each. Operations are recorded in Snaptrude's
- * command system for undo/redo support.
- *
- * Accessed via `snaptrude.tools.transform`.
- */
-export declare abstract class PluginTransformApi {
-    constructor();
-    /**
-     * Translate components by a displacement vector.
-     *
-     * Each component's position is offset by the given
-     * {@linkcode PluginMoveArgs.displacement displacement} vector.
-     * This operation is undoable.
-     *
-     * @param args - An object containing:
-     *   - {@linkcode PluginMoveArgs.componentIds args.componentIds} — Array of component
-     *     ID strings to move
-     *   - {@linkcode PluginMoveArgs.displacement args.displacement} — Translation vector
-     *     as a {@linkcode PVec3} in Babylon units
-     * @throws If any component ID is not found in the scene
-     *
-     * # Example
-     * ```ts
-     * const { vec3 } = snaptrude.core.math
-     *
-     * // Move a space 10 units along the X axis
-     * await snaptrude.tools.transform.move({
-     *   componentIds: ["some-space-id"],
-     *   displacement: vec3.new(10, 0, 0),
-     * })
-     * ```
-     */
-    abstract move({ componentIds, displacement, }: PluginMoveArgs): PluginApiReturn<void>;
-    /**
-     * Rotate components around an axis through a pivot point.
-     *
-     * Each component is rotated by {@linkcode PluginRotateArgs.angle angle}
-     * radians around the {@linkcode PluginRotateArgs.axis axis} vector,
-     * pivoting about the {@linkcode PluginRotateArgs.pivot pivot} point.
-     * This operation is undoable.
-     *
-     * @param args - An object containing:
-     *   - {@linkcode PluginRotateArgs.componentIds args.componentIds} — Array of component
-     *     ID strings to rotate
-     *   - {@linkcode PluginRotateArgs.angle args.angle} — Rotation angle in **radians**
-     *   - {@linkcode PluginRotateArgs.axis args.axis} — Rotation axis as a {@linkcode PVec3}
-     *   - {@linkcode PluginRotateArgs.pivot args.pivot} — Pivot point as a {@linkcode PVec3}
-     *     in Babylon units
-     * @throws If any component ID is not found in the scene
-     *
-     * # Example
-     * ```ts
-     * const { vec3 } = snaptrude.core.math
-     *
-     * // Rotate a space 45° around the Y axis at the origin
-     * await snaptrude.tools.transform.rotate({
-     *   componentIds: ["some-space-id"],
-     *   angle: Math.PI / 4,
-     *   axis: vec3.new(0, 1, 0),
-     *   pivot: vec3.new(0, 0, 0),
-     * })
-     * ```
-     */
-    abstract rotate({ componentIds, angle, axis, pivot, }: PluginRotateArgs): PluginApiReturn<void>;
-}
-/**
- * Arguments for {@linkcode PluginTransformApi.move}.
- *
- * | Property | Type | Description |
- * |---|---|---|
- * | `componentIds` | `string[]` | Component IDs to move |
- * | `displacement` | {@linkcode PVec3} | Translation vector in Babylon units |
- */
-export declare const PluginMoveArgs: z.ZodObject<{
-    componentIds: z.ZodArray<z.ZodString>;
-    displacement: z.ZodObject<{
-        x: z.ZodNumber;
-        y: z.ZodNumber;
-        z: z.ZodNumber;
-    }, z.core.$strip>;
-}, z.core.$strip>;
-export type PluginMoveArgs = z.infer<typeof PluginMoveArgs>;
-/**
- * Arguments for {@linkcode PluginTransformApi.rotate}.
- *
- * | Property | Type | Description |
- * |---|---|---|
- * | `componentIds` | `string[]` | Component IDs to rotate |
- * | `angle` | `number` | Rotation angle in radians |
- * | `axis` | {@linkcode PVec3} | Rotation axis direction |
- * | `pivot` | {@linkcode PVec3} | Pivot point in Babylon units |
- */
-export declare const PluginRotateArgs: z.ZodObject<{
-    componentIds: z.ZodArray<z.ZodString>;
-    angle: z.ZodNumber;
-    axis: z.ZodObject<{
-        x: z.ZodNumber;
-        y: z.ZodNumber;
-        z: z.ZodNumber;
-    }, z.core.$strip>;
-    pivot: z.ZodObject<{
-        x: z.ZodNumber;
-        y: z.ZodNumber;
-        z: z.ZodNumber;
-    }, z.core.$strip>;
-}, z.core.$strip>;
-export type PluginRotateArgs = z.infer<typeof PluginRotateArgs>;
-//# sourceMappingURL=transform.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"transform.d.ts","sourceRoot":"","sources":["../../../src/api/tools/transform.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AACxB,OAAO,EAAE,eAAe,EAAE,MAAM,aAAa,CAAA;AAG7C;;;;;;;;GAQG;AACH,8BAAsB,kBAAkB;;IAGtC;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;aACa,IAAI,CAAC,EACnB,YAAY,EACZ,YAAY,GACb,EAAE,cAAc,GAAG,eAAe,CAAC,IAAI,CAAC;IAEzC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6BG;aACa,MAAM,CAAC,EACrB,YAAY,EACZ,KAAK,EACL,IAAI,EACJ,KAAK,GACN,EAAE,gBAAgB,GAAG,eAAe,CAAC,IAAI,CAAC;CAC5C;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,cAAc;;;;;;;iBAGzB,CAAA;AAEF,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAA;AAE3D;;;;;;;;;GASG;AACH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;iBAK3B,CAAA;AAEF,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAA"}

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

@@ -1,163 +0,0 @@
-import * as z from "zod";
-import { PluginApiReturn } from "../../types";
-/**
- * Unit conversion between real-world units and Snaptrude's internal
- * (Babylon) coordinate system.
- *
- * Snaptrude uses an internal unit system (Babylon units) for all
- * coordinates and dimensions. Use these methods to convert between
- * real-world measurements and Babylon units.
- *
- * Accessed via `snaptrude.units`.
- */
-export declare abstract class PluginUnitsApi {
-    constructor();
-    /**
-     * Convert a value from a real-world unit to Snaptrude's internal (Babylon) units.
-     *
-     * Use this when you have a measurement in real-world units (e.g. meters, feet)
-     * and need to convert it to the coordinate system used by Snaptrude internally.
-     *
-     * @param args - An object containing:
-     *   - {@linkcode PluginUnitsConvertFromArgs.unit args.unit} — The source unit
-     *     to convert from. See {@linkcode PUnitType} for supported values.
-     *   - {@linkcode PluginUnitsConvertFromArgs.value args.value} — The numeric
-     *     value in the source unit
-     *   - {@linkcode PluginUnitsConvertFromArgs.degree args.degree} — (Optional)
-     *     Degree of the unit: 1 for length, 2 for area, 3 for volume. Defaults to 1
-     * @returns A {@linkcode PluginUnitsConvertFromResult} containing the converted
-     *   `value` in Babylon units
-     *
-     * # Example
-     * ```ts
-     * // Convert 5 meters to Babylon units for use in API calls
-     * const result = await snaptrude.units.convertFrom({ unit: "meters", value: 5 })
-     * const { spaceId } = await snaptrude.entity.space.createRectangular({
-     *   position: snaptrude.core.math.vec3.new(0, 0, 0),
-     *   dimensions: { width: result.value, height: result.value, depth: result.value },
-     * })
-     * ```
-     */
-    abstract convertFrom(args: PluginUnitsConvertFromArgs): PluginApiReturn<PluginUnitsConvertFromResult>;
-    /**
-     * Convert a value from Snaptrude's internal (Babylon) units to a real-world unit.
-     *
-     * Use this when you have a value in Snaptrude's internal coordinate system
-     * and need to express it in real-world units (e.g. meters, feet).
-     *
-     * @param args - An object containing:
-     *   - {@linkcode PluginUnitsConvertToArgs.unit args.unit} — The target unit
-     *     to convert to. See {@linkcode PUnitType} for supported values.
-     *   - {@linkcode PluginUnitsConvertToArgs.value args.value} — The numeric
-     *     value in Babylon units
-     *   - {@linkcode PluginUnitsConvertToArgs.degree args.degree} — (Optional)
-     *     Degree of the unit: 1 for length, 2 for area, 3 for volume. Defaults to 1
-     * @returns A {@linkcode PluginUnitsConvertToResult} containing the converted
-     *   `value` in the target unit
-     *
-     * # Example
-     * ```ts
-     * // Get a space's area in square meters
-     * const info = await snaptrude.entity.space.get({
-     *   spaceId: "some-id",
-     *   properties: ["area"],
-     * })
-     * const areaInMeters = await snaptrude.units.convertTo({
-     *   unit: "meters",
-     *   value: info.area!,
-     *   degree: 2,
-     * })
-     * ```
-     */
-    abstract convertTo(args: PluginUnitsConvertToArgs): PluginApiReturn<PluginUnitsConvertToResult>;
-}
-/**
- * Supported unit types for conversion.
- *
- * - `meters` — Metric meters
- * - `feet-inches` — Imperial feet (1 foot = 12 inches)
- * - `inches` — Imperial inches
- * - `centimeters` — Metric centimeters
- * - `millimeters` — Metric millimeters
- * - `kilometers` — Metric kilometers
- * - `miles` — Imperial miles
- */
-export declare const PUnitType: z.ZodEnum<{
-    meters: "meters";
-    "feet-inches": "feet-inches";
-    inches: "inches";
-    centimeters: "centimeters";
-    millimeters: "millimeters";
-    kilometers: "kilometers";
-    miles: "miles";
-}>;
-export type PUnitType = z.infer<typeof PUnitType>;
-/**
- * Arguments for {@linkcode PluginUnitsApi.convertFrom}.
- *
- * | Property | Type | Description |
- * |---|---|---|
- * | `unit` | {@linkcode PUnitType} | Source real-world unit |
- * | `value` | `number` | Numeric value in the source unit |
- * | `degree` | `1 \| 2 \| 3` | (Optional) Degree of the unit (e.g. 1 for length, 2 for area, 3 for volume). Defaults to 1 |
- */
-export declare const PluginUnitsConvertFromArgs: z.ZodObject<{
-    unit: z.ZodEnum<{
-        meters: "meters";
-        "feet-inches": "feet-inches";
-        inches: "inches";
-        centimeters: "centimeters";
-        millimeters: "millimeters";
-        kilometers: "kilometers";
-        miles: "miles";
-    }>;
-    value: z.ZodNumber;
-    degree: z.ZodOptional<z.ZodNumber>;
-}, z.core.$strip>;
-export type PluginUnitsConvertFromArgs = z.infer<typeof PluginUnitsConvertFromArgs>;
-/**
- * Result of {@linkcode PluginUnitsApi.convertFrom}.
- *
- * | Property | Type | Description |
- * |---|---|---|
- * | `value` | `number` | The converted value in Babylon units |
- */
-export declare const PluginUnitsConvertFromResult: z.ZodObject<{
-    value: z.ZodNumber;
-}, z.core.$strip>;
-export type PluginUnitsConvertFromResult = z.infer<typeof PluginUnitsConvertFromResult>;
-/**
- * Arguments for {@linkcode PluginUnitsApi.convertTo}.
- *
- * | Property | Type | Description |
- * |---|---|---|
- * | `unit` | {@linkcode PUnitType} | Target real-world unit |
- * | `value` | `number` | Numeric value in Babylon units |
- * | `degree` | `1 \| 2 \| 3` | (Optional) Degree of the unit (e.g. 1 for length, 2 for area, 3 for volume). Defaults to 1 |
- */
-export declare const PluginUnitsConvertToArgs: z.ZodObject<{
-    unit: z.ZodEnum<{
-        meters: "meters";
-        "feet-inches": "feet-inches";
-        inches: "inches";
-        centimeters: "centimeters";
-        millimeters: "millimeters";
-        kilometers: "kilometers";
-        miles: "miles";
-    }>;
-    value: z.ZodNumber;
-    degree: z.ZodOptional<z.ZodNumber>;
-}, z.core.$strip>;
-export type PluginUnitsConvertToArgs = z.infer<typeof PluginUnitsConvertToArgs>;
-/**
- * Result of {@linkcode PluginUnitsApi.convertTo}.
- *
- * | Property | Type | Description |
- * |---|---|---|
- * | `value` | `number` | The converted value in the target unit |
- */
-export declare const PluginUnitsConvertToResult: z.ZodObject<{
-    value: z.ZodNumber;
-}, z.core.$strip>;
-export type PluginUnitsConvertToResult = z.infer<typeof PluginUnitsConvertToResult>;
-//# sourceMappingURL=index.d.ts.map

package/dist/api/units/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/api/units/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AACxB,OAAO,EAAE,eAAe,EAAE,MAAM,aAAa,CAAA;AAE7C;;;;;;;;;GASG;AACH,8BAAsB,cAAc;;IAGlC;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;aACa,WAAW,CACzB,IAAI,EAAE,0BAA0B,GAC/B,eAAe,CAAC,4BAA4B,CAAC;IAEhD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6BG;aACa,SAAS,CACvB,IAAI,EAAE,wBAAwB,GAC7B,eAAe,CAAC,0BAA0B,CAAC;CAC/C;AAED;;;;;;;;;;GAUG;AACH,eAAO,MAAM,SAAS;;;;;;;;EAQpB,CAAA;AAEF,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,SAAS,CAAC,CAAA;AAEjD;;;;;;;;GAQG;AACH,eAAO,MAAM,0BAA0B;;;;;;;;;;;;iBAIrC,CAAA;AAEF,MAAM,MAAM,0BAA0B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAA;AAEnF;;;;;;GAMG;AACH,eAAO,MAAM,4BAA4B;;iBAEvC,CAAA;AAEF,MAAM,MAAM,4BAA4B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,4BAA4B,CAAC,CAAA;AAEvF;;;;;;;;GAQG;AACH,eAAO,MAAM,wBAAwB;;;;;;;;;;;;iBAInC,CAAA;AAEF,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAA;AAE/E;;;;;;GAMG;AACH,eAAO,MAAM,0BAA0B;;iBAErC,CAAA;AAEF,MAAM,MAAM,0BAA0B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAA"}

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

@@ -1,70 +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 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 {
-    return { curveType: "Arc", startPoint, endPoint, centrePoint, axis }
-  }
-}
-
-/**
- * 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 const PArc = z.object({
-  curveType: z.literal("Arc"),
-  startPoint: PVec3,
-  endPoint: PVec3,
-  centrePoint: PVec3,
-  axis: PVec3,
-})
-
-export type PArc = z.infer<typeof PArc>

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

@@ -1,41 +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 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 {
-    return curve
-  }
-}
-
-/**
- * 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 const PCurve = z.discriminatedUnion("curveType", [PLine, PArc])
-
-export type PCurve = z.infer<typeof PCurve>

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

@@ -1,53 +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 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 {
-    return { curveType: "Line", startPoint, endPoint }
-  }
-}
-
-/**
- * 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 const PLine = z.object({
-  curveType: z.literal("Line"),
-  startPoint: PVec3,
-  endPoint: PVec3,
-})
-
-export type PLine = z.infer<typeof PLine>