fluidcad 0.0.27 → 0.0.29

package/lib/dist/common/profiler.d.ts

@@ -0,0 +1,12 @@
+export type ProfileCategory = {
+    category: string;
+    durationMs: number;
+};
+export declare class Profiler {
+    private categories;
+    private stack;
+    start(category: string): void;
+    end(category: string): void;
+    record<T>(category: string, fn: () => T): T;
+    getCategories(): ProfileCategory[];
+}

package/lib/dist/common/profiler.js

@@ -0,0 +1,35 @@
+export class Profiler {
+    categories = new Map();
+    stack = [];
+    start(category) {
+        this.stack.push({ category, startTime: performance.now() });
+    }
+    end(category) {
+        for (let i = this.stack.length - 1; i >= 0; i--) {
+            if (this.stack[i].category === category) {
+                const entry = this.stack.splice(i, 1)[0];
+                const elapsed = performance.now() - entry.startTime;
+                const current = this.categories.get(category) || 0;
+                this.categories.set(category, current + elapsed);
+                this.stack.length = i;
+                return;
+            }
+        }
+    }
+    record(category, fn) {
+        this.start(category);
+        try {
+            return fn();
+        }
+        finally {
+            this.end(category);
+        }
+    }
+    getCategories() {
+        const result = [];
+        for (const [category, durationMs] of this.categories.entries()) {
+            result.push({ category, durationMs: Math.round(durationMs * 10) / 10 });
+        }
+        return result;
+    }
+}

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

@@ -1,13 +1,29 @@
 import { Shape, ShapeFilter } from "./shape.js";
+import { Face } from "./face.js";
+import { Edge } from "./edge.js";
 import { Matrix4 } from "../math/matrix4.js";
 import { ISceneObject } from "../core/interfaces.js";
 import { FusionScope, OperationMode } from "../features/extrude-options.js";
 import { ShapeType } from "./shape-type.js";
+import { Profiler } from "./profiler.js";
 export type SourceLocation = {
     filePath: string;
     line: number;
     column: number;
 };
+export type AdditionRecord<T> = {
+    shape: T;
+    addedBy: SceneObject;
+};
+export type RemovalRecord<T> = {
+    shape: T;
+    removedBy: SceneObject;
+};
+export type ModificationRecord<T> = {
+    sources: T[];
+    results: T[];
+    modifiedBy: SceneObject;
+};
 export interface Comparable<T> {
     compareTo(other: T): boolean;
 }
@@ -20,6 +36,7 @@ export type BuildSceneObjectContext = {
     getSceneObjectsFromTo(obj: SceneObject, to: SceneObject, type?: string): SceneObject[];
     getTransform(): Matrix4 | null;
     getLastObject(): SceneObject | null;
+    getProfiler(): Profiler;
 };
 export declare abstract class SceneObject implements Comparable<SceneObject>, Serializable, ISceneObject {
     private state;
@@ -74,11 +91,41 @@ export declare abstract class SceneObject implements Comparable<SceneObject>, Se
     private set addedShapes(value);
     private get removedShapes();
     private set removedShapes(value);
+    private get addedFaces();
+    private set addedFaces(value);
+    private get modifiedFaces();
+    private set modifiedFaces(value);
+    private get removedFaces();
+    private set removedFaces(value);
+    private get addedEdges();
+    private set addedEdges(value);
+    private get modifiedEdges();
+    private set modifiedEdges(value);
+    private get removedEdges();
+    private set removedEdges(value);
+    private get finalShapes();
+    private set finalShapes(value);
     getUniqueType(): string;
     addShape(shape: Shape): void;
     addShapes(shapes: Shape[]): void;
     removeShape(shape: Shape, removedBy: SceneObject): void;
     removeShapes(removedBy: SceneObject, force?: boolean): void;
+    recordAddedFace(face: Face, addedBy: SceneObject): void;
+    recordAddedEdge(edge: Edge, addedBy: SceneObject): void;
+    recordModifiedFaces(sources: Face[], results: Face[], modifiedBy: SceneObject): void;
+    recordModifiedEdges(sources: Edge[], results: Edge[], modifiedBy: SceneObject): void;
+    recordRemovedFace(face: Face, removedBy: SceneObject): void;
+    recordRemovedEdge(edge: Edge, removedBy: SceneObject): void;
+    private ownsFace;
+    private ownsEdge;
+    getAddedFaces(scope?: Set<SceneObject>): Face[];
+    getModifiedFaces(scope?: Set<SceneObject>): ModificationRecord<Face>[];
+    getRemovedFaces(scope?: Set<SceneObject>): Face[];
+    getAddedEdges(scope?: Set<SceneObject>): Edge[];
+    getModifiedEdges(scope?: Set<SceneObject>): ModificationRecord<Edge>[];
+    getRemovedEdges(scope?: Set<SceneObject>): Edge[];
+    setFinalShapes(shapes: Shape[]): void;
+    getFinalShapes(): Shape[];
     getOwnShapes(filter?: ShapeFilter, scope?: Set<SceneObject>): Shape[];
     getChildShapes(filter?: ShapeFilter, type?: ShapeType): Shape[];
     getShapes(filter?: ShapeFilter, type?: ShapeType): Shape[];

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

@@ -21,6 +21,13 @@ export class SceneObject {
         this.state = new Map();
         this.state.set('addedShapes', []);
         this.state.set('removedShapes', []);
+        this.state.set('addedFaces', []);
+        this.state.set('modifiedFaces', []);
+        this.state.set('removedFaces', []);
+        this.state.set('addedEdges', []);
+        this.state.set('modifiedEdges', []);
+        this.state.set('removedEdges', []);
+        this.state.set('finalShapes', []);
         this._id = randomUUID().toString();
     }
     get id() {
@@ -208,6 +215,48 @@ export class SceneObject {
     set removedShapes(shapes) {
         this.state.set('removedShapes', shapes);
     }
+    get addedFaces() {
+        return this.state.get('addedFaces');
+    }
+    set addedFaces(records) {
+        this.state.set('addedFaces', records);
+    }
+    get modifiedFaces() {
+        return this.state.get('modifiedFaces');
+    }
+    set modifiedFaces(records) {
+        this.state.set('modifiedFaces', records);
+    }
+    get removedFaces() {
+        return this.state.get('removedFaces');
+    }
+    set removedFaces(records) {
+        this.state.set('removedFaces', records);
+    }
+    get addedEdges() {
+        return this.state.get('addedEdges');
+    }
+    set addedEdges(records) {
+        this.state.set('addedEdges', records);
+    }
+    get modifiedEdges() {
+        return this.state.get('modifiedEdges');
+    }
+    set modifiedEdges(records) {
+        this.state.set('modifiedEdges', records);
+    }
+    get removedEdges() {
+        return this.state.get('removedEdges');
+    }
+    set removedEdges(records) {
+        this.state.set('removedEdges', records);
+    }
+    get finalShapes() {
+        return this.state.get('finalShapes');
+    }
+    set finalShapes(shapes) {
+        this.state.set('finalShapes', shapes);
+    }
     getUniqueType() {
         return this.getType();
     }
@@ -251,6 +300,78 @@ export class SceneObject {
             this.removeShape(shape, removedBy);
         }
     }
+    recordAddedFace(face, addedBy) {
+        this.addedFaces.push({ shape: face, addedBy });
+    }
+    recordAddedEdge(edge, addedBy) {
+        this.addedEdges.push({ shape: edge, addedBy });
+    }
+    recordModifiedFaces(sources, results, modifiedBy) {
+        this.modifiedFaces.push({ sources, results, modifiedBy });
+    }
+    recordModifiedEdges(sources, results, modifiedBy) {
+        this.modifiedEdges.push({ sources, results, modifiedBy });
+    }
+    recordRemovedFace(face, removedBy) {
+        if (this.isContainer()) {
+            for (const child of this.children) {
+                if (child.ownsFace(face)) {
+                    child.recordRemovedFace(face, removedBy);
+                }
+            }
+            return;
+        }
+        this.removedFaces.push({ shape: face, removedBy });
+    }
+    recordRemovedEdge(edge, removedBy) {
+        if (this.isContainer()) {
+            for (const child of this.children) {
+                if (child.ownsEdge(edge)) {
+                    child.recordRemovedEdge(edge, removedBy);
+                }
+            }
+            return;
+        }
+        this.removedEdges.push({ shape: edge, removedBy });
+    }
+    ownsFace(face) {
+        return this.addedFaces.some(r => r.shape === face);
+    }
+    ownsEdge(edge) {
+        return this.addedEdges.some(r => r.shape === edge);
+    }
+    getAddedFaces(scope) {
+        return this.addedFaces
+            .filter(r => !scope || scope.has(r.addedBy))
+            .map(r => r.shape);
+    }
+    getModifiedFaces(scope) {
+        return this.modifiedFaces.filter(r => !scope || scope.has(r.modifiedBy));
+    }
+    getRemovedFaces(scope) {
+        return this.removedFaces
+            .filter(r => !scope || scope.has(r.removedBy))
+            .map(r => r.shape);
+    }
+    getAddedEdges(scope) {
+        return this.addedEdges
+            .filter(r => !scope || scope.has(r.addedBy))
+            .map(r => r.shape);
+    }
+    getModifiedEdges(scope) {
+        return this.modifiedEdges.filter(r => !scope || scope.has(r.modifiedBy));
+    }
+    getRemovedEdges(scope) {
+        return this.removedEdges
+            .filter(r => !scope || scope.has(r.removedBy))
+            .map(r => r.shape);
+    }
+    setFinalShapes(shapes) {
+        this.finalShapes = shapes;
+    }
+    getFinalShapes() {
+        return this.finalShapes;
+    }
     getOwnShapes(filter, scope) {
         filter = {
             excludeMeta: filter?.excludeMeta ?? true,

package/lib/dist/common/shape-factory.d.ts

@@ -4,5 +4,5 @@ import { Wire } from "./wire.js";
 import { Face } from "./face.js";
 import { Edge } from "./edge.js";
 export declare class ShapeFactory {
-    static fromShape(shape: TopoDS_Shape): Wire | Edge | Face | Solid;
+    static fromShape(shape: TopoDS_Shape): Solid | Face | Edge | Wire;
 }

package/lib/dist/common/shape-history-tracker.d.ts

@@ -0,0 +1,43 @@
+import type { BRepBuilderAPI_MakeShape } from "occjs-wrapper";
+import { Face } from "./face.js";
+import { Edge } from "./edge.js";
+import { Shape } from "./shape.js";
+export type ShapeHistoryRecord<T> = {
+    sources: T[];
+    results: T[];
+};
+export type ShapeHistory = {
+    addedFaces: Face[];
+    modifiedFaces: ShapeHistoryRecord<Face>[];
+    generatedFaces: ShapeHistoryRecord<Face>[];
+    removedFaces: Face[];
+    addedEdges: Edge[];
+    modifiedEdges: ShapeHistoryRecord<Edge>[];
+    generatedEdges: ShapeHistoryRecord<Edge>[];
+    removedEdges: Edge[];
+};
+export declare class ShapeHistoryTracker {
+    /**
+     * Remap a list of pre-operation faces through a `ShapeHistory`'s
+     * modifications. For each input face:
+     *   - If it appears as a source in `modifiedFaces`, emit the corresponding
+     *     result faces (1:N).
+     *   - Otherwise, pass it through unchanged (it survived the operation with
+     *     the same TShape pointer).
+     *
+     * Use this to keep classification arrays (start/end/side/…) valid after a
+     * fusion has modified some of their faces.
+     */
+    static remapFaces(faces: Face[], history: ShapeHistory): Face[];
+    static remapEdges(edges: Edge[], history: ShapeHistory): Edge[];
+    /**
+     * Collect history for `inputs` against `maker`'s output. When `opts.skipAdded`
+     * is set, the added* fields come back empty — callers that compute additions
+     * themselves (e.g. `recordFusionHistory` aggregates across all scene shapes)
+     * skip the per-call output traversal and per-result claimed-map updates.
+     */
+    static collect(maker: BRepBuilderAPI_MakeShape, inputs: Shape[], opts?: {
+        skipAdded?: boolean;
+    }): ShapeHistory;
+    private static collectForType;
+}

package/lib/dist/common/shape-history-tracker.js

@@ -0,0 +1,128 @@
+import { getOC } from "../oc/init.js";
+import { Explorer } from "../oc/explorer.js";
+import { ShapeOps } from "../oc/shape-ops.js";
+import { Face } from "./face.js";
+import { Edge } from "./edge.js";
+export class ShapeHistoryTracker {
+    /**
+     * Remap a list of pre-operation faces through a `ShapeHistory`'s
+     * modifications. For each input face:
+     *   - If it appears as a source in `modifiedFaces`, emit the corresponding
+     *     result faces (1:N).
+     *   - Otherwise, pass it through unchanged (it survived the operation with
+     *     the same TShape pointer).
+     *
+     * Use this to keep classification arrays (start/end/side/…) valid after a
+     * fusion has modified some of their faces.
+     */
+    static remapFaces(faces, history) {
+        const result = [];
+        for (const face of faces) {
+            const record = history.modifiedFaces.find(m => m.sources.some(s => s.getShape().IsSame(face.getShape())));
+            if (record) {
+                result.push(...record.results);
+            }
+            else {
+                result.push(face);
+            }
+        }
+        return result;
+    }
+    static remapEdges(edges, history) {
+        const result = [];
+        for (const edge of edges) {
+            const record = history.modifiedEdges.find(m => m.sources.some(s => s.getShape().IsSame(edge.getShape())));
+            if (record) {
+                result.push(...record.results);
+            }
+            else {
+                result.push(edge);
+            }
+        }
+        return result;
+    }
+    /**
+     * Collect history for `inputs` against `maker`'s output. When `opts.skipAdded`
+     * is set, the added* fields come back empty — callers that compute additions
+     * themselves (e.g. `recordFusionHistory` aggregates across all scene shapes)
+     * skip the per-call output traversal and per-result claimed-map updates.
+     */
+    static collect(maker, inputs, opts = {}) {
+        const oc = getOC();
+        const FACE = oc.TopAbs_ShapeEnum.TopAbs_FACE;
+        const EDGE = oc.TopAbs_ShapeEnum.TopAbs_EDGE;
+        const skipAdded = opts.skipAdded === true;
+        const output = skipAdded ? null : maker.Shape();
+        const outputFaces = output ? Explorer.findShapes(output, FACE) : [];
+        const outputEdges = output ? Explorer.findShapes(output, EDGE) : [];
+        const faces = ShapeHistoryTracker.collectForType(maker, inputs, FACE, outputFaces, (raw) => Face.fromTopoDSFace(Explorer.toFace(raw)), skipAdded);
+        const edges = ShapeHistoryTracker.collectForType(maker, inputs, EDGE, outputEdges, (raw) => Edge.fromTopoDSEdge(Explorer.toEdge(raw)), skipAdded);
+        return {
+            addedFaces: faces.added,
+            modifiedFaces: faces.modified,
+            generatedFaces: faces.generated,
+            removedFaces: faces.removed,
+            addedEdges: edges.added,
+            modifiedEdges: edges.modified,
+            generatedEdges: edges.generated,
+            removedEdges: edges.removed,
+        };
+    }
+    static collectForType(maker, inputs, type, outputRaws, wrap, skipAdded) {
+        const oc = getOC();
+        const modified = [];
+        const generated = [];
+        const removed = [];
+        // Track which output raws are claimed by a Modified/Generated record so the
+        // remaining outputs can be reported as pure additions. When `skipAdded`,
+        // we don't compute additions, so skip the bookkeeping entirely.
+        const claimed = skipAdded ? null : new oc.TopTools_MapOfShape();
+        const isOfType = (raw) => raw.ShapeType() === type;
+        for (const input of inputs) {
+            const inputRaws = Explorer.findShapes(input.getShape(), type);
+            for (const inputRaw of inputRaws) {
+                const modifiedRaws = ShapeOps.shapeListToArray(maker.Modified(inputRaw)).filter(isOfType);
+                const generatedRaws = ShapeOps.shapeListToArray(maker.Generated(inputRaw)).filter(isOfType);
+                if (modifiedRaws.length > 0) {
+                    modified.push({
+                        sources: [wrap(inputRaw)],
+                        results: modifiedRaws.map(wrap),
+                    });
+                    if (claimed) {
+                        for (const r of modifiedRaws) {
+                            claimed.Add(r);
+                        }
+                    }
+                }
+                if (generatedRaws.length > 0) {
+                    generated.push({
+                        sources: [wrap(inputRaw)],
+                        results: generatedRaws.map(wrap),
+                    });
+                    if (claimed) {
+                        for (const r of generatedRaws) {
+                            claimed.Add(r);
+                        }
+                    }
+                }
+                // IsDeleted is only meaningful when the input has no successor. If
+                // Modified or Generated produced anything, that record already
+                // captures its fate — skip the (relatively expensive) IsDeleted call.
+                if (modifiedRaws.length === 0 && generatedRaws.length === 0
+                    && maker.IsDeleted(inputRaw)) {
+                    removed.push(wrap(inputRaw));
+                }
+            }
+        }
+        const added = [];
+        if (claimed) {
+            for (const raw of outputRaws) {
+                if (!claimed.Contains(raw)) {
+                    added.push(wrap(raw));
+                }
+            }
+            claimed.delete();
+        }
+        return { added, modified, generated, removed };
+    }
+}

package/lib/dist/common/shape.js

@@ -87,7 +87,13 @@ export class Shape {
         if (this.isVertex()) {
             throw new Error("Cannot set color on vertex shape");
         }
-        this.colorMap.push({ shape: face, color });
+        const existing = this.colorMap.findIndex(c => c.shape.IsSame(face));
+        if (existing >= 0) {
+            this.colorMap[existing] = { shape: face, color };
+        }
+        else {
+            this.colorMap.push({ shape: face, color });
+        }
     }
     getColor(face) {
         const entry = this.colorMap.find(c => c.shape.IsSame(face));

package/lib/dist/common/solid.js

@@ -60,7 +60,11 @@ export class Solid extends Shape {
         return null;
     }
     copy() {
-        return new Solid(this.getShape());
+        const copied = new Solid(this.getShape());
+        for (const entry of this.colorMap) {
+            copied.colorMap.push({ shape: entry.shape, color: entry.color });
+        }
+        return copied;
     }
     static fromTopoDSSolid(solid) {
         return new Solid(solid);

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

@@ -10,19 +10,19 @@ interface ALineFunction {
     (length: number, angle: number, centered?: boolean): IGeometry;
     /**
      * Draws a line at the given angle on a specific plane.
+     * @param targetPlane - The plane to draw on
      * @param length - The line length
      * @param angle - The angle in degrees
-     * @param targetPlane - The plane to draw on
      */
-    (length: number, angle: number, targetPlane: PlaneLike | ISceneObject): IGeometry;
+    (targetPlane: PlaneLike | ISceneObject, length: number, angle: number): IGeometry;
     /**
      * Draws a centered line at the given angle on a specific plane.
+     * @param targetPlane - The plane to draw on
      * @param length - The line length
      * @param angle - The angle in degrees
      * @param centered - Whether to center the line on the current position
-     * @param targetPlane - The plane to draw on
      */
-    (length: number, angle: number, centered: boolean, targetPlane: PlaneLike | ISceneObject): IGeometry;
+    (targetPlane: PlaneLike | ISceneObject, length: number, angle: number, centered: boolean): IGeometry;
 }
 declare const _default: ALineFunction;
 export default _default;

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

@@ -6,18 +6,22 @@ import { resolvePlane } from "../../helpers/resolve.js";
 function build(context) {
     return function line() {
         let planeObj = null;
-        let argCount = arguments.length;
-        // Detect plane as last argument
-        if (argCount > 0) {
-            const lastArg = arguments[argCount - 1];
-            if (isPlaneLike(lastArg) || lastArg instanceof SceneObject) {
-                planeObj = resolvePlane(lastArg, context);
-                argCount--;
+        let argOffset = 0;
+        // Detect plane as first argument (only valid outside a sketch)
+        if (arguments.length > 0) {
+            const firstArg = arguments[0];
+            if (isPlaneLike(firstArg) || firstArg instanceof SceneObject) {
+                if (context.getActiveSketch() !== null) {
+                    throw new Error("aLine(plane, ...) cannot be used inside a sketch. Use aLine(...) instead.");
+                }
+                planeObj = resolvePlane(firstArg, context);
+                argOffset = 1;
             }
         }
-        const length = arguments[0];
-        const angle = arguments[1];
-        const centered = argCount >= 3 ? arguments[2] : false;
+        const argCount = arguments.length - argOffset;
+        const length = arguments[argOffset];
+        const angle = arguments[argOffset + 1];
+        const centered = argCount >= 3 ? arguments[argOffset + 2] : false;
         const aline = new AngledLine(length, angle, centered, planeObj);
         context.addSceneObject(aline);
         return aline;

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

@@ -26,25 +26,25 @@ interface ArcFunction {
     (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
+     * @param endPoint - The end point of the arc
      */
-    (endPoint: Point2DLike, targetPlane: PlaneLike | ISceneObject): IArcPoints;
+    (targetPlane: PlaneLike | ISceneObject, endPoint: Point2DLike): IArcPoints;
     /**
      * Draws an arc between two points on a specific plane.
+     * @param targetPlane - The plane to draw on
      * @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): IArcPoints;
+    (targetPlane: PlaneLike | ISceneObject, startPoint: Point2DLike, endPoint: Point2DLike): IArcPoints;
     /**
      * Draws an arc by radius and angle range on a specific plane.
+     * @param targetPlane - The plane to draw on
      * @param radius - The arc radius
      * @param startAngle - The start angle in degrees
      * @param endAngle - The end angle in degrees
-     * @param targetPlane - The plane to draw on
      */
-    (radius: number, startAngle: number, endAngle: number, targetPlane: PlaneLike | ISceneObject): IArcAngles;
+    (targetPlane: PlaneLike | ISceneObject, radius: number, startAngle: number, endAngle: number): IArcAngles;
 }
 declare const _default: ArcFunction;
 export default _default;

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

@@ -8,34 +8,38 @@ import { resolvePlane } from "../../helpers/resolve.js";
 function build(context) {
     return function arc() {
         let planeObj = null;
-        let argCount = arguments.length;
-        // Detect plane as last argument
-        if (argCount > 0) {
-            const lastArg = arguments[argCount - 1];
-            if (isPlaneLike(lastArg) || (lastArg instanceof SceneObject && !isPoint2DLike(lastArg))) {
-                planeObj = resolvePlane(lastArg, context);
-                argCount--;
+        let argOffset = 0;
+        // Detect plane as first argument (only valid outside a sketch)
+        if (arguments.length > 0) {
+            const firstArg = arguments[0];
+            if (isPlaneLike(firstArg) || (firstArg instanceof SceneObject && !isPoint2DLike(firstArg))) {
+                if (context.getActiveSketch() !== null) {
+                    throw new Error("arc(plane, ...) cannot be used inside a sketch. Use arc(...) instead.");
+                }
+                planeObj = resolvePlane(firstArg, context);
+                argOffset = 1;
             }
         }
+        const argCount = arguments.length - argOffset;
         // (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]);
+        if (argCount >= 2 && isPoint2DLike(arguments[argOffset]) && isPoint2DLike(arguments[argOffset + 1])) {
+            const start = normalizePoint2D(arguments[argOffset]);
+            const end = normalizePoint2D(arguments[argOffset + 1]);
             const arcObj = Arc.twoPoints(start, end, planeObj);
             context.addSceneObject(arcObj);
             return arcObj;
         }
         // (endPoint) — single Point2DLike arg
-        if (isPoint2DLike(arguments[0])) {
-            const end = normalizePoint2D(arguments[0]);
+        if (isPoint2DLike(arguments[argOffset])) {
+            const end = normalizePoint2D(arguments[argOffset]);
             const arcObj = Arc.toPoint(end, planeObj);
             context.addSceneObject(arcObj);
             return arcObj;
         }
         // (radius, startAngle?, endAngle?) — all numeric args
-        const radius = arguments[0] || 100;
-        const startAngle = arguments[1] || 0;
-        const endAngle = argCount >= 3 ? arguments[2] : 180;
+        const radius = arguments[argOffset] || 100;
+        const startAngle = arguments[argOffset + 1] || 0;
+        const endAngle = argCount >= 3 ? arguments[argOffset + 2] : 180;
         const arcObj = Arc.fromAngles(radius, startAngle, endAngle, planeObj);
         context.addSceneObject(arcObj);
         return arcObj;

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

@@ -15,10 +15,10 @@ interface CircleFunction {
     (diameter?: number): IExtrudableGeometry;
     /**
      * Draws a circle with a given diameter on a specific plane.
-     * @param diameter - The circle diameter
      * @param targetPlane - The plane to draw on
+     * @param diameter - The circle diameter
      */
-    (diameter: number, targetPlane: PlaneLike | ISceneObject): IExtrudableGeometry;
+    (targetPlane: PlaneLike | ISceneObject, diameter: number): IExtrudableGeometry;
 }
 declare const _default: CircleFunction;
 export default _default;