fluidcad 0.0.33 → 0.0.35

package/lib/dist/core/repeat.js

@@ -1,15 +1,37 @@
 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 { isNumberParam, resolveParam } from "./param.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 +45,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,25 +58,25 @@ 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
                 ? restObjects
                 : [context.getSceneObjects().at(-1)];
             if (type === 'linear') {
-                const counts = Array.isArray(options.count) ? options.count : [options.count];
+                const counts = Array.isArray(options.count) ? options.count : [resolveParam(options.count)];
                 const offsets = options.offset != null
-                    ? (Array.isArray(options.offset) ? options.offset : [options.offset])
+                    ? (Array.isArray(options.offset) ? options.offset : [resolveParam(options.offset)])
                     : null;
                 const lengths = 'length' in options && options.length != null
-                    ? (Array.isArray(options.length) ? options.length : [options.length])
+                    ? (Array.isArray(options.length) ? options.length : [resolveParam(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 +111,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,16 +138,17 @@ 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 count = resolveParam(circularOptions.count);
+                const { centered, skip } = circularOptions;
                 const repeat = new RepeatCircular(axis, circularOptions, objects);
                 let offset;
                 if ('offset' in circularOptions && circularOptions.offset !== undefined) {
-                    offset = circularOptions.offset;
+                    offset = resolveParam(circularOptions.offset);
                 }
                 else {
-                    const angle = circularOptions.angle;
+                    const angle = resolveParam(circularOptions.angle);
                     offset = angle % 360 === 0 ? angle / count : angle / (count - 1);
                 }
                 const startOffset = centered ? -(count * offset) / 2 : 0;
@@ -127,8 +158,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,44 +173,31 @@ 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') {
-                angle = args[2];
+            if (isNumberParam(args[2])) {
+                angle = resolveParam(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);
+            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/revolve.d.ts

@@ -1,5 +1,6 @@
 import { AxisLike } from "../math/axis.js";
 import { IRevolve, ISceneObject } from "./interfaces.js";
+import { type NumberParam } from "./param.js";
 interface RevolveFunction {
     /**
      * Revolves the last sketch 360 degrees around an axis.
@@ -13,7 +14,7 @@ interface RevolveFunction {
      * @param angle - The sweep angle in degrees
      * @param target - The sketch to revolve
      */
-    (axisLike: AxisLike, angle: number, target?: ISceneObject): IRevolve;
+    (axisLike: AxisLike, angle: NumberParam, target?: ISceneObject): IRevolve;
 }
 declare const _default: RevolveFunction;
 export default _default;

package/lib/dist/core/revolve.js

@@ -2,6 +2,7 @@ import { registerBuilder } from "../index.js";
 import { Revolve } from "../features/revolve.js";
 import { resolveAxis } from "../helpers/resolve.js";
 import { SceneObject } from "../common/scene-object.js";
+import { isNumberParam, resolveParam } from "./param.js";
 function isExtrudable(obj) {
     return obj instanceof SceneObject && obj.isExtrudable();
 }
@@ -16,8 +17,8 @@ function build(context) {
         // (axis, angle)
         if (params.length === 2) {
             const axis = resolveAxis(params[0], context);
-            if (typeof params[1] === 'number') {
-                return new Revolve(axis, params[1], extrudable);
+            if (isNumberParam(params[1])) {
+                return new Revolve(axis, resolveParam(params[1]), extrudable);
             }
         }
         throw new Error("Invalid parameters for revolve function.");

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

@@ -1,4 +1,5 @@
 import { IRib, ISceneObject } from "./interfaces.js";
+import { type NumberParam } from "./param.js";
 interface RibFunction {
     /**
      * Creates a rib from the last sketch with the given thickness.
@@ -6,13 +7,13 @@ interface RibFunction {
      * surrounding solids. Positive thickness = forward, negative = reverse.
      * @param thickness - Wall thickness (sign controls direction)
      */
-    (thickness: number): IRib;
+    (thickness: NumberParam): 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;
+    (thickness: NumberParam, spine: ISceneObject): IRib;
 }
 declare const _default: RibFunction;
 export default _default;

package/lib/dist/core/rib.js

@@ -1,6 +1,7 @@
 import { SceneObject } from "../common/scene-object.js";
 import { registerBuilder } from "../index.js";
 import { Rib } from "../features/rib.js";
+import { isNumberParam, resolveParam } from "./param.js";
 function isExtrudable(obj) {
     return obj instanceof SceneObject && obj.isExtrudable();
 }
@@ -11,8 +12,11 @@ function build(context) {
         if (args.length === 0) {
             throw new Error("rib() requires at least a thickness argument.");
         }
-        const thickness = args[0];
-        if (typeof thickness !== 'number' || thickness === 0) {
+        if (!isNumberParam(args[0])) {
+            throw new Error("rib() thickness must be a non-zero number.");
+        }
+        const thickness = resolveParam(args[0]);
+        if (thickness === 0) {
             throw new Error("rib() thickness must be a non-zero number.");
         }
         let spine;

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

@@ -1,26 +1,27 @@
 import { AxisLike } from "../math/axis.js";
 import { IRotate, ISceneObject } from "./interfaces.js";
+import { type NumberParam, type BooleanParam } from "./param.js";
 interface RotateFunction {
     /**
      * [2D] Rotates geometry by an angle inside a sketch.
      * @param angle - The rotation angle in degrees
      * @param targets - The geometries to rotate (defaults to last object)
      */
-    (angle: number, ...targets: ISceneObject[]): IRotate;
+    (angle: NumberParam, ...targets: ISceneObject[]): IRotate;
     /**
      * [2D] Rotates geometry by an angle inside a sketch, optionally making a copy.
      * @param angle - The rotation angle in degrees
      * @param copy - Whether to copy instead of move
      * @param targets - The geometries to rotate (defaults to last object)
      */
-    (angle: number, copy: boolean, ...targets: ISceneObject[]): IRotate;
+    (angle: NumberParam, copy: BooleanParam, ...targets: ISceneObject[]): IRotate;
     /**
      * [3D] Rotates objects around an axis by an angle.
      * @param axis - The axis to rotate around
      * @param angle - The rotation angle in degrees
      * @param targets - The objects to rotate (defaults to last object)
      */
-    (axis: AxisLike, angle: number, ...targets: ISceneObject[]): IRotate;
+    (axis: AxisLike, angle: NumberParam, ...targets: ISceneObject[]): IRotate;
     /**
      * [3D] Rotates objects around an axis by an angle, optionally making a copy.
      * @param axis - The axis to rotate around
@@ -28,7 +29,7 @@ interface RotateFunction {
      * @param copy - Whether to copy instead of move
      * @param targets - The objects to rotate (defaults to last object)
      */
-    (axis: AxisLike, angle: number, copy: boolean, ...targets: ISceneObject[]): IRotate;
+    (axis: AxisLike, angle: NumberParam, copy: BooleanParam, ...targets: ISceneObject[]): IRotate;
 }
 declare const _default: RotateFunction;
 export default _default;

package/lib/dist/core/rotate.js

@@ -5,6 +5,7 @@ import { SceneObject } from "../common/scene-object.js";
 import { AxisObjectBase } from "../features/axis-renderable-base.js";
 import { AxisObject } from "../features/axis.js";
 import { Rotate2D } from "../features/rotate2d.js";
+import { isBooleanParam, resolveParam } from "./param.js";
 function build(context) {
     return function rotate() {
         const args = Array.from(arguments);
@@ -15,13 +16,13 @@ function build(context) {
             targets.unshift(args.pop());
         }
         // Extract copy flag from the end (if boolean)
-        const copy = typeof args[args.length - 1] === 'boolean' ? args.pop() : false;
+        const copy = isBooleanParam(args[args.length - 1]) ? resolveParam(args.pop()) : false;
         // 2D: rotate(angle, copy?, ...targets)
         if (args.length === 1) {
             if (!activeSketch) {
                 throw new Error("rotate(angle) is only valid inside a sketch. For 3D rotation, specify an axis: rotate(axis, angle).");
             }
-            const angle = args[0];
+            const angle = resolveParam(args[0]);
             const rotate = new Rotate2D(angle, copy, ...targets);
             context.addSceneObject(rotate);
             return rotate;
@@ -40,7 +41,7 @@ function build(context) {
                 axis = new AxisObject(a);
                 context.addSceneObject(axis);
             }
-            const angle = args[1];
+            const angle = resolveParam(args[1]);
             const rotate = new Rotate(axis, angle, copy, ...targets);
             context.addSceneObject(rotate);
             return rotate;

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

@@ -1,16 +1,17 @@
 import { ISceneObject, IShell } from "./interfaces.js";
+import { type NumberParam } from "./param.js";
 interface ShellFunction {
     /**
      * Hollows out a solid with the given wall thickness.
      * @param thickness - The wall thickness (defaults to 2.5)
      */
-    (thickness?: number): IShell;
+    (thickness?: NumberParam): IShell;
     /**
      * Hollows out a solid, removing the selected faces.
      * @param thickness - The wall thickness
      * @param selections - The face selections to remove
      */
-    (thickness: number, ...selections: ISceneObject[]): IShell;
+    (thickness: NumberParam, ...selections: ISceneObject[]): IShell;
 }
 declare const _default: ShellFunction;
 export default _default;

package/lib/dist/core/shell.js

@@ -1,6 +1,7 @@
 import { Shell } from "../features/shell.js";
 import { SceneObject } from "../common/scene-object.js";
 import { registerBuilder } from "../index.js";
+import { isNumberParam, resolveParam } from "./param.js";
 function build(context) {
     return function shell() {
         const args = Array.from(arguments);
@@ -14,8 +15,8 @@ function build(context) {
                 selections.push(implicit);
             }
         }
-        const thickness = (args.length >= 1 && typeof args[0] === 'number')
-            ? args[0]
+        const thickness = (args.length >= 1 && isNumberParam(args[0]))
+            ? resolveParam(args[0])
             : 2.5;
         for (const sel of selections) {
             context.addSceneObject(sel);

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

@@ -1,16 +1,17 @@
 import { ITransformable } from "./interfaces.js";
+import { type NumberParam } from "./param.js";
 interface SphereFunction {
     /**
      * Creates a full sphere with the given radius.
      * @param radius - The sphere radius
      */
-    (radius: number): ITransformable;
+    (radius: NumberParam): ITransformable;
     /**
      * Creates a partial sphere with the given radius and sweep angle.
      * @param radius - The sphere radius
      * @param angle - The sweep angle in degrees
      */
-    (radius: number, angle: number): ITransformable;
+    (radius: NumberParam, angle: NumberParam): ITransformable;
 }
 declare const _default: SphereFunction;
 export default _default;

package/lib/dist/core/sphere.js

@@ -1,9 +1,10 @@
 import { Sphere } from "../features/sphere.js";
 import { rad } from "../helpers/math-helpers.js";
 import { registerBuilder } from "../index.js";
+import { resolveParam } from "./param.js";
 function build(context) {
     return function sphere(radius, angle = 360) {
-        const sphere = new Sphere(radius, rad(angle));
+        const sphere = new Sphere(resolveParam(radius), rad(resolveParam(angle)));
         context.addSceneObject(sphere);
         return sphere;
     };

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

@@ -1,26 +1,27 @@
 import { PointLike } from "../math/point.js";
 import { ISceneObject, ITranslate } from "./interfaces.js";
+import { type NumberParam, type BooleanParam } from "./param.js";
 interface TranslateFunction {
     /**
      * Translates objects along the X axis.
      * @param x - The X distance
      * @param targets - The objects to translate (defaults to last object)
      */
-    (x: number, ...targets: ISceneObject[]): ITranslate;
+    (x: NumberParam, ...targets: ISceneObject[]): ITranslate;
     /**
      * Translates objects along the X axis, optionally making a copy.
      * @param x - The X distance
      * @param copy - Whether to copy instead of move
      * @param targets - The objects to translate (defaults to last object)
      */
-    (x: number, copy: boolean, ...targets: ISceneObject[]): ITranslate;
+    (x: NumberParam, copy: BooleanParam, ...targets: ISceneObject[]): ITranslate;
     /**
      * Translates objects along the X and Y axes.
      * @param x - The X distance
      * @param y - The Y distance
      * @param targets - The objects to translate (defaults to last object)
      */
-    (x: number, y: number, ...targets: ISceneObject[]): ITranslate;
+    (x: NumberParam, y: NumberParam, ...targets: ISceneObject[]): ITranslate;
     /**
      * Translates objects along the X and Y axes, optionally making a copy.
      * @param x - The X distance
@@ -28,7 +29,7 @@ interface TranslateFunction {
      * @param copy - Whether to copy instead of move
      * @param targets - The objects to translate (defaults to last object)
      */
-    (x: number, y: number, copy: boolean, ...targets: ISceneObject[]): ITranslate;
+    (x: NumberParam, y: NumberParam, copy: BooleanParam, ...targets: ISceneObject[]): ITranslate;
     /**
      * Translates objects along all three axes.
      * @param x - The X distance
@@ -36,7 +37,7 @@ interface TranslateFunction {
      * @param z - The Z distance
      * @param targets - The objects to translate (defaults to last object)
      */
-    (x: number, y: number, z: number, ...targets: ISceneObject[]): ITranslate;
+    (x: NumberParam, y: NumberParam, z: NumberParam, ...targets: ISceneObject[]): ITranslate;
     /**
      * Translates objects along all three axes, optionally making a copy.
      * @param x - The X distance
@@ -45,7 +46,7 @@ interface TranslateFunction {
      * @param copy - Whether to copy instead of move
      * @param targets - The objects to translate (defaults to last object)
      */
-    (x: number, y: number, z: number, copy: boolean, ...targets: ISceneObject[]): ITranslate;
+    (x: NumberParam, y: NumberParam, z: NumberParam, copy: BooleanParam, ...targets: ISceneObject[]): ITranslate;
     /**
      * Translates objects by a point-like offset.
      * @param distance - The offset as a point

package/lib/dist/core/translate.js

@@ -5,6 +5,7 @@ import { Point } from "../math/point.js";
 import { SceneObject } from "../common/scene-object.js";
 import { Vertex } from "../common/vertex.js";
 import { LazyVertex } from "../features/lazy-vertex.js";
+import { isNumberParam, isBooleanParam, resolveParam } from "./param.js";
 function build(context) {
     return function translate() {
         const args = Array.from(arguments);
@@ -14,12 +15,12 @@ function build(context) {
             targets.unshift(args.pop());
         }
         // Extract copy flag from the end (if boolean)
-        const copy = typeof args[args.length - 1] === 'boolean' ? args.pop() : false;
+        const copy = isBooleanParam(args[args.length - 1]) ? resolveParam(args.pop()) : false;
         // translate(x, y?, z?)
-        if (typeof args[0] === 'number') {
-            const x = args[0];
-            const y = args[1] ?? 0;
-            const z = args[2] ?? 0;
+        if (isNumberParam(args[0])) {
+            const x = resolveParam(args[0]);
+            const y = isNumberParam(args[1]) ? resolveParam(args[1]) : 0;
+            const z = isNumberParam(args[2]) ? resolveParam(args[2]) : 0;
             const vertex = Vertex.fromPoint(new Point(x, y, z));
             const lazyVertex = LazyVertex.fromVertex(vertex);
             const translate = new Translate(lazyVertex, copy, ...targets);

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;