fluidcad 0.0.14 → 0.0.16

package/bin/fluidcad.js

@@ -26,14 +26,14 @@ if (positionals[0] === 'init') {
     process.exit(1);
   }
 
-  writeFileSync(initPath, `import { init } from 'fluidcad'\n\nexport default init()\n`);
+  writeFileSync(initPath, `import { init } from 'fluidcad'\n\nexport default await 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();
+    rect(100, 50).radius(10).centered();
 });
 
 const e = extrude(30);

package/lib/dist/common/scene-object.d.ts

@@ -27,10 +27,12 @@ export declare abstract class SceneObject implements Comparable<SceneObject>, Se
     private _id;
     private _order;
     private _transform;
+    private _cloneSource;
     private _parent;
     private _alwaysVisible;
     private _name;
     private _guide;
+    private _reusable;
     private _sourceLocation;
     private _error;
     protected _fusionScope?: FusionScope;
@@ -60,6 +62,8 @@ export declare abstract class SceneObject implements Comparable<SceneObject>, Se
     clone(): SceneObject[];
     setTransform(matrix: Matrix4): void;
     getTransform(): Matrix4 | null;
+    setCloneSource(source: SceneObject): void;
+    getCloneSource(): SceneObject | null;
     getTransformMatrix(): Matrix4 | null;
     isExtrudable(): boolean;
     init(): void;
@@ -71,7 +75,7 @@ export declare abstract class SceneObject implements Comparable<SceneObject>, Se
     addShape(shape: Shape): void;
     addShapes(shapes: Shape[]): void;
     removeShape(shape: Shape, removedBy: SceneObject): void;
-    removeShapes(removedBy: SceneObject): void;
+    removeShapes(removedBy: SceneObject, force?: boolean): void;
     getOwnShapes(filter?: ShapeFilter, scope?: Set<SceneObject>): Shape[];
     getChildShapes(filter?: ShapeFilter, type?: ShapeType): Shape[];
     getShapes(filter?: ShapeFilter, type?: ShapeType): Shape[];
@@ -89,6 +93,8 @@ export declare abstract class SceneObject implements Comparable<SceneObject>, Se
     getName(): string;
     name(value: string): this;
     guide(): this;
+    reusable(): this;
+    isReusable(): boolean;
     setSourceLocation(loc: SourceLocation): void;
     getSourceLocation(): SourceLocation | null;
     setError(message: string): void;

package/lib/dist/common/scene-object.js

@@ -5,10 +5,12 @@ export class SceneObject {
     _id;
     _order = 0;
     _transform = null;
+    _cloneSource = null;
     _parent = null;
     _alwaysVisible = false;
     _name = null;
     _guide = false;
+    _reusable = false;
     _sourceLocation = null;
     _error = null;
     _fusionScope = 'all';
@@ -88,7 +90,7 @@ export class SceneObject {
         return this.getState('snapshot') || [];
     }
     compareTo(other) {
-        const match = this._guide === other._guide;
+        const match = this._guide === other._guide && this._reusable === other._reusable;
         if (!match) {
             return false;
         }
@@ -161,6 +163,12 @@ export class SceneObject {
     getTransform() {
         return this._transform;
     }
+    setCloneSource(source) {
+        this._cloneSource = source;
+    }
+    getCloneSource() {
+        return this._cloneSource;
+    }
     getTransformMatrix() {
         return null;
     }
@@ -210,10 +218,13 @@ export class SceneObject {
             removedBy
         });
     }
-    removeShapes(removedBy) {
+    removeShapes(removedBy, force) {
+        if (this._reusable && !force) {
+            return;
+        }
         if (this.isContainer()) {
             for (const child of this.children) {
-                child.removeShapes(removedBy);
+                child.removeShapes(removedBy, force);
             }
             return;
         }
@@ -296,6 +307,13 @@ export class SceneObject {
         this._guide = true;
         return this;
     }
+    reusable() {
+        this._reusable = true;
+        return this;
+    }
+    isReusable() {
+        return this._reusable;
+    }
     setSourceLocation(loc) {
         this._sourceLocation = loc;
     }

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

@@ -1,84 +1,42 @@
 import { Point2DLike } from "../../math/point.js";
 import { PlaneLike } from "../../math/plane.js";
-import { IGeometry, ISceneObject } from "../interfaces.js";
+import { IArcPoints, IArcAngles, ISceneObject } from "../interfaces.js";
 interface ArcFunction {
     /**
-     * Draws an arc to an end point with an optional bulge radius.
+     * Draws an arc to an end point from the current position.
+     * Chain `.radius(r)` to set bulge radius, or `.center(point)` to specify the circle center.
      * @param endPoint - The end point of the arc
-     * @param radius - The bulge radius (0 = auto)
      */
-    (endPoint: Point2DLike, radius?: number): IGeometry;
+    (endPoint: Point2DLike): IArcPoints;
     /**
-     * Draws an arc from a start point to an end point with an optional bulge radius.
+     * Draws an arc from a start point to an end point.
+     * By default, uses the current position as the arc center.
+     * Chain `.radius(r)` to use bulge radius instead, or `.center(point)` to specify an explicit center.
      * @param startPoint - The start point of the arc
      * @param endPoint - The end point of the arc
-     * @param radius - The bulge radius (0 = auto)
      */
-    (startPoint: Point2DLike, endPoint: Point2DLike, radius?: number): IGeometry;
+    (startPoint: Point2DLike, endPoint: Point2DLike): IArcPoints;
     /**
-     * Draws an arc by radius and angle range.
+     * Draws an arc by radius and angle range at the current position.
+     * Chain `.centered()` to center the arc symmetrically around the start angle.
      * @param radius - The arc radius
      * @param startAngle - The start angle in degrees (defaults to 0)
      * @param endAngle - The end angle in degrees (defaults to 180)
-     * @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;
+    (radius: number, startAngle?: number, endAngle?: number): IArcAngles;
     /**
      * Draws an arc to an end point on a specific plane.
      * @param endPoint - The end point of the arc
      * @param targetPlane - The plane to draw on
      */
-    (endPoint: Point2DLike, targetPlane: PlaneLike | ISceneObject): IGeometry;
-    /**
-     * Draws an arc to an end point with a bulge radius on a specific plane.
-     * @param endPoint - The end point of the arc
-     * @param radius - The bulge radius
-     * @param targetPlane - The plane to draw on
-     */
-    (endPoint: Point2DLike, radius: number, targetPlane: PlaneLike | ISceneObject): IGeometry;
+    (endPoint: Point2DLike, targetPlane: PlaneLike | ISceneObject): IArcPoints;
     /**
      * Draws an arc between two points on a specific plane.
      * @param startPoint - The start point of the arc
      * @param endPoint - The end point of the arc
      * @param targetPlane - The plane to draw on
      */
-    (startPoint: Point2DLike, endPoint: Point2DLike, targetPlane: PlaneLike | ISceneObject): IGeometry;
-    /**
-     * Draws an arc between two points with a bulge radius on a specific plane.
-     * @param startPoint - The start point of the arc
-     * @param endPoint - The end point of the arc
-     * @param radius - The bulge radius
-     * @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
-     * @param targetPlane - The plane to draw on
-     */
-    (radius: number, targetPlane: PlaneLike | ISceneObject): IGeometry;
-    /**
-     * Draws an arc by radius and start angle on a specific plane.
-     * @param radius - The arc radius
-     * @param startAngle - The start angle in degrees
-     * @param targetPlane - The plane to draw on
-     */
-    (radius: number, startAngle: number, targetPlane: PlaneLike | ISceneObject): IGeometry;
+    (startPoint: Point2DLike, endPoint: Point2DLike, targetPlane: PlaneLike | ISceneObject): IArcPoints;
     /**
      * Draws an arc by radius and angle range on a specific plane.
      * @param radius - The arc radius
@@ -86,7 +44,7 @@ interface ArcFunction {
      * @param endAngle - The end angle in degrees
      * @param targetPlane - The plane to draw on
      */
-    (radius: number, startAngle: number, endAngle: number, targetPlane: PlaneLike | ISceneObject): IGeometry;
+    (radius: number, startAngle: number, endAngle: number, targetPlane: PlaneLike | ISceneObject): IArcAngles;
 }
 declare const _default: ArcFunction;
 export default _default;

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

@@ -1,8 +1,5 @@
 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 { Arc } from "../../features/2d/arc.js";
 import { normalizePoint2D } from "../../helpers/normalize.js";
 import { registerBuilder } from "../../index.js";
 import { isPlaneLike } from "../../math/plane.js";
@@ -20,38 +17,26 @@ 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
+        // (startPoint, endPoint) — two Point2DLike args, default center = current position
         if (argCount >= 2 && isPoint2DLike(arguments[0]) && isPoint2DLike(arguments[1])) {
             const start = normalizePoint2D(arguments[0]);
             const end = normalizePoint2D(arguments[1]);
-            const radius = argCount >= 3 ? arguments[2] : 0;
-            const arcObj = new ArcToPoint(end, radius, planeObj);
-            context.addSceneObjects([new Move(start), arcObj]);
+            const arcObj = Arc.twoPoints(start, end, planeObj);
+            context.addSceneObject(arcObj);
             return arcObj;
         }
-        // (endPoint, radius?) — single Point2DLike arg
+        // (endPoint) — single Point2DLike arg
         if (isPoint2DLike(arguments[0])) {
             const end = normalizePoint2D(arguments[0]);
-            const radius = argCount >= 2 ? arguments[1] : 0;
-            const arcObj = new ArcToPoint(end, radius, planeObj);
+            const arcObj = Arc.toPoint(end, planeObj);
             context.addSceneObject(arcObj);
             return arcObj;
         }
-        // (radius, startAngle, endAngle?, centered?) — all numeric args
+        // (radius, startAngle?, endAngle?) — all numeric args
         const radius = arguments[0] || 100;
         const startAngle = arguments[1] || 0;
         const endAngle = argCount >= 3 ? arguments[2] : 180;
-        const centered = argCount >= 4 ? arguments[3] : false;
-        const arcObj = new ArcFromTwoAngles(radius, startAngle, endAngle, centered, planeObj);
+        const arcObj = Arc.fromAngles(radius, startAngle, endAngle, planeObj);
         context.addSceneObject(arcObj);
         return arcObj;
     };

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

@@ -0,0 +1,9 @@
+import { IGeometry } from "../interfaces.js";
+interface CenterFunction {
+    /**
+     * Move the current position to the center of the sketch plane.
+     */
+    (): IGeometry;
+}
+declare const _default: CenterFunction;
+export default _default;

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

@@ -0,0 +1,10 @@
+import { PlaneCenter } from "../../features/2d/plane-center.js";
+import { registerBuilder } from "../../index.js";
+function build(context) {
+    return function center() {
+        const planeCenter = new PlaneCenter();
+        context.addSceneObject(planeCenter);
+        return planeCenter;
+    };
+}
+export default registerBuilder(build);

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

@@ -18,4 +18,6 @@ export { default as connect } from './connect.js';
 export { default as polygon } from './polygon.js';
 export { default as offset } from './offset.js';
 export { default as project } from './project.js';
+export { default as intersect } from './intersect.js';
 export { default as bezier } from './bezier.js';
+export { default as center } from './center.js';

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

@@ -18,4 +18,6 @@ export { default as connect } from './connect.js';
 export { default as polygon } from './polygon.js';
 export { default as offset } from './offset.js';
 export { default as project } from './project.js';
+export { default as intersect } from './intersect.js';
 export { default as bezier } from './bezier.js';
+export { default as center } from './center.js';

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

@@ -0,0 +1,17 @@
+import { PlaneLike } from "../../math/plane.js";
+import { IExtrudableGeometry, ISceneObject } from "../interfaces.js";
+interface IntersectFunction {
+    /**
+     * Intersects 3D objects with the current sketch plane, producing cross-section edges.
+     * @param sourceObjects - The 3D objects to intersect
+     */
+    (...sourceObjects: ISceneObject[]): IExtrudableGeometry;
+    /**
+     * Intersects 3D objects with a target plane, producing cross-section edges.
+     * @param sourceObjects - The 3D objects to intersect
+     * @param targetPlane - The plane to intersect with
+     */
+    (sourceObjects: ISceneObject[], targetPlane: PlaneLike | ISceneObject): IExtrudableGeometry;
+}
+declare const _default: IntersectFunction;
+export default _default;

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

@@ -0,0 +1,20 @@
+import { Intersect } from "../../features/2d/intersect.js";
+import { resolvePlane } from "../../helpers/resolve.js";
+import { registerBuilder } from "../../index.js";
+function build(context) {
+    return function intersect(...args) {
+        if (Array.isArray(args[0])) {
+            const sourceObjects = args[0];
+            context.addSceneObjects(sourceObjects);
+            const planeObj = resolvePlane(args[1], context);
+            const result = new Intersect(sourceObjects, planeObj);
+            context.addSceneObject(result);
+            return result;
+        }
+        const result = new Intersect(args);
+        context.addSceneObjects(args);
+        context.addSceneObject(result);
+        return result;
+    };
+}
+export default registerBuilder(build);

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

@@ -13,6 +13,13 @@ export interface ISceneObject {
      * final geometry output unless explicitly included.
      */
     guide(): this;
+    /**
+     * Marks this object as reusable. Reusable objects retain their shapes when
+     * consumed by features (e.g., extrude, revolve), allowing multiple features
+     * to reference the same source geometry. Use `remove(obj)` to force-remove
+     * shapes from a reusable object.
+     */
+    reusable(): this;
 }
 export interface IFuseable extends ISceneObject {
     /**
@@ -58,6 +65,26 @@ export interface IGeometry extends ISceneObject {
 }
 export interface IExtrudableGeometry extends IGeometry {
 }
+export interface IArcPoints extends IExtrudableGeometry {
+    /**
+     * Sets the bulge radius for point-to-point arcs.
+     * Positive = CCW, negative = CW.
+     * @param value - The bulge radius.
+     */
+    radius(value: number): this;
+    /**
+     * 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;
+}
+export interface IArcAngles extends IExtrudableGeometry {
+    /**
+     * Centers the arc symmetrically around the start angle.
+     */
+    centered(): this;
+}
 export interface IRect extends IExtrudableGeometry {
     /**
      * Sets corner radii for a rounded rectangle. Accepts 1–4 values
@@ -71,7 +98,7 @@ export interface IRect extends IExtrudableGeometry {
      * @param value - `true` centers on both axes, `'horizontal'` or `'vertical'` centers
      *   on one axis, `false` (default) keeps the current point as the origin corner.
      */
-    center(value?: boolean | 'horizontal' | 'vertical'): this;
+    centered(value?: boolean | 'horizontal' | 'vertical'): this;
     /**
      * Returns the top straight edge of the rectangle.
      */
@@ -127,7 +154,7 @@ export interface ISlot extends IExtrudableGeometry {
      * When `true`, the slot is offset backward by half its length.
      * @param value - `true` to center, `false` (default) to start from the current position.
      */
-    center(value?: boolean): this;
+    centered(value?: boolean): this;
     /**
      * Sets the rotation angle of the slot's primary axis.
      * @param angle - Rotation in degrees.
@@ -223,6 +250,17 @@ export interface IExtrude extends IFuseable {
      * @param args - Numeric indices or {@link EdgeFilterBuilder} instances to filter the selection.
      */
     internalEdges(...args: (number | EdgeFilterBuilder)[]): ISceneObject;
+    /**
+     * Selects the cap faces at the open ends of a thin-walled extrusion from an open profile.
+     * These are the small faces connecting the inner and outer walls at the profile endpoints.
+     * @param args - Numeric indices or {@link FaceFilterBuilder} instances to filter the selection.
+     */
+    capFaces(...args: (number | FaceFilterBuilder)[]): ISceneObject;
+    /**
+     * Selects edges on the cap faces of a thin-walled extrusion from an open profile.
+     * @param args - Numeric indices or {@link EdgeFilterBuilder} instances to filter the selection.
+     */
+    capEdges(...args: (number | EdgeFilterBuilder)[]): ISceneObject;
     /**
      * Applies a draft (taper) angle to the extrusion walls.
      * @param value - A single angle for uniform draft, or a `[start, end]` tuple for asymmetric draft.
@@ -244,6 +282,20 @@ export interface IExtrude extends IFuseable {
      * @param points - 2D points in the sketch plane identifying regions to extrude.
      */
     pick(...points: Point2DLike[]): this;
+    /**
+     * Enables thin extrude mode — offsets the profile edges to create a thin-walled solid
+     * instead of extruding filled faces. Positive values offset outward, negative values offset inward.
+     * @param offset - The wall offset distance. Positive = outward, negative = inward.
+     */
+    thin(offset: number): this;
+    /**
+     * Enables thin extrude mode with two offset directions.
+     * The two offsets must go in opposite directions. If both have the same sign,
+     * the second offset is automatically flipped.
+     * @param offset1 - The first wall offset distance. Positive = outward, negative = inward.
+     * @param offset2 - The second wall offset distance, in the opposite direction of offset1.
+     */
+    thin(offset1: number, offset2: number): this;
 }
 export interface ICut extends ISceneObject {
     /**
@@ -290,6 +342,20 @@ export interface ICut extends ISceneObject {
      * @param points - 2D points in the sketch plane identifying regions to cut.
      */
     pick(...points: Point2DLike[]): this;
+    /**
+     * Enables thin cut mode — offsets the profile edges to cut a thin-walled shape
+     * instead of cutting filled faces. Positive values offset outward, negative values offset inward.
+     * @param offset - The wall offset distance. Positive = outward, negative = inward.
+     */
+    thin(offset: number): this;
+    /**
+     * Enables thin cut mode with two offset directions.
+     * The two offsets must go in opposite directions. If both have the same sign,
+     * the second offset is automatically flipped.
+     * @param offset1 - The first wall offset distance. Positive = outward, negative = inward.
+     * @param offset2 - The second wall offset distance, in the opposite direction of offset1.
+     */
+    thin(offset1: number, offset2: number): this;
 }
 export interface IRevolve extends IFuseable {
     /**

package/lib/dist/core/part.js

@@ -11,7 +11,7 @@ function part(name, callback) {
     const currentFile = getCurrentFile();
     const isDirectEdit = sourceLocation
         && currentFile
-        && sourceLocation.filePath.replace('virtual:live-render:', '') === currentFile;
+        && sourceLocation.filePath === currentFile;
     if (isDirectEdit) {
         const scene = getCurrentScene();
         if (scene) {

package/lib/dist/core/repeat.js

@@ -73,9 +73,16 @@ function build(context) {
                     indexCombinations.push(...newCombinations);
                 }
                 for (const indices of indexCombinations) {
-                    // Skip the origin instance (all zeros)
-                    if (indices.every(i => i === 0)) {
-                        continue;
+                    // Skip the origin instance
+                    if (options.centered) {
+                        if (indices.every((idx, a) => idx === Math.floor(axisOffsets[a].count / 2))) {
+                            continue;
+                        }
+                    }
+                    else {
+                        if (indices.every(i => i === 0)) {
+                            continue;
+                        }
                     }
                     // Skip if in the skip list
                     if (options.skip?.some(s => s.length === indices.length && s.every((v, i) => v === indices[i]))) {
@@ -110,7 +117,8 @@ function build(context) {
                     offset = circularOptions.offset;
                 }
                 else {
-                    offset = circularOptions.angle / (count - 1);
+                    const angle = circularOptions.angle;
+                    offset = angle % 360 === 0 ? angle / count : angle / (count - 1);
                 }
                 const startOffset = centered ? -(count * offset) / 2 : 0;
                 const transformedObjects = [];

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

@@ -1,3 +1,4 @@
+import { SceneObject } from "../../common/scene-object.js";
 import { PlaneObjectBase } from "../plane-renderable-base.js";
 import { GeometrySceneObject } from "./geometry.js";
 export declare class AngledLine extends GeometrySceneObject {
@@ -7,6 +8,7 @@ export declare class AngledLine extends GeometrySceneObject {
     private targetPlane;
     constructor(length: number, angle: number, centered?: boolean, targetPlane?: PlaneObjectBase);
     build(): void;
+    createCopy(remap: Map<SceneObject, SceneObject>): SceneObject;
     compareTo(other: AngledLine): boolean;
     getType(): string;
     getUniqueType(): string;

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

@@ -47,6 +47,10 @@ export class AngledLine extends GeometrySceneObject {
         if (this.targetPlane)
             this.targetPlane.removeShapes(this);
     }
+    createCopy(remap) {
+        const targetPlane = this.targetPlane ? (remap.get(this.targetPlane) || this.targetPlane) : null;
+        return new AngledLine(this.length, this.angle, this.centered, targetPlane);
+    }
     compareTo(other) {
         if (!(other instanceof AngledLine)) {
             return false;

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

@@ -1,19 +1,32 @@
+import { Point2DLike } from "../../math/point.js";
 import { PlaneObjectBase } from "../plane-renderable-base.js";
 import { GeometrySceneObject } from "./geometry.js";
-export declare class ArcFromTwoAngles extends GeometrySceneObject {
-    radius: number;
-    startAngle: number;
-    endAngle: number;
-    centered: boolean;
-    private targetPlane;
-    constructor(radius: number, startAngle: number, endAngle: number, centered?: boolean, targetPlane?: PlaneObjectBase);
+import { LazyVertex } from "../lazy-vertex.js";
+import { IArcPoints, IArcAngles } from "../../core/interfaces.js";
+export declare class Arc extends GeometrySceneObject implements IArcPoints, IArcAngles {
+    private _startPoint;
+    private _endPoint;
+    private _arcRadius;
+    private _startAngle;
+    private _endAngle;
+    private _bulgeRadius;
+    private _centerPoint;
+    private _centered;
+    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;
+    radius(value: number): this;
+    center(value: Point2DLike): this;
+    centered(): this;
     build(): void;
+    private buildTwoPointsCenter;
+    private buildTwoPointsBulge;
+    private buildToPoint;
+    private buildWithCenter;
+    private buildFromAngles;
     getType(): string;
-    compareTo(other: ArcFromTwoAngles): boolean;
-    serialize(): {
-        radius: number;
-        startAngle: number;
-        endAngle: number;
-        centered: boolean;
-    };
+    compareTo(other: Arc): boolean;
+    serialize(): Record<string, unknown>;
 }