fluidcad 0.0.32 → 0.0.34

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

@@ -19,6 +19,25 @@ export interface ISceneObject {
      */
     reusable(): this;
 }
+export interface ILoadFile extends ISceneObject {
+    /**
+     * Skip applying colors from the imported file's color metadata sidecar.
+     */
+    noColors(): this;
+    /**
+     * Keep only the solids at the given 0-based indices (in load order).
+     * Combined with {@link exclude} by applying include first, then exclude.
+     * Repeated calls accumulate.
+     * @param indices - The 0-based solid indices to keep.
+     */
+    include(...indices: number[]): this;
+    /**
+     * Drop the solids at the given 0-based indices. Applied after {@link include}.
+     * Repeated calls accumulate.
+     * @param indices - The 0-based solid indices to drop.
+     */
+    exclude(...indices: number[]): this;
+}
 export interface IBooleanOperation extends ISceneObject {
     /**
      * Additive boolean operation — fuses the result with all intersecting scene objects.
@@ -138,13 +157,27 @@ export interface IArcPoints extends IExtrudableGeometry {
      * Positive = CCW, negative = CW.
      * @param value - The bulge radius.
      */
-    radius(value: number): this;
+    radius(value: number): IArcRadius;
     /**
      * Specifies the circle center point for the arc.
      * Mutually exclusive with `.radius()`.
      * @param value - The center point of the arc's circle.
      */
-    center(value: Point2DLike): this;
+    center(value: Point2DLike): IArcCenter;
+}
+export interface IArcRadius extends IExtrudableGeometry {
+    /**
+     * Switches to the major arc (> 180°).
+     * By default, `.radius()` produces the minor arc (< 180°);
+     * `.major()` switches to the complementary major arc on the same circle.
+     */
+    major(): this;
+}
+export interface IArcCenter extends IExtrudableGeometry {
+    /**
+     * Sweeps the arc clockwise from start to end instead of the default counter-clockwise.
+     */
+    cw(): this;
 }
 export interface IArcAngles extends IExtrudableGeometry {
     /**
@@ -279,6 +312,14 @@ export interface ITwoObjectsTangentLine extends IGeometry {
      */
     end(index?: number): LazyVertex;
 }
+export interface ITangentArcToObject extends IGeometry {
+    /**
+     * Flips the arc to the opposite side of the start tangent. By default,
+     * the arc curves to the left of the current tangent direction;
+     * `.flip()` switches it to the right.
+     */
+    flip(): this;
+}
 export interface ITangentArcTwoObjects extends IGeometry {
     /**
      * Returns the start vertex of the tangent arc.
@@ -695,6 +736,64 @@ export interface IRotate extends ISceneObject {
 }
 export interface IDraft extends ISceneObject {
 }
+export interface IRib extends IBooleanOperation {
+    /**
+     * Selects faces at the start (base) of the rib — the profile face at the sketch plane.
+     * @param args - Numeric indices or {@link FaceFilterBuilder} instances to filter the selection.
+     */
+    startFaces(...args: (number | FaceFilterBuilder)[]): ISceneObject;
+    /**
+     * Selects faces at the end (top) of the rib — where the rib meets the boundary.
+     * @param args - Numeric indices or {@link FaceFilterBuilder} instances to filter the selection.
+     */
+    endFaces(...args: (number | FaceFilterBuilder)[]): ISceneObject;
+    /**
+     * Selects the lateral wall faces of the rib.
+     * @param args - Numeric indices or {@link FaceFilterBuilder} instances to filter the selection.
+     */
+    sideFaces(...args: (number | FaceFilterBuilder)[]): ISceneObject;
+    /**
+     * Selects the small cap faces at the spine endpoints.
+     * @param args - Numeric indices or {@link FaceFilterBuilder} instances to filter the selection.
+     */
+    capFaces(...args: (number | FaceFilterBuilder)[]): ISceneObject;
+    /**
+     * Selects edges on the start faces.
+     * @param args - Numeric indices or {@link EdgeFilterBuilder} instances to filter the selection.
+     */
+    startEdges(...args: (number | EdgeFilterBuilder)[]): ISceneObject;
+    /**
+     * Selects edges on the end faces.
+     * @param args - Numeric indices or {@link EdgeFilterBuilder} instances to filter the selection.
+     */
+    endEdges(...args: (number | EdgeFilterBuilder)[]): ISceneObject;
+    /**
+     * Selects edges on the side faces, excluding edges shared with start/end faces.
+     * @param args - Numeric indices or {@link EdgeFilterBuilder} instances to filter the selection.
+     */
+    sideEdges(...args: (number | EdgeFilterBuilder)[]): ISceneObject;
+    /**
+     * Selects edges on the cap faces.
+     * @param args - Numeric indices or {@link EdgeFilterBuilder} instances to filter the selection.
+     */
+    capEdges(...args: (number | EdgeFilterBuilder)[]): ISceneObject;
+    /**
+     * Applies a draft (taper) angle to the rib walls.
+     * @param value - A single angle for uniform draft, or a `[start, end]` tuple for asymmetric draft.
+     */
+    draft(value: number | [number, number]): this;
+    /**
+     * Switches the extrusion direction to parallel to the sketch plane
+     * (perpendicular to the spine within the plane) instead of normal to it.
+     */
+    parallel(): this;
+    /**
+     * Extends the rib's side faces at the spine endpoints outward to blend
+     * with the target solids' walls.
+     */
+    extend(): this;
+}
+export type ShellJoinType = 'arc' | 'intersection' | 'tangent';
 export interface IShell extends ISceneObject {
     /**
      * Selects the inner wall faces created by the shell operation (from thickness removal).
@@ -707,4 +806,10 @@ export interface IShell extends ISceneObject {
      * @param args - Numeric indices or {@link EdgeFilterBuilder} instances to filter the selection.
      */
     internalEdges(...args: (number | EdgeFilterBuilder)[]): ISceneObject;
+    /**
+     * Sets the join type used at inner-wall corners.
+     * @param type - `'arc'` (default) for rounded blends, `'intersection'` for sharp corners,
+     *   or `'tangent'` for tangent-continuous blends.
+     */
+    join(type: ShellJoinType): this;
 }

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

@@ -1,10 +1,10 @@
-import { ISceneObject } from "./interfaces.js";
+import { ILoadFile } from "./interfaces.js";
 interface LoadFunction {
     /**
      * Loads a 3D model file (STEP, STL, etc.) by filename.
      * @param fileName - The path to the model file
      */
-    (fileName: string): ISceneObject;
+    (fileName: string): ILoadFile;
 }
 declare const _default: LoadFunction;
 export default _default;

package/lib/dist/core/repeat.js

@@ -1,15 +1,36 @@
 import { registerBuilder } from "../index.js";
-import { normalizeAxis, normalizePlane } from "../helpers/normalize.js";
+import { Axis } from "../math/axis.js";
+import { SceneObject } from "../common/scene-object.js";
 import { Matrix4 } from "../math/matrix4.js";
+import { LazyMatrix } from "../math/lazy-matrix.js";
 import { rad } from "../helpers/math-helpers.js";
 import { RepeatLinear } from "../features/repeat-linear.js";
 import { RepeatCircular } from "../features/repeat-circular.js";
 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 { resolveAxis, resolvePlane } from "../helpers/resolve.js";
+import { normalizeAxis } from "../helpers/normalize.js";
 import { AxisObjectBase } from "../features/axis-renderable-base.js";
+/**
+ * Resolve a repeat axis argument to a value usable by LazyMatrix. Scene-
+ * resident sources (AxisObjectBase or an edge SceneObject) go through
+ * resolveAxis so they end up in the scene and get built before consumers.
+ * Primitive inputs (world-axis string, raw Axis) stay as concrete Axis
+ * values — no extra scene object, no rendered world-axis line.
+ */
+function resolveRepeatAxis(arg, context) {
+    if (arg instanceof AxisObjectBase) {
+        return arg;
+    }
+    if (arg instanceof SceneObject) {
+        return resolveAxis(arg, context);
+    }
+    if (arg instanceof Axis) {
+        return arg;
+    }
+    return normalizeAxis(arg);
+}
 function build(context) {
     return (function repeat() {
         const args = Array.from(arguments);
@@ -23,8 +44,9 @@ function build(context) {
             const objects = restObjects.length > 0
                 ? restObjects
                 : [context.getSceneObjects().at(-1)];
-            const feature = new RepeatMatrix(matrix, objects);
-            const cloned = cloneWithTransform(objects, matrix, feature);
+            const lazy = LazyMatrix.of(matrix);
+            const feature = new RepeatMatrix(lazy, objects);
+            const cloned = cloneWithTransform(objects, lazy, feature);
             context.addSceneObject(feature);
             context.addSceneObjects(cloned);
             return feature;
@@ -35,9 +57,9 @@ function build(context) {
         const type = args[0];
         if (type === 'linear' || type === 'circular') {
             const axisArg = args[1];
-            const axes = Array.isArray(axisArg)
-                ? axisArg.map(a => normalizeAxis(a))
-                : [normalizeAxis(axisArg)];
+            const axisSources = Array.isArray(axisArg)
+                ? axisArg.map(a => resolveRepeatAxis(a, context))
+                : [resolveRepeatAxis(axisArg, context)];
             const options = args[2];
             const restObjects = args.slice(3);
             const objects = restObjects.length > 0
@@ -51,9 +73,9 @@ function build(context) {
                 const lengths = 'length' in options && options.length != null
                     ? (Array.isArray(options.length) ? options.length : [options.length])
                     : null;
-                const repeat = new RepeatLinear(axes, options, objects);
+                const repeat = new RepeatLinear(axisSources, options, objects);
                 const transformedObjects = [];
-                const axisOffsets = axes.map((axis, i) => {
+                const axisOffsets = axisSources.map((axis, i) => {
                     const count = counts[i] ?? counts[0];
                     const offset = offsets != null
                         ? (offsets[i] ?? offsets[0])
@@ -88,19 +110,26 @@ function build(context) {
                     if (options.skip?.some(s => s.length === indices.length && s.every((v, i) => v === indices[i]))) {
                         continue;
                     }
-                    // Compose translation from all axes
-                    let dx = 0, dy = 0, dz = 0;
-                    for (let a = 0; a < axisOffsets.length; a++) {
-                        const { axis, offset } = axisOffsets[a];
+                    // Capture per-axis offset + signed index for this instance; the
+                    // axis direction is read lazily at build time so an AxisObjectBase
+                    // can still be unbuilt at parse time.
+                    const perAxis = axisOffsets.map((entry, a) => {
                         const idx = options.centered
-                            ? indices[a] - Math.floor(axisOffsets[a].count / 2)
+                            ? indices[a] - Math.floor(entry.count / 2)
                             : indices[a];
-                        dx += axis.direction.x * offset * idx;
-                        dy += axis.direction.y * offset * idx;
-                        dz += axis.direction.z * offset * idx;
-                    }
-                    const transform = Matrix4.fromTranslation(dx, dy, dz);
-                    const cloned = cloneWithTransform(objects, transform, repeat);
+                        return { axis: entry.axis, offset: entry.offset, idx };
+                    });
+                    const lazy = LazyMatrix.from(() => {
+                        let dx = 0, dy = 0, dz = 0;
+                        for (const { axis, offset, idx } of perAxis) {
+                            const dir = (axis instanceof AxisObjectBase ? axis.getAxis() : axis).direction;
+                            dx += dir.x * offset * idx;
+                            dy += dir.y * offset * idx;
+                            dz += dir.z * offset * idx;
+                        }
+                        return Matrix4.fromTranslation(dx, dy, dz);
+                    });
+                    const cloned = cloneWithTransform(objects, lazy, repeat);
                     transformedObjects.push(...cloned);
                 }
                 context.addSceneObject(repeat);
@@ -108,7 +137,7 @@ function build(context) {
                 return repeat;
             }
             if (type === 'circular') {
-                const axis = axes[0];
+                const axis = axisSources[0];
                 const circularOptions = options;
                 const { count, centered, skip } = circularOptions;
                 const repeat = new RepeatCircular(axis, circularOptions, objects);
@@ -127,8 +156,8 @@ function build(context) {
                         continue;
                     }
                     const angle = startOffset + offset * i;
-                    const matrix = Matrix4.fromRotationAroundAxis(axis.origin, axis.direction, rad(angle));
-                    const cloned = cloneWithTransform(objects, matrix, repeat);
+                    const lazy = LazyMatrix.rotation(axis, rad(angle));
+                    const cloned = cloneWithTransform(objects, lazy, repeat);
                     transformedObjects.push(...cloned);
                 }
                 context.addSceneObject(repeat);
@@ -142,31 +171,16 @@ function build(context) {
             const targetObjects = restObjects.length > 0
                 ? restObjects
                 : [context.getSceneObjects().at(-1)];
-            let planeObj;
-            let normalizedPlane;
-            if (planeArg instanceof PlaneObjectBase) {
-                planeObj = planeArg;
-                planeObj.build();
-                normalizedPlane = planeObj.getPlane();
-            }
-            else {
-                normalizedPlane = normalizePlane(planeArg);
-                planeObj = new PlaneObject(normalizedPlane);
-                planeObj.build();
-                context.addSceneObject(planeObj);
-            }
-            const matrix = Matrix4.mirrorPlane(normalizedPlane.normal, normalizedPlane.origin);
-            const mirrorFeature = new MirrorFeature(planeObj, matrix);
-            const mirrorTree = cloneWithTransform(targetObjects, matrix, mirrorFeature);
+            const planeObj = resolvePlane(planeArg, context);
+            const lazy = LazyMatrix.mirror(planeObj);
+            const mirrorFeature = new MirrorFeature(planeObj, lazy);
+            const mirrorTree = cloneWithTransform(targetObjects, lazy, mirrorFeature);
             context.addSceneObject(mirrorFeature);
             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') {
@@ -177,9 +191,11 @@ function build(context) {
             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);
+            const axis = resolveRepeatAxis(axisArg, context);
+            const lazy = LazyMatrix.rotation(axis, rad(angle));
+            const sources = axis instanceof AxisObjectBase ? [axis] : [];
+            const feature = new RepeatMatrix(lazy, objects, sources);
+            const cloned = cloneWithTransform(objects, lazy, feature);
             context.addSceneObject(feature);
             context.addSceneObjects(cloned);
             return feature;

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

@@ -0,0 +1,18 @@
+import { IRib, ISceneObject } from "./interfaces.js";
+interface RibFunction {
+    /**
+     * Creates a rib from the last sketch with the given thickness.
+     * The rib extends in the sketch normal direction until it reaches
+     * surrounding solids. Positive thickness = forward, negative = reverse.
+     * @param thickness - Wall thickness (sign controls direction)
+     */
+    (thickness: number): IRib;
+    /**
+     * Creates a rib from an explicit sketch spine with the given thickness.
+     * @param thickness - Wall thickness (sign controls direction)
+     * @param spine - The sketch providing the rib spine wire and plane
+     */
+    (thickness: number, spine: ISceneObject): IRib;
+}
+declare const _default: RibFunction;
+export default _default;

package/lib/dist/core/rib.js

@@ -0,0 +1,37 @@
+import { SceneObject } from "../common/scene-object.js";
+import { registerBuilder } from "../index.js";
+import { Rib } from "../features/rib.js";
+function isExtrudable(obj) {
+    return obj instanceof SceneObject && obj.isExtrudable();
+}
+function build(context) {
+    //@ts-ignore
+    return function rib() {
+        const args = [...arguments];
+        if (args.length === 0) {
+            throw new Error("rib() requires at least a thickness argument.");
+        }
+        const thickness = args[0];
+        if (typeof thickness !== 'number' || thickness === 0) {
+            throw new Error("rib() thickness must be a non-zero number.");
+        }
+        let spine;
+        let extrudable;
+        if (args.length > 1 && isExtrudable(args[1])) {
+            spine = args[1];
+            extrudable = args[1];
+        }
+        else {
+            const lastExtrudable = context.getLastExtrudable();
+            if (!lastExtrudable) {
+                throw new Error("rib() requires a sketch. No sketch found in the scene.");
+            }
+            spine = lastExtrudable;
+            extrudable = lastExtrudable;
+        }
+        const result = new Rib(thickness, spine, extrudable);
+        context.addSceneObject(result);
+        return result;
+    };
+}
+export default registerBuilder(build);

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

@@ -2,9 +2,9 @@ import { Point2DLike } from "../../math/point.js";
 import { PlaneObjectBase } from "../plane-renderable-base.js";
 import { GeometrySceneObject } from "./geometry.js";
 import { LazyVertex } from "../lazy-vertex.js";
-import { IArcPoints, IArcAngles } from "../../core/interfaces.js";
+import { IArcPoints, IArcRadius, IArcCenter, IArcAngles } from "../../core/interfaces.js";
 import { SceneObject } from "../../common/scene-object.js";
-export declare class Arc extends GeometrySceneObject implements IArcPoints, IArcAngles {
+export declare class Arc extends GeometrySceneObject implements IArcPoints, IArcRadius, IArcCenter, IArcAngles {
     private _startPoint;
     private _endPoint;
     private _arcRadius;
@@ -13,18 +13,24 @@ export declare class Arc extends GeometrySceneObject implements IArcPoints, IArc
     private _bulgeRadius;
     private _centerPoint;
     private _centered;
+    private _clockwise;
+    private _major;
     private _targetPlane;
     constructor(targetPlane?: PlaneObjectBase | null);
     static toPoint(endPoint: LazyVertex, targetPlane?: PlaneObjectBase | null): Arc;
     static twoPoints(startPoint: LazyVertex, endPoint: LazyVertex, targetPlane?: PlaneObjectBase | null): Arc;
     static fromAngles(arcRadius: number, startAngle: number, endAngle: number, targetPlane?: PlaneObjectBase | null): Arc;
+    private static circumcenter;
     radius(value: number): this;
     center(value: Point2DLike): this;
     centered(): this;
+    cw(): this;
+    major(): this;
     build(): void;
     private buildTwoPointsCenter;
     private buildTwoPointsBulge;
     private buildToPoint;
+    private makeMajorArc;
     private buildWithCenter;
     private buildFromAngles;
     getType(): string;

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

@@ -16,6 +16,8 @@ export class Arc extends GeometrySceneObject {
     _bulgeRadius = 0;
     _centerPoint = null;
     _centered = false;
+    _clockwise = false;
+    _major = false;
     _targetPlane;
     constructor(targetPlane = null) {
         super();
@@ -39,6 +41,13 @@ export class Arc extends GeometrySceneObject {
         arc._endAngle = endAngle;
         return arc;
     }
+    static circumcenter(a, b, c) {
+        const D = 2 * (a.x * (b.y - c.y) + b.x * (c.y - a.y) + c.x * (a.y - b.y));
+        const aa = a.x * a.x + a.y * a.y;
+        const bb = b.x * b.x + b.y * b.y;
+        const cc = c.x * c.x + c.y * c.y;
+        return new Point2D((aa * (b.y - c.y) + bb * (c.y - a.y) + cc * (a.y - b.y)) / D, (aa * (c.x - b.x) + bb * (a.x - c.x) + cc * (b.x - a.x)) / D);
+    }
     // Chainable methods (IArc)
     radius(value) {
         this._bulgeRadius = value;
@@ -52,6 +61,14 @@ export class Arc extends GeometrySceneObject {
         this._centered = true;
         return this;
     }
+    cw() {
+        this._clockwise = true;
+        return this;
+    }
+    major() {
+        this._major = true;
+        return this;
+    }
     build() {
         if (this._startPoint && this._endPoint) {
             // Two explicit points: default center = current position
@@ -81,21 +98,26 @@ export class Arc extends GeometrySceneObject {
         const endPt = this._endPoint.asPoint2D();
         const centerPt = this._centerPoint
             ? this._centerPoint.asPoint2D()
-            : this.getCurrentPosition();
+            : new Point2D((startPt.x + endPt.x) / 2, (startPt.y + endPt.y) / 2);
         const dx = startPt.x - centerPt.x;
         const dy = startPt.y - centerPt.y;
         const radius = Math.sqrt(dx * dx + dy * dy);
         const endAngle = Math.atan2(endPt.y - centerPt.y, endPt.x - centerPt.x);
+        const normal = this._clockwise ? plane.normal.negate() : plane.normal;
         const center = plane.localToWorld(centerPt);
         const start = plane.localToWorld(startPt);
         const end = plane.localToWorld(endPt);
-        const arc = Geometry.makeArc(center, radius, plane.normal, start, end);
+        const arc = Geometry.makeArc(center, radius, normal, start, end);
         const edge = Geometry.makeEdgeFromCurve(arc);
-        const tx = -Math.sin(endAngle);
-        const ty = Math.cos(endAngle);
+        const sign = this._clockwise ? -1 : 1;
+        const tx = sign * (-Math.sin(endAngle));
+        const ty = sign * Math.cos(endAngle);
         this.setTangent(new Point2D(tx, ty));
         this.setState('start', Vertex.fromPoint2D(startPt));
         this.setState('end', Vertex.fromPoint2D(endPt));
+        const centerVertex = Vertex.fromPoint2D(centerPt);
+        centerVertex.markAsMetaShape();
+        this.addShape(centerVertex);
         this.addShape(edge);
         if (this.sketch) {
             this.setCurrentPosition(endPt);
@@ -129,14 +151,19 @@ export class Arc extends GeometrySceneObject {
         const center = plane.localToWorld(centerPoint);
         const start = plane.localToWorld(startPoint);
         const end = plane.localToWorld(targetPoint);
-        const arc = Geometry.makeArc(center, r, normal, start, end);
+        const arc = this._major
+            ? this.makeMajorArc(startPoint, targetPoint, centerPoint, cw, plane)
+            : Geometry.makeArc(center, r, normal, start, end);
         const edge = Geometry.makeEdgeFromCurve(arc);
-        const signT = cw ? -1 : 1;
+        const signT = (cw ? -1 : 1) * (this._major ? -1 : 1);
         const endTx = signT * (-Math.sin(endAngle));
         const endTy = signT * Math.cos(endAngle);
         this.setTangent(new Point2D(endTx, endTy));
         this.setState('start', Vertex.fromPoint2D(startPoint));
         this.setState('end', Vertex.fromPoint2D(targetPoint));
+        const centerVertex = Vertex.fromPoint2D(centerPoint);
+        centerVertex.markAsMetaShape();
+        this.addShape(centerVertex);
         this.addShape(edge);
         if (this.sketch) {
             this.setCurrentPosition(targetPoint);
@@ -172,14 +199,19 @@ export class Arc extends GeometrySceneObject {
         const center = plane.localToWorld(centerPoint);
         const start = plane.localToWorld(startPoint);
         const end = plane.localToWorld(targetPoint);
-        const arc = Geometry.makeArc(center, r, normal, start, end);
+        const arc = this._major
+            ? this.makeMajorArc(startPoint, targetPoint, centerPoint, cw, plane)
+            : Geometry.makeArc(center, r, normal, start, end);
         const edge = Geometry.makeEdgeFromCurve(arc);
-        const signT = cw ? -1 : 1;
+        const signT = (cw ? -1 : 1) * (this._major ? -1 : 1);
         const endTx = signT * (-Math.sin(endAngle));
         const endTy = signT * Math.cos(endAngle);
         this.setTangent(new Point2D(endTx, endTy));
         this.setState('start', Vertex.fromPoint2D(startPoint));
         this.setState('end', Vertex.fromPoint2D(targetPoint));
+        const centerVertex = Vertex.fromPoint2D(centerPoint);
+        centerVertex.markAsMetaShape();
+        this.addShape(centerVertex);
         this.addShape(edge);
         if (this.sketch) {
             this.setCurrentPosition(targetPoint);
@@ -188,6 +220,24 @@ export class Arc extends GeometrySceneObject {
             this._targetPlane.removeShapes(this);
         }
     }
+    makeMajorArc(startPoint2D, endPoint2D, centerPoint2D, cw, plane) {
+        const startAngleRad = Math.atan2(startPoint2D.y - centerPoint2D.y, startPoint2D.x - centerPoint2D.x);
+        const endAngleRad = Math.atan2(endPoint2D.y - centerPoint2D.y, endPoint2D.x - centerPoint2D.x);
+        let minorSweep = cw ? startAngleRad - endAngleRad : endAngleRad - startAngleRad;
+        if (minorSweep <= 0) {
+            minorSweep += 2 * Math.PI;
+        }
+        const midAngle = cw
+            ? startAngleRad + (2 * Math.PI - minorSweep) / 2
+            : startAngleRad - (2 * Math.PI - minorSweep) / 2;
+        const r = Math.sqrt((startPoint2D.x - centerPoint2D.x) ** 2 +
+            (startPoint2D.y - centerPoint2D.y) ** 2);
+        const midPoint2D = new Point2D(centerPoint2D.x + r * Math.cos(midAngle), centerPoint2D.y + r * Math.sin(midAngle));
+        const start = plane.localToWorld(startPoint2D);
+        const mid = plane.localToWorld(midPoint2D);
+        const end = plane.localToWorld(endPoint2D);
+        return Geometry.makeArcThreePoints(start, mid, end);
+    }
     buildWithCenter() {
         const plane = this._targetPlane?.getPlane() || this.sketch.getPlane();
         const startPt = this._targetPlane
@@ -195,20 +245,33 @@ export class Arc extends GeometrySceneObject {
             : this.getCurrentPosition();
         const endPt = this._endPoint.asPoint2D();
         const centerPt = this._centerPoint.asPoint2D();
-        const dx = startPt.x - centerPt.x;
-        const dy = startPt.y - centerPt.y;
-        const radius = Math.sqrt(dx * dx + dy * dy);
-        const endAngle = Math.atan2(endPt.y - centerPt.y, endPt.x - centerPt.x);
-        const center = plane.localToWorld(centerPt);
+        const aStart = Math.atan2(startPt.y - centerPt.y, startPt.x - centerPt.x);
+        const aEnd = Math.atan2(endPt.y - centerPt.y, endPt.x - centerPt.x);
+        let sweep = this._clockwise ? aStart - aEnd : aEnd - aStart;
+        if (sweep <= 0) {
+            sweep += 2 * Math.PI;
+        }
+        const midAngle = this._clockwise ? aStart - sweep / 2 : aStart + sweep / 2;
+        const rStart = Math.sqrt((startPt.x - centerPt.x) ** 2 + (startPt.y - centerPt.y) ** 2);
+        const rEnd = Math.sqrt((endPt.x - centerPt.x) ** 2 + (endPt.y - centerPt.y) ** 2);
+        const rMid = (rStart + rEnd) / 2;
+        const midPt = new Point2D(centerPt.x + rMid * Math.cos(midAngle), centerPt.y + rMid * Math.sin(midAngle));
+        const actualCenter = Arc.circumcenter(startPt, midPt, endPt);
+        const endAngle = Math.atan2(endPt.y - actualCenter.y, endPt.x - actualCenter.x);
         const start = plane.localToWorld(startPt);
         const end = plane.localToWorld(endPt);
-        const arc = Geometry.makeArc(center, radius, plane.normal, start, end);
+        const mid = plane.localToWorld(midPt);
+        const arc = Geometry.makeArcThreePoints(start, mid, end);
         const edge = Geometry.makeEdgeFromCurve(arc);
-        const tx = -Math.sin(endAngle);
-        const ty = Math.cos(endAngle);
+        const sign = this._clockwise ? -1 : 1;
+        const tx = sign * (-Math.sin(endAngle));
+        const ty = sign * Math.cos(endAngle);
         this.setTangent(new Point2D(tx, ty));
         this.setState('start', Vertex.fromPoint2D(startPt));
         this.setState('end', Vertex.fromPoint2D(endPt));
+        const centerVertex = Vertex.fromPoint2D(actualCenter);
+        centerVertex.markAsMetaShape();
+        this.addShape(centerVertex);
         this.addShape(edge);
         if (this.sketch) {
             this.setCurrentPosition(endPt);
@@ -254,6 +317,9 @@ export class Arc extends GeometrySceneObject {
         const edge = Geometry.makeEdgeFromCurve(arc);
         this.setState('start', Vertex.fromPoint2D(startPoint));
         this.setState('end', Vertex.fromPoint2D(endPoint));
+        const centerVertex = Vertex.fromPoint2D(centerPoint);
+        centerVertex.markAsMetaShape();
+        this.addShape(centerVertex);
         const sign = cw ? -1 : 1;
         const tx = sign * (-Math.sin(endAngleRad));
         const ty = sign * Math.cos(endAngleRad);
@@ -286,6 +352,8 @@ export class Arc extends GeometrySceneObject {
         copy._bulgeRadius = this._bulgeRadius;
         copy._centerPoint = this._centerPoint;
         copy._centered = this._centered;
+        copy._clockwise = this._clockwise;
+        copy._major = this._major;
         return copy;
     }
     compareTo(other) {
@@ -301,6 +369,9 @@ export class Arc extends GeometrySceneObject {
         if (this._targetPlane && other._targetPlane && !this._targetPlane.compareTo(other._targetPlane)) {
             return false;
         }
+        if (this._clockwise !== other._clockwise) {
+            return false;
+        }
         if (this._endPoint && other._endPoint) {
             if (!this._endPoint.compareTo(other._endPoint)) {
                 return false;
@@ -316,7 +387,7 @@ export class Arc extends GeometrySceneObject {
             if (this._centerPoint && other._centerPoint) {
                 return this._centerPoint.compareTo(other._centerPoint);
             }
-            return this._bulgeRadius === other._bulgeRadius;
+            return this._bulgeRadius === other._bulgeRadius && this._major === other._major;
         }
         if (!this._endPoint && !other._endPoint) {
             return this._arcRadius === other._arcRadius &&
@@ -340,6 +411,12 @@ export class Arc extends GeometrySceneObject {
             if (this._bulgeRadius !== 0) {
                 base.radius = this._bulgeRadius;
             }
+            if (this._clockwise) {
+                base.clockwise = true;
+            }
+            if (this._major) {
+                base.major = true;
+            }
             return base;
         }
         return {