@snaptrude/plugin-core 0.3.0 → 0.6.0

package/dist/api/core/geom/update/contour.d.ts

@@ -0,0 +1,272 @@
+import * as z from "zod";
+import { PluginApiReturn } from "../../../../types";
+import { ContourHandle, ProfileHandle, Vec3Handle, Vec3Components } from "../../../../handles";
+/**
+ * Contour editing — produce NEW contours from an existing one (all-handle model, §11).
+ *
+ * A contour is an outer {@linkcode ProfileHandle} plus zero or more inner profiles
+ * that punch holes in it. Every method here is an immutable derive-new operation:
+ * it takes an opaque {@linkcode ContourHandle} (plus any extra inputs) and returns a
+ * fresh {@linkcode ContourHandle} for the resulting contour. The input contour is
+ * never mutated — the original handle keeps referring to the unchanged contour. Read
+ * the resulting geometry back as plain values with the query namespace.
+ *
+ * Accessed via `snaptrude.core.geom.update.contour`.
+ */
+export declare abstract class PluginGeomUpdateContourApi {
+    constructor();
+    /**
+     * Offset a contour inward/outward by a signed distance. Immutable — returns a NEW
+     * contour and leaves the input unchanged.
+     *
+     * @param contour The contour to offset
+     * @param distance Signed offset distance (outward when positive, inward when negative)
+     * @returns The offset contour as a NEW {@linkcode ContourHandle}
+     *
+     * @examplePrompt Offset this boundary 500mm inward
+     * @examplePrompt Shrink this floor outline by half a metre all around
+     *
+     * # Example
+     * ```ts
+     * const rect = await snaptrude.core.geom.create.profileRect(10, 8)
+     * const contour = await snaptrude.core.geom.create.contourFromProfile(rect)
+     * const inset = await snaptrude.core.geom.update.contour.offset(contour, -0.5)
+     * const area = await snaptrude.core.geom.query.contour.getArea(inset)
+     * ```
+     */
+    abstract offset(contour: ContourHandle, distance: number): PluginApiReturn<ContourHandle>;
+    /**
+     * Translate a contour by a vector. Immutable — returns a NEW contour and leaves
+     * the input unchanged.
+     *
+     * @param contour The contour to move
+     * @param translation Translation vector to move the contour by
+     * @returns The moved contour as a NEW {@linkcode ContourHandle}
+     *
+     * @examplePrompt Move this shape 2 metres to the right
+     * @examplePrompt Shift this outline over by 5 feet
+     *
+     * # Example
+     * ```ts
+     * const rect = await snaptrude.core.geom.create.profileRect(6, 4)
+     * const contour = await snaptrude.core.geom.create.contourFromProfile(rect)
+     * const shift = await snaptrude.core.math.vec3.new(2, 0, 0)
+     * const moved = await snaptrude.core.geom.update.contour.move(contour, shift)
+     * ```
+     */
+    abstract move(contour: ContourHandle, translation: Vec3Handle): PluginApiReturn<ContourHandle>;
+    /**
+     * Rotate a contour about an axis through an optional pivot. Immutable — returns a
+     * NEW contour and leaves the input unchanged.
+     *
+     * @param contour The contour to rotate
+     * @param axis Rotation axis direction
+     * @param angle Rotation angle in radians
+     * @param pivot Optional pivot point to rotate about (defaults to the origin)
+     * @returns The rotated contour as a NEW {@linkcode ContourHandle}
+     *
+     * @examplePrompt Rotate this shape 45 degrees
+     * @examplePrompt Turn this outline 90 degrees about its corner
+     *
+     * # Example
+     * ```ts
+     * const rect = await snaptrude.core.geom.create.profileRect(6, 4)
+     * const contour = await snaptrude.core.geom.create.contourFromProfile(rect)
+     * const axis = await snaptrude.core.math.vec3.new(0, 1, 0)
+     * const pivot = await snaptrude.core.math.vec3.new(3, 0, 2)
+     * const rotated = await snaptrude.core.geom.update.contour.rotate(contour, axis, Math.PI / 4, pivot)
+     * ```
+     */
+    abstract rotate(contour: ContourHandle, axis: Vec3Handle, angle: number, pivot?: Vec3Handle): PluginApiReturn<ContourHandle>;
+    /**
+     * Scale a contour uniformly or per-axis about an optional pivot. Immutable —
+     * returns a NEW contour and leaves the input unchanged.
+     *
+     * @param contour The contour to scale
+     * @param factor Uniform scale factor, or per-axis factors
+     * @param pivot Optional pivot point to scale about (defaults to the origin)
+     * @returns The scaled contour as a NEW {@linkcode ContourHandle}
+     *
+     * @examplePrompt Scale this shape up by a factor of 2
+     * @examplePrompt Make this outline half its current size
+     *
+     * # Example
+     * ```ts
+     * const rect = await snaptrude.core.geom.create.profileRect(6, 4)
+     * const contour = await snaptrude.core.geom.create.contourFromProfile(rect)
+     * const doubled = await snaptrude.core.geom.update.contour.scale(contour, 2)
+     * const stretched = await snaptrude.core.geom.update.contour.scale(contour, { x: 2, y: 1, z: 1 })
+     * ```
+     */
+    abstract scale(contour: ContourHandle, factor: number | Vec3Components, pivot?: Vec3Handle): PluginApiReturn<ContourHandle>;
+    /**
+     * Mirror a contour across a plane. Immutable — returns a NEW contour and leaves
+     * the input unchanged.
+     *
+     * @param contour The contour to mirror
+     * @param plane Mirror plane defined by a point on it and its normal
+     * @returns The mirrored contour as a NEW {@linkcode ContourHandle}
+     *
+     * @examplePrompt Mirror this shape across the gridline
+     * @examplePrompt Flip this outline to its mirror image
+     *
+     * # Example
+     * ```ts
+     * const rect = await snaptrude.core.geom.create.profileRect(6, 4)
+     * const contour = await snaptrude.core.geom.create.contourFromProfile(rect)
+     * const point = await snaptrude.core.math.vec3.new(0, 0, 0)
+     * const normal = await snaptrude.core.math.vec3.new(1, 0, 0)
+     * const mirrored = await snaptrude.core.geom.update.contour.mirror(contour, { point, normal })
+     * ```
+     */
+    abstract mirror(contour: ContourHandle, plane: {
+        point: Vec3Handle;
+        normal: Vec3Handle;
+    }): PluginApiReturn<ContourHandle>;
+    /**
+     * Add a hole to a contour by appending an inner profile. Immutable — returns a NEW
+     * contour and leaves the input unchanged.
+     *
+     * @param contour The contour to add a hole to
+     * @param hole The inner profile to add as a hole
+     * @returns The contour with the added hole as a NEW {@linkcode ContourHandle}
+     *
+     * @examplePrompt Cut a hole in this shape
+     * @examplePrompt Punch an opening through this floor outline
+     *
+     * # Example
+     * ```ts
+     * const outer = await snaptrude.core.geom.create.profileRect(10, 8)
+     * const contour = await snaptrude.core.geom.create.contourFromProfile(outer)
+     * const hole = await snaptrude.core.geom.create.profileRect(2, 2)
+     * const withHole = await snaptrude.core.geom.update.contour.addHole(contour, hole)
+     * const count = await snaptrude.core.geom.query.contour.getHoleCount(withHole) // 1
+     * ```
+     */
+    abstract addHole(contour: ContourHandle, hole: ProfileHandle): PluginApiReturn<ContourHandle>;
+    /**
+     * Remove a hole from a contour by inner-profile index. Immutable — returns a NEW
+     * contour and leaves the input unchanged.
+     *
+     * @param contour The contour to remove a hole from
+     * @param index Zero-based index of the inner profile (hole) to remove
+     * @returns The contour with the hole removed as a NEW {@linkcode ContourHandle}
+     *
+     * @examplePrompt Remove the hole from this shape
+     * @examplePrompt Fill in the opening in this floor outline
+     *
+     * # Example
+     * ```ts
+     * const outer = await snaptrude.core.geom.create.profileRect(10, 8)
+     * const hole = await snaptrude.core.geom.create.profileRect(2, 2)
+     * const contour = await snaptrude.core.geom.create.contourFromProfiles(outer, [hole])
+     * const solid = await snaptrude.core.geom.update.contour.removeHole(contour, 0)
+     * ```
+     */
+    abstract removeHole(contour: ContourHandle, index: number): PluginApiReturn<ContourHandle>;
+}
+/**
+ * Arguments for {@linkcode PluginGeomUpdateContourApi.offset}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `contour` | {@linkcode ContourHandle} | The contour to offset |
+ * | `distance` | `number` | Signed offset distance (outward when positive, inward when negative) |
+ */
+export declare const PluginGeomUpdateContourOffsetArgs: z.ZodObject<{
+    contour: z.ZodPipe<z.ZodString, z.ZodTransform<import("../../../..").Handle<"contour">, string>>;
+    distance: z.ZodNumber;
+}, z.core.$strip>;
+export type PluginGeomUpdateContourOffsetArgs = z.infer<typeof PluginGeomUpdateContourOffsetArgs>;
+/**
+ * Arguments for {@linkcode PluginGeomUpdateContourApi.move}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `contour` | {@linkcode ContourHandle} | The contour to move |
+ * | `translation` | {@linkcode Vec3Handle} | Translation vector to move the contour by |
+ */
+export declare const PluginGeomUpdateContourMoveArgs: z.ZodObject<{
+    contour: z.ZodPipe<z.ZodString, z.ZodTransform<import("../../../..").Handle<"contour">, string>>;
+    translation: z.ZodPipe<z.ZodString, z.ZodTransform<import("../../../..").Handle<"vec3">, string>>;
+}, z.core.$strip>;
+export type PluginGeomUpdateContourMoveArgs = z.infer<typeof PluginGeomUpdateContourMoveArgs>;
+/**
+ * Arguments for {@linkcode PluginGeomUpdateContourApi.rotate}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `contour` | {@linkcode ContourHandle} | The contour to rotate |
+ * | `axis` | {@linkcode Vec3Handle} | Rotation axis direction |
+ * | `angle` | `number` | Rotation angle in radians |
+ * | `pivot` | {@linkcode Vec3Handle} | Optional pivot point to rotate about (defaults to the origin) |
+ */
+export declare const PluginGeomUpdateContourRotateArgs: z.ZodObject<{
+    contour: z.ZodPipe<z.ZodString, z.ZodTransform<import("../../../..").Handle<"contour">, string>>;
+    axis: z.ZodPipe<z.ZodString, z.ZodTransform<import("../../../..").Handle<"vec3">, string>>;
+    angle: z.ZodNumber;
+    pivot: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("../../../..").Handle<"vec3">, string>>>;
+}, z.core.$strip>;
+export type PluginGeomUpdateContourRotateArgs = z.infer<typeof PluginGeomUpdateContourRotateArgs>;
+/**
+ * Arguments for {@linkcode PluginGeomUpdateContourApi.scale}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `contour` | {@linkcode ContourHandle} | The contour to scale |
+ * | `factor` | `number` \| {@linkcode Vec3Components} | Uniform scale factor, or per-axis factors |
+ * | `pivot` | {@linkcode Vec3Handle} | Optional pivot point to scale about (defaults to the origin) |
+ */
+export declare const PluginGeomUpdateContourScaleArgs: z.ZodObject<{
+    contour: z.ZodPipe<z.ZodString, z.ZodTransform<import("../../../..").Handle<"contour">, string>>;
+    factor: z.ZodUnion<readonly [z.ZodNumber, z.ZodObject<{
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+        z: z.ZodNumber;
+    }, z.core.$strip>]>;
+    pivot: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("../../../..").Handle<"vec3">, string>>>;
+}, z.core.$strip>;
+export type PluginGeomUpdateContourScaleArgs = z.infer<typeof PluginGeomUpdateContourScaleArgs>;
+/**
+ * Arguments for {@linkcode PluginGeomUpdateContourApi.mirror}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `contour` | {@linkcode ContourHandle} | The contour to mirror |
+ * | `plane` | `{ point: `{@linkcode Vec3Handle}`, normal: `{@linkcode Vec3Handle}` }` | Mirror plane defined by a point on it and its normal |
+ */
+export declare const PluginGeomUpdateContourMirrorArgs: z.ZodObject<{
+    contour: z.ZodPipe<z.ZodString, z.ZodTransform<import("../../../..").Handle<"contour">, string>>;
+    plane: z.ZodObject<{
+        point: z.ZodPipe<z.ZodString, z.ZodTransform<import("../../../..").Handle<"vec3">, string>>;
+        normal: z.ZodPipe<z.ZodString, z.ZodTransform<import("../../../..").Handle<"vec3">, string>>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type PluginGeomUpdateContourMirrorArgs = z.infer<typeof PluginGeomUpdateContourMirrorArgs>;
+/**
+ * Arguments for {@linkcode PluginGeomUpdateContourApi.addHole}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `contour` | {@linkcode ContourHandle} | The contour to add a hole to |
+ * | `hole` | {@linkcode ProfileHandle} | The inner profile to add as a hole |
+ */
+export declare const PluginGeomUpdateContourAddHoleArgs: z.ZodObject<{
+    contour: z.ZodPipe<z.ZodString, z.ZodTransform<import("../../../..").Handle<"contour">, string>>;
+    hole: z.ZodPipe<z.ZodString, z.ZodTransform<import("../../../..").Handle<"profile">, string>>;
+}, z.core.$strip>;
+export type PluginGeomUpdateContourAddHoleArgs = z.infer<typeof PluginGeomUpdateContourAddHoleArgs>;
+/**
+ * Arguments for {@linkcode PluginGeomUpdateContourApi.removeHole}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `contour` | {@linkcode ContourHandle} | The contour to remove a hole from |
+ * | `index` | `number` | Zero-based index of the inner profile (hole) to remove |
+ */
+export declare const PluginGeomUpdateContourRemoveHoleArgs: z.ZodObject<{
+    contour: z.ZodPipe<z.ZodString, z.ZodTransform<import("../../../..").Handle<"contour">, string>>;
+    index: z.ZodNumber;
+}, z.core.$strip>;
+export type PluginGeomUpdateContourRemoveHoleArgs = z.infer<typeof PluginGeomUpdateContourRemoveHoleArgs>;
+//# sourceMappingURL=contour.d.ts.map

package/dist/api/core/geom/update/contour.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"contour.d.ts","sourceRoot":"","sources":["../../../../../src/api/core/geom/update/contour.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AACxB,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAA;AACnD,OAAO,EACL,aAAa,EACb,aAAa,EACb,UAAU,EACV,cAAc,EACf,MAAM,qBAAqB,CAAA;AAE5B;;;;;;;;;;;GAWG;AACH,8BAAsB,0BAA0B;;IAG9C;;;;;;;;;;;;;;;;;;OAkBG;aACa,MAAM,CACpB,OAAO,EAAE,aAAa,EACtB,QAAQ,EAAE,MAAM,GACf,eAAe,CAAC,aAAa,CAAC;IAEjC;;;;;;;;;;;;;;;;;;OAkBG;aACa,IAAI,CAClB,OAAO,EAAE,aAAa,EACtB,WAAW,EAAE,UAAU,GACtB,eAAe,CAAC,aAAa,CAAC;IAEjC;;;;;;;;;;;;;;;;;;;;;OAqBG;aACa,MAAM,CACpB,OAAO,EAAE,aAAa,EACtB,IAAI,EAAE,UAAU,EAChB,KAAK,EAAE,MAAM,EACb,KAAK,CAAC,EAAE,UAAU,GACjB,eAAe,CAAC,aAAa,CAAC;IAEjC;;;;;;;;;;;;;;;;;;;OAmBG;aACa,KAAK,CACnB,OAAO,EAAE,aAAa,EACtB,MAAM,EAAE,MAAM,GAAG,cAAc,EAC/B,KAAK,CAAC,EAAE,UAAU,GACjB,eAAe,CAAC,aAAa,CAAC;IAEjC;;;;;;;;;;;;;;;;;;;OAmBG;aACa,MAAM,CACpB,OAAO,EAAE,aAAa,EACtB,KAAK,EAAE;QAAE,KAAK,EAAE,UAAU,CAAC;QAAC,MAAM,EAAE,UAAU,CAAA;KAAE,GAC/C,eAAe,CAAC,aAAa,CAAC;IAEjC;;;;;;;;;;;;;;;;;;;OAmBG;aACa,OAAO,CACrB,OAAO,EAAE,aAAa,EACtB,IAAI,EAAE,aAAa,GAClB,eAAe,CAAC,aAAa,CAAC;IAEjC;;;;;;;;;;;;;;;;;;OAkBG;aACa,UAAU,CACxB,OAAO,EAAE,aAAa,EACtB,KAAK,EAAE,MAAM,GACZ,eAAe,CAAC,aAAa,CAAC;CAClC;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,iCAAiC;;;iBAG5C,CAAA;AAEF,MAAM,MAAM,iCAAiC,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iCAAiC,CAAC,CAAA;AAEjG;;;;;;;GAOG;AACH,eAAO,MAAM,+BAA+B;;;iBAG1C,CAAA;AAEF,MAAM,MAAM,+BAA+B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,+BAA+B,CAAC,CAAA;AAE7F;;;;;;;;;GASG;AACH,eAAO,MAAM,iCAAiC;;;;;iBAK5C,CAAA;AAEF,MAAM,MAAM,iCAAiC,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iCAAiC,CAAC,CAAA;AAEjG;;;;;;;;GAQG;AACH,eAAO,MAAM,gCAAgC;;;;;;;;iBAI3C,CAAA;AAEF,MAAM,MAAM,gCAAgC,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gCAAgC,CAAC,CAAA;AAE/F;;;;;;;GAOG;AACH,eAAO,MAAM,iCAAiC;;;;;;iBAM5C,CAAA;AAEF,MAAM,MAAM,iCAAiC,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iCAAiC,CAAC,CAAA;AAEjG;;;;;;;GAOG;AACH,eAAO,MAAM,kCAAkC;;;iBAG7C,CAAA;AAEF,MAAM,MAAM,kCAAkC,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kCAAkC,CAAC,CAAA;AAEnG;;;;;;;GAOG;AACH,eAAO,MAAM,qCAAqC;;;iBAGhD,CAAA;AAEF,MAAM,MAAM,qCAAqC,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qCAAqC,CAAC,CAAA"}

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

@@ -0,0 +1,180 @@
+import * as z from "zod";
+import { PluginApiReturn } from "../../../../types";
+import { Vec3Handle, CurveHandle } from "../../../../handles";
+/**
+ * Curve editing — produce NEW curves from an existing one (all-handle model, §11).
+ *
+ * Every method takes an opaque {@linkcode CurveHandle} and returns a fresh handle
+ * (or handles) for the resulting geometry; the input curve is never mutated. Read
+ * the resulting geometry back as plain values with the query namespace.
+ *
+ * Accessed via `snaptrude.core.geom.update.curve`.
+ */
+export declare abstract class PluginGeomUpdateCurveApi {
+    constructor();
+    /**
+     * Extend a curve by a distance from one of its ends. Host API call — returns a handle.
+     *
+     * @param curve - The curve to extend
+     * @param distance - Distance to extend the curve by
+     * @param fromStart - Extend from the start end when `true`, otherwise from the end
+     * @returns The extended curve as a {@linkcode CurveHandle}
+     *
+     * @examplePrompt Extend this line by 1 metre
+     * @examplePrompt Lengthen this edge from its start point
+     *
+     * # Example
+     * ```ts
+     * const a = await snaptrude.core.math.vec3.new(0, 0, 0)
+     * const b = await snaptrude.core.math.vec3.new(5, 0, 0)
+     * const line = await snaptrude.core.geom.create.line(a, b)
+     * const longer = await snaptrude.core.geom.update.curve.extend(line, 1, false)
+     * const length = await snaptrude.core.geom.query.curve.getLength(longer) // 6
+     * ```
+     */
+    abstract extend(curve: CurveHandle, distance: number, fromStart: boolean): PluginApiReturn<CurveHandle>;
+    /**
+     * Split a curve at a point into separate segments. Host API call — returns handles.
+     *
+     * @param curve - The curve to split
+     * @param point - Point on the curve to split at
+     * @returns The resulting segments as {@linkcode CurveHandle}`[]`
+     *
+     * @examplePrompt Split this line at its midpoint
+     * @examplePrompt Break this edge into two pieces where it meets the gridline
+     *
+     * # Example
+     * ```ts
+     * const a = await snaptrude.core.math.vec3.new(0, 0, 0)
+     * const b = await snaptrude.core.math.vec3.new(6, 0, 0)
+     * const line = await snaptrude.core.geom.create.line(a, b)
+     * const mid = await snaptrude.core.math.vec3.new(3, 0, 0)
+     * const [left, right] = await snaptrude.core.geom.update.curve.split(line, mid)
+     * ```
+     */
+    abstract split(curve: CurveHandle, point: Vec3Handle): PluginApiReturn<CurveHandle[]>;
+    /**
+     * Trim a curve to the portion between two parameter values. Host API call — returns a handle.
+     *
+     * @param curve - The curve to trim
+     * @param startParam - Start parameter of the portion to keep
+     * @param endParam - End parameter of the portion to keep
+     * @returns The trimmed curve as a {@linkcode CurveHandle}
+     *
+     * @examplePrompt Trim this line back to a shorter segment
+     * @examplePrompt Keep only the middle portion of this curve
+     *
+     * # Example
+     * ```ts
+     * const a = await snaptrude.core.math.vec3.new(0, 0, 0)
+     * const b = await snaptrude.core.math.vec3.new(10, 0, 0)
+     * const line = await snaptrude.core.geom.create.line(a, b)
+     * const middle = await snaptrude.core.geom.update.curve.trim(line, 0.25, 0.75)
+     * ```
+     */
+    abstract trim(curve: CurveHandle, startParam: number, endParam: number): PluginApiReturn<CurveHandle>;
+    /**
+     * Offset a curve by a translation vector. Host API call — returns a handle.
+     *
+     * @param curve - The curve to offset
+     * @param vector - Translation vector to offset the curve by
+     * @returns The offset curve as a {@linkcode CurveHandle}
+     *
+     * @examplePrompt Offset this line 500mm to the side
+     * @examplePrompt Shift this edge over to make a parallel copy
+     *
+     * # Example
+     * ```ts
+     * const a = await snaptrude.core.math.vec3.new(0, 0, 0)
+     * const b = await snaptrude.core.math.vec3.new(8, 0, 0)
+     * const line = await snaptrude.core.geom.create.line(a, b)
+     * const sideways = await snaptrude.core.math.vec3.new(0, 0, 0.5)
+     * const parallel = await snaptrude.core.geom.update.curve.offset(line, sideways)
+     * ```
+     */
+    abstract offset(curve: CurveHandle, vector: Vec3Handle): PluginApiReturn<CurveHandle>;
+    /**
+     * Reverse the direction of a curve. Host API call — returns a handle.
+     *
+     * @param curve - The curve to reverse
+     * @returns The reversed curve as a {@linkcode CurveHandle}
+     *
+     * # Example
+     * ```ts
+     * const a = await snaptrude.core.math.vec3.new(0, 0, 0)
+     * const b = await snaptrude.core.math.vec3.new(4, 0, 0)
+     * const line = await snaptrude.core.geom.create.line(a, b)
+     * const reversed = await snaptrude.core.geom.update.curve.reverse(line)
+     * const start = await snaptrude.core.geom.query.curve.getStartPoint(reversed) // { x: 4, y: 0, z: 0 }
+     * ```
+     */
+    abstract reverse(curve: CurveHandle): PluginApiReturn<CurveHandle>;
+}
+/**
+ * Arguments for {@linkcode PluginGeomUpdateCurveApi.extend}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `curve` | {@linkcode CurveHandle} | The curve to extend |
+ * | `distance` | `number` | Distance to extend the curve by |
+ * | `fromStart` | `boolean` | Extend from the start end when `true`, otherwise from the end |
+ */
+export declare const PluginGeomUpdateCurveExtendArgs: z.ZodObject<{
+    curve: z.ZodUnion<readonly [z.ZodPipe<z.ZodString, z.ZodTransform<import("../../../..").Handle<"line">, string>>, z.ZodPipe<z.ZodString, z.ZodTransform<import("../../../..").Handle<"arc">, string>>]>;
+    distance: z.ZodNumber;
+    fromStart: z.ZodBoolean;
+}, z.core.$strip>;
+export type PluginGeomUpdateCurveExtendArgs = z.infer<typeof PluginGeomUpdateCurveExtendArgs>;
+/**
+ * Arguments for {@linkcode PluginGeomUpdateCurveApi.split}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `curve` | {@linkcode CurveHandle} | The curve to split |
+ * | `point` | {@linkcode Vec3Handle} | Point on the curve to split at |
+ */
+export declare const PluginGeomUpdateCurveSplitArgs: z.ZodObject<{
+    curve: z.ZodUnion<readonly [z.ZodPipe<z.ZodString, z.ZodTransform<import("../../../..").Handle<"line">, string>>, z.ZodPipe<z.ZodString, z.ZodTransform<import("../../../..").Handle<"arc">, string>>]>;
+    point: z.ZodPipe<z.ZodString, z.ZodTransform<import("../../../..").Handle<"vec3">, string>>;
+}, z.core.$strip>;
+export type PluginGeomUpdateCurveSplitArgs = z.infer<typeof PluginGeomUpdateCurveSplitArgs>;
+/**
+ * Arguments for {@linkcode PluginGeomUpdateCurveApi.trim}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `curve` | {@linkcode CurveHandle} | The curve to trim |
+ * | `startParam` | `number` | Start parameter of the portion to keep |
+ * | `endParam` | `number` | End parameter of the portion to keep |
+ */
+export declare const PluginGeomUpdateCurveTrimArgs: z.ZodObject<{
+    curve: z.ZodUnion<readonly [z.ZodPipe<z.ZodString, z.ZodTransform<import("../../../..").Handle<"line">, string>>, z.ZodPipe<z.ZodString, z.ZodTransform<import("../../../..").Handle<"arc">, string>>]>;
+    startParam: z.ZodNumber;
+    endParam: z.ZodNumber;
+}, z.core.$strip>;
+export type PluginGeomUpdateCurveTrimArgs = z.infer<typeof PluginGeomUpdateCurveTrimArgs>;
+/**
+ * Arguments for {@linkcode PluginGeomUpdateCurveApi.offset}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `curve` | {@linkcode CurveHandle} | The curve to offset |
+ * | `vector` | {@linkcode Vec3Handle} | Translation vector to offset the curve by |
+ */
+export declare const PluginGeomUpdateCurveOffsetArgs: z.ZodObject<{
+    curve: z.ZodUnion<readonly [z.ZodPipe<z.ZodString, z.ZodTransform<import("../../../..").Handle<"line">, string>>, z.ZodPipe<z.ZodString, z.ZodTransform<import("../../../..").Handle<"arc">, string>>]>;
+    vector: z.ZodPipe<z.ZodString, z.ZodTransform<import("../../../..").Handle<"vec3">, string>>;
+}, z.core.$strip>;
+export type PluginGeomUpdateCurveOffsetArgs = z.infer<typeof PluginGeomUpdateCurveOffsetArgs>;
+/**
+ * Arguments for {@linkcode PluginGeomUpdateCurveApi.reverse}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `curve` | {@linkcode CurveHandle} | The curve to reverse |
+ */
+export declare const PluginGeomUpdateCurveReverseArgs: z.ZodObject<{
+    curve: z.ZodUnion<readonly [z.ZodPipe<z.ZodString, z.ZodTransform<import("../../../..").Handle<"line">, string>>, z.ZodPipe<z.ZodString, z.ZodTransform<import("../../../..").Handle<"arc">, string>>]>;
+}, z.core.$strip>;
+export type PluginGeomUpdateCurveReverseArgs = z.infer<typeof PluginGeomUpdateCurveReverseArgs>;
+//# sourceMappingURL=curve.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"curve.d.ts","sourceRoot":"","sources":["../../../../../src/api/core/geom/update/curve.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AACxB,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAA;AACnD,OAAO,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAA;AAE7D;;;;;;;;GAQG;AACH,8BAAsB,wBAAwB;;IAG5C;;;;;;;;;;;;;;;;;;;OAmBG;aACa,MAAM,CACpB,KAAK,EAAE,WAAW,EAClB,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,OAAO,GACjB,eAAe,CAAC,WAAW,CAAC;IAE/B;;;;;;;;;;;;;;;;;;OAkBG;aACa,KAAK,CACnB,KAAK,EAAE,WAAW,EAClB,KAAK,EAAE,UAAU,GAChB,eAAe,CAAC,WAAW,EAAE,CAAC;IAEjC;;;;;;;;;;;;;;;;;;OAkBG;aACa,IAAI,CAClB,KAAK,EAAE,WAAW,EAClB,UAAU,EAAE,MAAM,EAClB,QAAQ,EAAE,MAAM,GACf,eAAe,CAAC,WAAW,CAAC;IAE/B;;;;;;;;;;;;;;;;;;OAkBG;aACa,MAAM,CACpB,KAAK,EAAE,WAAW,EAClB,MAAM,EAAE,UAAU,GACjB,eAAe,CAAC,WAAW,CAAC;IAE/B;;;;;;;;;;;;;;OAcG;aACa,OAAO,CAAC,KAAK,EAAE,WAAW,GAAG,eAAe,CAAC,WAAW,CAAC;CAC1E;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,+BAA+B;;;;iBAI1C,CAAA;AAEF,MAAM,MAAM,+BAA+B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,+BAA+B,CAAC,CAAA;AAE7F;;;;;;;GAOG;AACH,eAAO,MAAM,8BAA8B;;;iBAGzC,CAAA;AAEF,MAAM,MAAM,8BAA8B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,8BAA8B,CAAC,CAAA;AAE3F;;;;;;;;GAQG;AACH,eAAO,MAAM,6BAA6B;;;;iBAIxC,CAAA;AAEF,MAAM,MAAM,6BAA6B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,6BAA6B,CAAC,CAAA;AAEzF;;;;;;;GAOG;AACH,eAAO,MAAM,+BAA+B;;;iBAG1C,CAAA;AAEF,MAAM,MAAM,+BAA+B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,+BAA+B,CAAC,CAAA;AAE7F;;;;;;GAMG;AACH,eAAO,MAAM,gCAAgC;;iBAE3C,CAAA;AAEF,MAAM,MAAM,gCAAgC,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gCAAgC,CAAC,CAAA"}

package/dist/api/core/geom/update/index.d.ts

@@ -0,0 +1,27 @@
+import { PluginGeomUpdateCurveApi } from "./curve";
+import { PluginGeomUpdateProfileApi } from "./profile";
+import { PluginGeomUpdateContourApi } from "./contour";
+/**
+ * Curve/profile/contour update namespace — derive NEW geometry by editing existing
+ * handles (all-handle model, §11). Inputs are never mutated; every method returns a
+ * fresh handle.
+ *
+ * - {@linkcode PluginGeomUpdateApi.curve} — extend, split, trim, offset, reverse
+ * - {@linkcode PluginGeomUpdateApi.profile} — offset, affine, add/remove/reverse/simplify
+ * - {@linkcode PluginGeomUpdateApi.contour} — offset, affine, addHole/removeHole
+ *
+ * Accessed via `snaptrude.core.geom.update`.
+ */
+export declare abstract class PluginGeomUpdateApi {
+    /** Curve editing operations. See {@linkcode PluginGeomUpdateCurveApi}. */
+    abstract curve: PluginGeomUpdateCurveApi;
+    /** Profile editing operations. See {@linkcode PluginGeomUpdateProfileApi}. */
+    abstract profile: PluginGeomUpdateProfileApi;
+    /** Contour editing operations. See {@linkcode PluginGeomUpdateContourApi}. */
+    abstract contour: PluginGeomUpdateContourApi;
+    constructor();
+}
+export * from "./curve";
+export * from "./profile";
+export * from "./contour";
+//# sourceMappingURL=index.d.ts.map

package/dist/api/core/geom/update/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/api/core/geom/update/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,wBAAwB,EAAE,MAAM,SAAS,CAAA;AAClD,OAAO,EAAE,0BAA0B,EAAE,MAAM,WAAW,CAAA;AACtD,OAAO,EAAE,0BAA0B,EAAE,MAAM,WAAW,CAAA;AAEtD;;;;;;;;;;GAUG;AACH,8BAAsB,mBAAmB;IACvC,0EAA0E;IAC1E,SAAgB,KAAK,EAAE,wBAAwB,CAAA;IAC/C,8EAA8E;IAC9E,SAAgB,OAAO,EAAE,0BAA0B,CAAA;IACnD,8EAA8E;IAC9E,SAAgB,OAAO,EAAE,0BAA0B,CAAA;;CAGpD;AAED,cAAc,SAAS,CAAA;AACvB,cAAc,WAAW,CAAA;AACzB,cAAc,WAAW,CAAA"}