fluidcad 0.0.6 → 0.0.8

package/bin/fluidcad.js

@@ -28,6 +28,22 @@ if (positionals[0] === 'init') {
 
   writeFileSync(initPath, `import { init } from 'fluidcad'\n\nexport default init()\n`);
 
+  const testPath = resolve(cwd, 'test.fluid.js');
+  if (!existsSync(testPath)) {
+    writeFileSync(testPath, `import { extrude, fillet, rect, shell, sketch } from "fluidcad/core";
+
+sketch("xy", () => {
+    rect(100, 50).radius(10).center();
+});
+
+const e = extrude(30);
+
+fillet(4, e.startEdges());
+
+shell(-2, e.endFaces());
+`);
+  }
+
   const jsconfigPath = resolve(cwd, 'jsconfig.json');
   if (!existsSync(jsconfigPath)) {
     writeFileSync(jsconfigPath, JSON.stringify({

package/lib/dist/core/2d/arc.d.ts

@@ -23,6 +23,13 @@ interface ArcFunction {
      * @param centered - Whether to center the arc on the current position
      */
     (radius: number, startAngle?: number, endAngle?: number, centered?: boolean): IGeometry;
+    /**
+     * Draws an arc from a start point to an end point around a center point.
+     * @param startPoint - The start point of the arc
+     * @param endPoint - The end point of the arc
+     * @param center - The center point of the arc
+     */
+    (startPoint: Point2DLike, endPoint: Point2DLike, center: Point2DLike): IGeometry;
     /**
      * Draws an arc to an end point on a specific plane.
      * @param endPoint - The end point of the arc
@@ -51,6 +58,14 @@ interface ArcFunction {
      * @param targetPlane - The plane to draw on
      */
     (startPoint: Point2DLike, endPoint: Point2DLike, radius: number, targetPlane: PlaneLike | ISceneObject): IGeometry;
+    /**
+     * Draws an arc from a start point to an end point around a center point on a specific plane.
+     * @param startPoint - The start point of the arc
+     * @param endPoint - The end point of the arc
+     * @param center - The center point of the arc
+     * @param targetPlane - The plane to draw on
+     */
+    (startPoint: Point2DLike, endPoint: Point2DLike, center: Point2DLike, targetPlane: PlaneLike | ISceneObject): IGeometry;
     /**
      * Draws an arc by radius on a specific plane.
      * @param radius - The arc radius

package/lib/dist/core/2d/arc.js

@@ -1,6 +1,7 @@
 import { isPoint2DLike } from "../../math/point.js";
 import { ArcFromTwoAngles } from "../../features/2d/arc.js";
 import { ArcToPoint } from "../../features/2d/arc-to-point.js";
+import { ArcThreePoints } from "../../features/2d/arc-three-points.js";
 import { Move } from "../../features/2d/move.js";
 import { normalizePoint2D } from "../../helpers/normalize.js";
 import { registerBuilder } from "../../index.js";
@@ -19,6 +20,15 @@ function build(context) {
                 argCount--;
             }
         }
+        // (startPoint, endPoint, center) — three Point2DLike args
+        if (argCount >= 3 && isPoint2DLike(arguments[0]) && isPoint2DLike(arguments[1]) && isPoint2DLike(arguments[2])) {
+            const start = normalizePoint2D(arguments[0]);
+            const end = normalizePoint2D(arguments[1]);
+            const center = normalizePoint2D(arguments[2]);
+            const arcObj = new ArcThreePoints(start, end, center, planeObj);
+            context.addSceneObjects([new Move(start), arcObj]);
+            return arcObj;
+        }
         // (startPoint, endPoint, radius?) — two Point2DLike args
         if (argCount >= 2 && isPoint2DLike(arguments[0]) && isPoint2DLike(arguments[1])) {
             const start = normalizePoint2D(arguments[0]);

package/lib/dist/core/2d/index.d.ts

@@ -13,7 +13,6 @@ export { default as arc } from './arc.js';
 export { default as move } from './move.js';
 export { default as pMove } from './pmove.js';
 export { default as aLine } from './aline.js';
-export { default as wire } from './wire.js';
 export { default as slot } from './slot.js';
 export { default as connect } from './connect.js';
 export { default as polygon } from './polygon.js';

package/lib/dist/core/2d/index.js

@@ -13,7 +13,6 @@ export { default as arc } from './arc.js';
 export { default as move } from './move.js';
 export { default as pMove } from './pmove.js';
 export { default as aLine } from './aline.js';
-export { default as wire } from './wire.js';
 export { default as slot } from './slot.js';
 export { default as connect } from './connect.js';
 export { default as polygon } from './polygon.js';

package/lib/dist/core/2d/tarc.d.ts

@@ -34,11 +34,35 @@ interface TArcFunction {
      */
     (startPoint: Point2DLike, endPoint: Point2DLike, tangent: Point2DLike): IGeometry;
     /**
-     * Draws a tangent arc between two objects with a given radius.
+     * Draws a tangent arc between two geometry objects.
+     * @param c1 - The first geometry object
+     * @param c2 - The second geometry object
+     * @param radius - The arc radius
+     * @param mustTouch - Whether the arc must touch both objects
+     */
+    (c1: ISceneObject, c2: ISceneObject, radius: number, mustTouch?: boolean): ITangentArcTwoObjects;
+    /**
+     * Draws a tangent arc between two qualified geometry objects.
+     * @param c1 - The first qualified geometry object (e.g., `outside(circle1)`)
+     * @param c2 - The second qualified geometry object
+     * @param radius - The arc radius
+     * @param mustTouch - Whether the arc must touch both objects
+     */
+    (c1: QualifiedSceneObject, c2: QualifiedSceneObject, radius: number, mustTouch?: boolean): ITangentArcTwoObjects;
+    /**
+     * Draws a tangent arc between two points.
+     * @param c1 - The first point
+     * @param c2 - The second point
+     * @param radius - The arc radius
+     * @param mustTouch - Whether the arc must touch both points
+     */
+    (c1: Point2DLike, c2: Point2DLike, radius: number, mustTouch?: boolean): ITangentArcTwoObjects;
+    /**
+     * Draws a tangent arc using a mix of geometry objects, qualified objects, or points as constraints.
      * @param c1 - The first constraint object or point
      * @param c2 - The second constraint object or point
      * @param radius - The arc radius
-     * @param mustTouch - Whether the arc must touch both objects
+     * @param mustTouch - Whether the arc must touch both constraints
      */
     (c1: ISceneObject | QualifiedSceneObject | Point2DLike, c2: ISceneObject | QualifiedSceneObject | Point2DLike, radius: number, mustTouch?: boolean): ITangentArcTwoObjects;
 }

package/lib/dist/core/2d/tcircle.d.ts

@@ -3,11 +3,35 @@ import { Point2DLike } from "../../math/point.js";
 import { IGeometry, ISceneObject } from "../interfaces.js";
 interface TCircleFunction {
     /**
-     * Draws a circle tangent to two objects with the given diameter.
+     * Draws a circle tangent to two geometry objects.
+     * @param c1 - The first geometry object
+     * @param c2 - The second geometry object
+     * @param diameter - The circle diameter
+     * @param mustTouch - Whether the circle must touch both objects
+     */
+    (c1: ISceneObject, c2: ISceneObject, diameter: number, mustTouch?: boolean): IGeometry;
+    /**
+     * Draws a circle tangent to two qualified geometry objects.
+     * @param c1 - The first qualified geometry object (e.g., `outside(circle1)`)
+     * @param c2 - The second qualified geometry object
+     * @param diameter - The circle diameter
+     * @param mustTouch - Whether the circle must touch both objects
+     */
+    (c1: QualifiedSceneObject, c2: QualifiedSceneObject, diameter: number, mustTouch?: boolean): IGeometry;
+    /**
+     * Draws a circle passing through two points.
+     * @param c1 - The first point
+     * @param c2 - The second point
+     * @param diameter - The circle diameter
+     * @param mustTouch - Whether the circle must touch both points
+     */
+    (c1: Point2DLike, c2: Point2DLike, diameter: number, mustTouch?: boolean): IGeometry;
+    /**
+     * Draws a tangent circle using a mix of geometry objects, qualified objects, or points as constraints.
      * @param c1 - The first constraint object or point
      * @param c2 - The second constraint object or point
      * @param diameter - The circle diameter
-     * @param mustTouch - Whether the circle must touch both objects
+     * @param mustTouch - Whether the circle must touch both constraints
      */
     (c1: ISceneObject | QualifiedSceneObject | Point2DLike, c2: ISceneObject | QualifiedSceneObject | Point2DLike, diameter: number, mustTouch?: boolean): IGeometry;
 }

package/lib/dist/core/2d/tline.d.ts

@@ -7,18 +7,38 @@ interface TLineFunction {
      */
     (distance: number): IGeometry;
     /**
-     * Draws a line tangent to two objects.
-     * @param c1 - The first constraint object
-     * @param c2 - The second constraint object
+     * Draws a line tangent to two geometry objects.
+     * @param c1 - The first geometry object
+     * @param c2 - The second geometry object
+     * @param mustTouch - Whether the line must touch both objects
+     */
+    (c1: ISceneObject, c2: ISceneObject, mustTouch?: boolean): ITwoObjectsTangentLine;
+    /**
+     * Draws a line tangent to two qualified geometry objects.
+     * @param c1 - The first qualified geometry object (e.g., `outside(circle1)`)
+     * @param c2 - The second qualified geometry object
+     * @param mustTouch - Whether the line must touch both objects
+     */
+    (c1: QualifiedSceneObject, c2: QualifiedSceneObject, mustTouch?: boolean): ITwoObjectsTangentLine;
+    /**
+     * Draws a line tangent to a combination of geometry and qualified geometry objects.
+     * @param c1 - The first constraint (geometry or qualified geometry)
+     * @param c2 - The second constraint (geometry or qualified geometry)
      * @param mustTouch - Whether the line must touch both objects
      */
     (c1: ISceneObject | QualifiedSceneObject, c2: ISceneObject | QualifiedSceneObject, mustTouch?: boolean): ITwoObjectsTangentLine;
     /**
-     * Draws a line tangent to one object.
-     * @param c1 - The constraint object
+     * Draws a line tangent to one geometry object.
+     * @param c1 - The geometry object to be tangent to
+     * @param mustTouch - Whether the line must touch the object
+     */
+    (c1: ISceneObject, mustTouch?: boolean): IGeometry;
+    /**
+     * Draws a line tangent to a qualified geometry object.
+     * @param c1 - The qualified geometry object (e.g., `outside(circle1)`)
      * @param mustTouch - Whether the line must touch the object
      */
-    (c1: ISceneObject | QualifiedSceneObject, mustTouch?: boolean): IGeometry;
+    (c1: QualifiedSceneObject, mustTouch?: boolean): IGeometry;
 }
 declare const _default: TLineFunction;
 export default _default;

package/lib/dist/core/axis.d.ts

@@ -30,12 +30,19 @@ interface AxisFunction {
      */
     (axis: IAxis, options: AxisTransformOptions): IAxis;
     /**
-     * Creates an axis midway between two axes.
-     * @param a1 - The first axis
-     * @param a2 - The second axis
+     * Creates an axis midway between two direction vectors.
+     * @param a1 - The first direction vector or standard axis
+     * @param a2 - The second direction vector or standard axis
      * @param options - Transform options (offset, flip, etc.)
      */
-    (a1: AxisLike | IAxis, a2: AxisLike | IAxis, options?: AxisTransformOptions): IAxis;
+    (a1: AxisLike, a2: AxisLike, options?: AxisTransformOptions): IAxis;
+    /**
+     * Creates an axis midway between two existing Axis objects.
+     * @param a1 - The first Axis object
+     * @param a2 - The second Axis object
+     * @param options - Transform options (offset, flip, etc.)
+     */
+    (a1: IAxis, a2: IAxis, options?: AxisTransformOptions): IAxis;
 }
 declare const _default: AxisFunction;
 export default _default;

package/lib/dist/core/chamfer.d.ts

@@ -6,11 +6,11 @@ interface ChamferFunction {
      */
     (distance?: number): ISceneObject;
     /**
-     * Chamfers the given edge selection with the given distance.
+     * Chamfers the given edge selections with the given distance.
      * @param distance - The chamfer distance
-     * @param selection - The edge selection to chamfer
+     * @param sceneObjects - The edge selections to chamfer
      */
-    (distance: number, selection: ISceneObject): ISceneObject;
+    (distance: number, ...sceneObjects: ISceneObject[]): ISceneObject;
     /**
      * Chamfers selected edges with two distances or a distance and angle.
      * @param distance - The first chamfer distance
@@ -19,13 +19,13 @@ interface ChamferFunction {
      */
     (distance: number, distance2: number, isAngle?: boolean): ISceneObject;
     /**
-     * Chamfers the given edge selection with two distances or a distance and angle.
+     * Chamfers the given edge selections with two distances or a distance and angle.
      * @param distance - The first chamfer distance
      * @param distance2 - The second distance, or angle if `isAngle` is true
      * @param isAngle - Whether `distance2` is an angle
-     * @param selection - The edge selection to chamfer
+     * @param sceneObjects - The edge selections to chamfer
      */
-    (distance: number, distance2: number, isAngle: boolean, selection: ISceneObject): ISceneObject;
+    (distance: number, distance2: number, isAngle: boolean, ...sceneObjects: ISceneObject[]): ISceneObject;
 }
 declare const _default: ChamferFunction;
 export default _default;

package/lib/dist/core/chamfer.js

@@ -4,14 +4,6 @@ import { registerBuilder } from "../index.js";
 function build(context) {
     return function chamfer() {
         const args = Array.from(arguments);
-        let selection;
-        if (args.length > 0 && args[args.length - 1] instanceof SceneObject) {
-            selection = args.pop();
-        }
-        else {
-            selection = context.getLastSelection() || undefined;
-        }
-        context.addSceneObject(selection); // Ensure lazy selections are added to the scene
         let distance = 1;
         let distance2 = undefined;
         let isAngle = false;
@@ -24,7 +16,18 @@ function build(context) {
         if (args.length >= 3 && typeof args[2] === 'boolean') {
             isAngle = args[2];
         }
-        const chamfer = new Chamfer(distance, distance2, isAngle, selection);
+        const selections = args
+            .filter(a => a instanceof SceneObject);
+        if (selections.length === 0) {
+            const lastSelection = context.getLastSelection() || undefined;
+            if (lastSelection) {
+                selections.push(lastSelection);
+            }
+        }
+        for (const selection of selections) {
+            context.addSceneObject(selection);
+        }
+        const chamfer = new Chamfer(distance, distance2, isAngle, ...selections);
         context.addSceneObject(chamfer);
         return chamfer;
     };

package/lib/dist/core/cut.d.ts

@@ -30,17 +30,38 @@ interface CutFunction {
      */
     (distance1: number, distance2: number, target: ISceneObject): ICut;
     /**
-     * Cuts up to face using the last sketch.
-     * @param face - The face to cut up to, or `'first-face'`/`'last-face'`
+     * Cuts up to a specific face using the last sketch.
+     * @param face - A face selection to cut up to
+     */
+    (face: ISceneObject): ICut;
+    /**
+     * Cuts up to the first intersecting face using the last sketch.
+     * @param face - The literal `'first-face'`
+     */
+    (face: 'first-face'): ICut;
+    /**
+     * Cuts up to the last intersecting face using the last sketch.
+     * @param face - The literal `'last-face'`
+     */
+    (face: 'last-face'): ICut;
+    /**
+     * Cuts up to a specific face using the given sketch.
+     * @param face - A face selection to cut up to
+     * @param target - The sketch to cut with
+     */
+    (face: ISceneObject, target: ISceneObject): ICut;
+    /**
+     * Cuts up to the first intersecting face using the given sketch.
+     * @param face - The literal `'first-face'`
      * @param target - The sketch to cut with
      */
-    (face: ISceneObject | 'first-face' | 'last-face'): ICut;
+    (face: 'first-face', target: ISceneObject): ICut;
     /**
-     * Cuts up to face using the given sketch.
-     * @param face - The face to cut up to, or `'first-face'`/`'last-face'`
+     * Cuts up to the last intersecting face using the given sketch.
+     * @param face - The literal `'last-face'`
      * @param target - The sketch to cut with
      */
-    (face: ISceneObject | 'first-face' | 'last-face', target: ISceneObject): ICut;
+    (face: 'last-face', target: ISceneObject): ICut;
 }
 declare const _default: CutFunction;
 export default _default;

package/lib/dist/core/extrude.d.ts

@@ -26,11 +26,23 @@ interface ExtrudeFunction {
      */
     (distance1: number, distance2: number, target: ISceneObject): IExtrude;
     /**
-     * Extrudes the last sketch up to a face.
-     * @param face - The face to extrude up to, or `'first-face'`/`'last-face'`
+     * Extrudes the last sketch up to a specific face.
+     * @param face - A face selection to extrude up to
      * @param target - The sketch to extrude
      */
-    (face: ISceneObject | 'first-face' | 'last-face', target?: ISceneObject): IExtrude;
+    (face: ISceneObject, target?: ISceneObject): IExtrude;
+    /**
+     * Extrudes the last sketch up to the first intersecting face.
+     * @param face - The literal `'first-face'`
+     * @param target - The sketch to extrude
+     */
+    (face: 'first-face', target?: ISceneObject): IExtrude;
+    /**
+     * Extrudes the last sketch up to the last intersecting face.
+     * @param face - The literal `'last-face'`
+     * @param target - The sketch to extrude
+     */
+    (face: 'last-face', target?: ISceneObject): IExtrude;
 }
 declare const _default: ExtrudeFunction;
 export default _default;

package/lib/dist/core/plane.d.ts

@@ -45,12 +45,19 @@ interface PlaneFunction {
      */
     (plane: IPlane, options: PlaneRenderableOptions): IPlane;
     /**
-     * Creates a plane midway between two planes.
-     * @param p1 - The first plane
-     * @param p2 - The second plane
+     * Creates a plane midway between two standard planes or normal vectors.
+     * @param p1 - The first standard plane or normal vector
+     * @param p2 - The second standard plane or normal vector
      * @param options - Transform options (offset, flip, sticky, etc.)
      */
-    (p1: PlaneLike | IPlane, p2: PlaneLike | IPlane, options?: PlaneRenderableOptions): IPlane;
+    (p1: PlaneLike, p2: PlaneLike, options?: PlaneRenderableOptions): IPlane;
+    /**
+     * Creates a plane midway between two existing Plane objects.
+     * @param p1 - The first Plane object
+     * @param p2 - The second Plane object
+     * @param options - Transform options (offset, flip, sticky, etc.)
+     */
+    (p1: IPlane, p2: IPlane, options?: PlaneRenderableOptions): IPlane;
 }
 declare const _default: PlaneFunction;
 export default _default;

package/lib/dist/core/repeat.d.ts

@@ -1,9 +1,10 @@
 import { AxisLike } from "../math/axis.js";
+import { Matrix4 } from "../math/matrix4.js";
 import { LinearRepeatOptions } from "../features/repeat-linear.js";
 import { CircularRepeatOptions } from "../features/repeat-circular.js";
 import { ISceneObject } from "./interfaces.js";
 import { PlaneLike } from "../math/plane.js";
-export type RepeatType = 'linear' | 'circular' | 'mirror';
+export type RepeatType = 'linear' | 'circular' | 'mirror' | 'rotate';
 interface RepeatFunction {
     /**
      * Creates linear repeated instances along an axis.
@@ -36,6 +37,20 @@ interface RepeatFunction {
      * @param objects - The objects to mirror (defaults to last object)
      */
     (type: 'mirror', plane: PlaneLike, ...objects: ISceneObject[]): ISceneObject;
+    /**
+     * Creates a rotated clone of objects around an axis.
+     * @param type - Must be `'rotate'`
+     * @param axis - The axis to rotate around
+     * @param angle - The rotation angle in degrees (defaults to 90)
+     * @param objects - The objects to rotate (defaults to last object)
+     */
+    (type: 'rotate', axis: AxisLike, angle?: number, ...objects: ISceneObject[]): ISceneObject;
+    /**
+     * Creates a transformed clone of objects using an arbitrary matrix.
+     * @param matrix - The transformation matrix to apply
+     * @param objects - The objects to transform (defaults to last object)
+     */
+    (matrix: Matrix4, ...objects: ISceneObject[]): ISceneObject;
 }
 declare const _default: RepeatFunction;
 export default _default;

package/lib/dist/core/repeat.js

@@ -8,16 +8,30 @@ import { cloneWithTransform } from "../helpers/clone-transform.js";
 import { PlaneObjectBase } from "../features/plane-renderable-base.js";
 import { PlaneObject } from "../features/plane.js";
 import { MirrorFeature } from "../features/mirror-feature.js";
+import { RepeatMatrix } from "../features/repeat-matrix.js";
+import { AxisObjectBase } from "../features/axis-renderable-base.js";
 function build(context) {
     return (function repeat() {
         const args = Array.from(arguments);
-        if (args.length < 2) {
-            throw new Error("Invalid arguments for repeat function: expected at least (type, ...)");
-        }
         const sketch = context.getActiveSketch();
         if (sketch) {
             throw new Error("Cannot call repeat() inside a sketch. Use copy() instead.");
         }
+        if (args[0] instanceof Matrix4) {
+            const matrix = args[0];
+            const restObjects = args.slice(1);
+            const objects = restObjects.length > 0
+                ? restObjects
+                : [context.getSceneObjects().at(-1)];
+            const feature = new RepeatMatrix(matrix, objects);
+            const cloned = cloneWithTransform(objects, matrix, feature);
+            context.addSceneObject(feature);
+            context.addSceneObjects(cloned);
+            return feature;
+        }
+        if (args.length < 2) {
+            throw new Error("Invalid arguments for repeat function: expected at least (type, ...)");
+        }
         const type = args[0];
         if (type === 'linear' || type === 'circular') {
             const axisArg = args[1];
@@ -140,6 +154,28 @@ function build(context) {
             context.addSceneObjects(mirrorTree);
             return mirrorFeature;
         }
+        if (type === 'rotate') {
+            const axisArg = args[1];
+            const axis = axisArg instanceof AxisObjectBase
+                ? axisArg.getAxis()
+                : normalizeAxis(axisArg);
+            let angle = 90;
+            let restStart = 2;
+            if (typeof args[2] === 'number') {
+                angle = args[2];
+                restStart = 3;
+            }
+            const restObjects = args.slice(restStart);
+            const objects = restObjects.length > 0
+                ? restObjects
+                : [context.getSceneObjects().at(-1)];
+            const matrix = Matrix4.fromRotationAroundAxis(axis.origin, axis.direction, rad(angle));
+            const feature = new RepeatMatrix(matrix, objects);
+            const cloned = cloneWithTransform(objects, matrix, feature);
+            context.addSceneObject(feature);
+            context.addSceneObjects(cloned);
+            return feature;
+        }
         throw new Error(`Invalid repeat type: ${type}`);
     });
 }

package/lib/dist/core/sketch.d.ts

@@ -8,11 +8,17 @@ interface SketchFunction {
      */
     (plane: PlaneLike, sketcher: () => void): ISceneObject;
     /**
-     * Draws 2D geometry on a face or plane object.
-     * @param face - The face or plane object to sketch on
+     * Draws 2D geometry on a face selection.
+     * @param face - The face to sketch on
      * @param sketcher - Callback containing sketch operations
      */
-    (face: ISceneObject | IPlane, sketcher: () => void): ISceneObject;
+    (face: ISceneObject, sketcher: () => void): ISceneObject;
+    /**
+     * Draws 2D geometry on an existing Plane object.
+     * @param plane - The Plane object to sketch on
+     * @param sketcher - Callback containing sketch operations
+     */
+    (plane: IPlane, sketcher: () => void): ISceneObject;
 }
 declare const _default: SketchFunction;
 export default _default;

package/lib/dist/core/subtract.d.ts

@@ -1,11 +1,12 @@
 import { ISceneObject } from "./interfaces.js";
 interface SubtractFunction {
     /**
-     * Subtracts the second solid from the first (boolean difference).
-     * @param solid1 - The base solid
-     * @param solid2 - The solid to subtract
+     * Subtracts the second shape from the first (boolean difference).
+     * Works with both 3D solids and 2D sketch geometries.
+     * @param object1 - The base shape
+     * @param object2 - The shape to subtract
      */
-    (solid1: ISceneObject, solid2: ISceneObject): ISceneObject;
+    (object1: ISceneObject, object2: ISceneObject): ISceneObject;
 }
 declare const _default: SubtractFunction;
 export default _default;

package/lib/dist/core/subtract.js

@@ -1,8 +1,15 @@
 import { registerBuilder } from "../index.js";
 import { Subtract } from "../features/subtract.js";
+import { Subtract2D } from "../features/subtract2d.js";
 function build(context) {
-    return function subtract(solid1, solid2) {
-        const subtract = new Subtract(solid1, solid2);
+    return function subtract(object1, object2) {
+        const activeSketch = context.getActiveSketch();
+        if (activeSketch) {
+            const subtract2d = new Subtract2D(object1, object2);
+            context.addSceneObject(subtract2d);
+            return subtract2d;
+        }
+        const subtract = new Subtract(object1, object2);
         context.addSceneObject(subtract);
         return subtract;
     };

package/lib/dist/features/2d/arc-three-points.d.ts

@@ -0,0 +1,19 @@
+import { GeometrySceneObject } from "./geometry.js";
+import { LazyVertex } from "../lazy-vertex.js";
+import { PlaneObjectBase } from "../plane-renderable-base.js";
+export declare class ArcThreePoints extends GeometrySceneObject {
+    startPoint: LazyVertex;
+    endPoint: LazyVertex;
+    center: LazyVertex;
+    private targetPlane;
+    constructor(startPoint: LazyVertex, endPoint: LazyVertex, center: LazyVertex, targetPlane?: PlaneObjectBase);
+    build(): void;
+    compareTo(other: ArcThreePoints): boolean;
+    getType(): string;
+    getUniqueType(): string;
+    serialize(): {
+        startPoint: {};
+        endPoint: {};
+        center: {};
+    };
+}