fluidcad 0.0.2

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

@@ -0,0 +1,74 @@
+import { isPoint2DLike } from "../../math/point.js";
+import { Move } from "../../features/2d/move.js";
+import { Rect } from "../../features/2d/rect.js";
+import { normalizePoint2D } from "../../helpers/normalize.js";
+import { registerBuilder } from "../../index.js";
+import { isPlaneLike } from "../../math/plane.js";
+import { SceneObject } from "../../common/scene-object.js";
+import { resolvePlane } from "../../helpers/resolve.js";
+function build(context) {
+    return function cRect() {
+        let width;
+        let height;
+        let options;
+        let start;
+        let rect;
+        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--;
+            }
+        }
+        if (argCount === 1) {
+            width = arguments[0];
+            height = width;
+            rect = new Rect(width, height, true, options, planeObj);
+            context.addSceneObject(rect);
+        }
+        else if (argCount === 2) {
+            if (typeof arguments[0] === 'number') {
+                width = arguments[0];
+                height = arguments[1];
+                rect = new Rect(width, height, true, options, planeObj);
+                context.addSceneObject(rect);
+            }
+            else {
+                start = normalizePoint2D(arguments[0]);
+                width = arguments[1];
+                height = width;
+                rect = new Rect(width, height, true, options, planeObj);
+                context.addSceneObjects([new Move(start), rect]);
+            }
+        }
+        else if (argCount === 3) {
+            if (typeof arguments[0] === 'number') {
+                width = arguments[0];
+                height = arguments[1];
+                options = arguments[2];
+                rect = new Rect(width, height, true, options, planeObj);
+                context.addSceneObject(rect);
+            }
+            else {
+                start = normalizePoint2D(arguments[0]);
+                width = arguments[1];
+                height = arguments[2];
+                rect = new Rect(width, height, true, options, planeObj);
+                context.addSceneObjects([new Move(start), rect]);
+            }
+        }
+        else if (argCount === 4) {
+            start = normalizePoint2D(arguments[0]);
+            width = arguments[1];
+            height = arguments[2];
+            options = arguments[3];
+            rect = new Rect(width, height, true, options, planeObj);
+            context.addSceneObjects([new Move(start), rect]);
+        }
+        return rect;
+    };
+}
+export default registerBuilder(build);

package/lib/dist/core/2d/face-driller.d.ts

@@ -0,0 +1,8 @@
+import { FaceInfo } from "../../helpers/types.js";
+export declare class FaceDriller {
+    private faceInfos;
+    constructor(faceInfos: FaceInfo[]);
+    drillHoles(): FaceInfo[];
+    private wireIsInsideFace;
+    private getFaceHoles;
+}

package/lib/dist/core/2d/face-driller.js

@@ -0,0 +1,70 @@
+import { FaceOps } from "../../oc/face-ops.js";
+export class FaceDriller {
+    faceInfos;
+    constructor(faceInfos) {
+        this.faceInfos = faceInfos;
+    }
+    drillHoles() {
+        const foundHoles = [];
+        let drilledFaces = [];
+        for (const faceInfo of this.faceInfos) {
+            if (foundHoles.includes(faceInfo)) {
+                continue;
+            }
+            const faceHoles = this.getFaceHoles(faceInfo, foundHoles);
+            console.log("Found holes for face:", faceHoles.length);
+            if (faceHoles.length === 0) {
+                drilledFaces.push(faceInfo);
+                continue;
+            }
+            faceInfo.holes = faceHoles;
+            drilledFaces.push(faceInfo);
+            for (const hole of faceHoles) {
+                foundHoles.push(hole);
+            }
+        }
+        console.log("Found holes:", foundHoles.length);
+        console.log("Drilled faces before removing holes:", drilledFaces.length);
+        // remove face infos that are in foundHoles
+        drilledFaces = drilledFaces.filter(info => !foundHoles.includes(info));
+        console.log("Drilled faces:", drilledFaces.length);
+        for (const info of drilledFaces) {
+            const holes = info.holes;
+            if (!holes?.length) {
+                continue;
+            }
+            const holeWires = [];
+            for (const hole of holes) {
+                hole.wire.getShape().Reverse();
+                holeWires.push(hole.wire);
+            }
+            const newFace = FaceOps.makeFaceWithHoles(info.wire, holeWires);
+            info.face = newFace;
+            for (const hole of holes) {
+                hole.wire.dispose();
+                hole.face.dispose();
+            }
+            info.holes = [];
+        }
+        return drilledFaces;
+    }
+    wireIsInsideFace(inner, outer) {
+        const firstPoint = inner.wire.getFirstVertex().toPoint();
+        if (!firstPoint) {
+            return false;
+        }
+        return FaceOps.isPointInsideFace(firstPoint, outer.face);
+    }
+    getFaceHoles(faceInfo, exclude) {
+        const holes = [];
+        for (let fInfo of this.faceInfos) {
+            if (fInfo === faceInfo || exclude.includes(faceInfo)) {
+                continue;
+            }
+            if (this.wireIsInsideFace(fInfo, faceInfo)) {
+                holes.push(fInfo);
+            }
+        }
+        return holes;
+    }
+}

package/lib/dist/core/2d/face-maker.d.ts

@@ -0,0 +1,13 @@
+import { Wire } from "../../common/wire.js";
+import { Plane } from "../../math/plane.js";
+import { Face } from "../../common/face.js";
+import { Edge } from "../../common/edge.js";
+export declare class FaceMaker {
+    static getFaces(shapes: Array<Wire | Edge>, plane: Plane): Face[];
+    static unifyWires(shapes: (Wire | Edge)[]): Wire[];
+    private static createFacesFromWires;
+    private static fuseIntersectingFaces;
+    private static boundingBoxesIntersect;
+    private static getFaceInfos;
+    private static getWiresFromFaces;
+}

package/lib/dist/core/2d/face-maker.js

@@ -0,0 +1,119 @@
+import { FaceDriller } from "./face-driller.js";
+import { Wire } from "../../common/wire.js";
+import { FaceOps } from "../../oc/face-ops.js";
+import { Explorer } from "../../oc/explorer.js";
+import { ShapeOps } from "../../oc/shape-ops.js";
+import { Edge } from "../../common/edge.js";
+import { WireOps } from "../../oc/wire-ops.js";
+export class FaceMaker {
+    static getFaces(shapes, plane) {
+        const wires = this.unifyWires(shapes);
+        let faces = this.createFacesFromWires(wires, plane);
+        console.log("====== Faces before fuse:", faces.length);
+        faces = this.fuseIntersectingFaces(faces);
+        console.log("====== Faces after fuse:", faces.length);
+        const newWires = this.getWiresFromFaces(faces);
+        let faceInfo = this.getFaceInfos(faces, newWires);
+        const faceDriller = new FaceDriller(faceInfo);
+        faceInfo = faceDriller.drillHoles();
+        console.log("====== Faces after drilling holes:", faceInfo.length);
+        return faceInfo.map(info => info.face);
+    }
+    static unifyWires(shapes) {
+        const wires = [];
+        for (let shape of shapes) {
+            if (shape instanceof Wire) {
+                wires.push(shape);
+            }
+            else if (shape instanceof Edge) {
+                const wire = WireOps.makeWireFromEdges([shape]);
+                wires.push(wire);
+            }
+        }
+        return wires;
+    }
+    static createFacesFromWires(wires, plane) {
+        if (wires.length === 0)
+            return [];
+        console.log("Creating faces from wires:", wires.length);
+        const faces = [];
+        for (let wire of wires) {
+            const face = FaceOps.makeFaceOnPlaneWrapped(wire, plane);
+            const fixedFace = FaceOps.fixFaceOrientation(face);
+            faces.push(fixedFace);
+        }
+        return faces;
+    }
+    static fuseIntersectingFaces(faces) {
+        if (faces.length === 0)
+            return [];
+        if (faces.length === 1)
+            return faces;
+        // Pre-compute bounding boxes for all faces
+        const faceBoxes = faces.map((face, index) => ({
+            face,
+            index,
+            bbox: ShapeOps.getBoundingBox(face)
+        }));
+        const result = [];
+        const processedFaces = new Set();
+        for (let i = 0; i < faces.length; i++) {
+            const face1 = faces[i];
+            if (processedFaces.has(face1)) {
+                continue;
+            }
+            let fusedFace = face1;
+            const facesToFuse = [face1];
+            let bbox1 = faceBoxes[i].bbox;
+            // Find all faces that intersect with face1 using bounding box pre-filtering
+            for (let j = i + 1; j < faces.length; j++) {
+                const face2 = faces[j];
+                if (processedFaces.has(face2)) {
+                    continue;
+                }
+                const bbox2 = faceBoxes[j].bbox;
+                // Quick bounding box intersection test before expensive geometric operations
+                if (!this.boundingBoxesIntersect(bbox1, bbox2)) {
+                    continue;
+                }
+                const newFusedFace = FaceOps.fuseFacesAndUnify(fusedFace, face2);
+                if (newFusedFace) {
+                    fusedFace = newFusedFace;
+                    bbox1 = ShapeOps.getBoundingBox(fusedFace);
+                    facesToFuse.push(face2);
+                }
+            }
+            // Add the final fused face to results
+            result.push(fusedFace);
+            // Mark all processed faces
+            facesToFuse.forEach(face => processedFaces.add(face));
+        }
+        console.log("Fused faces count:", result.length);
+        return result;
+    }
+    static boundingBoxesIntersect(bbox1, bbox2) {
+        return !(bbox1.maxX < bbox2.minX || bbox2.maxX < bbox1.minX ||
+            bbox1.maxY < bbox2.minY || bbox2.maxY < bbox1.minY);
+    }
+    static getFaceInfos(faces, facesWires) {
+        const faceInfos = faces.map((face, index) => {
+            const bbox = ShapeOps.getBoundingBox(face);
+            const diagonal = Math.sqrt(Math.pow(bbox.maxX - bbox.minX, 2) + Math.pow(bbox.maxY - bbox.minY, 2));
+            return { face, wire: facesWires[index], bbox, diagonal };
+        });
+        // Sort by diagonal size (largest first for better hole containment logic)
+        faceInfos.sort((a, b) => b.diagonal - a.diagonal);
+        return faceInfos;
+    }
+    static getWiresFromFaces(faces) {
+        const wires = [];
+        for (let face of faces) {
+            const faceWires = Explorer.findWiresWrapped(face);
+            console.log("Found wires in face:", faceWires.length);
+            for (const wire of faceWires) {
+                wires.push(wire);
+            }
+        }
+        return wires;
+    }
+}

package/lib/dist/core/2d/face-maker2.d.ts

@@ -0,0 +1,6 @@
+import { Wire } from "../../common/wire.js";
+import { Plane } from "../../math/plane.js";
+import { Edge } from "../../common/edge.js";
+export declare class FaceMaker2 {
+    static getFaces(shapes: Array<Wire | Edge>, plane: Plane, drill?: boolean): void;
+}

package/lib/dist/core/2d/face-maker2.js

@@ -0,0 +1,54 @@
+import { Face } from "../../common/face.js";
+import { Explorer } from "../../oc/explorer.js";
+export class FaceMaker2 {
+    static getFaces(shapes, plane, drill = true) {
+        const cellsBuilder = new oc.BOPAlgo_CellsBuilder();
+        const argsList = new oc.TopTools_ListOfShape();
+        for (const face of sketchShapes) {
+            argsList.Append(face.getShape());
+        }
+        cellsBuilder.SetArguments(argsList);
+        cellsBuilder.SetNonDestructive(true);
+        const progress = new oc.Message_ProgressRange();
+        cellsBuilder.Perform(progress);
+        if (cellsBuilder.HasErrors()) {
+            console.error('CellsBuilder: Perform() reported errors');
+            cellsBuilder.delete();
+            argsList.delete();
+            progress.delete();
+            throw new Error('Failed to partition sketch faces for pick mode');
+            // cells = sketchFaces;
+        }
+        else {
+            cellsBuilder.AddAllToResult(0, false);
+            // cellsBuilder.MakeContainers();
+            // cellsBuilder.Perform(new oc.Message_ProgressRange());
+            const allParts = cellsBuilder.GetAllParts();
+            console.log('CellsBuilder: GetAllParts count:', allParts.NbChildren());
+            const [gpPln, dispose] = Convert.toGpPln(plane);
+            const planeFace = new oc.BRepBuilderAPI_MakeFace(gpPln, -10000, 10000, -10000, 10000).Face();
+            // 3. Split the face using the edges as tools
+            const splitter = new oc.BRepAlgoAPI_Splitter();
+            const objects = new oc.TopTools_ListOfShape();
+            objects.Append(planeFace);
+            splitter.SetArguments(objects);
+            // Add each split edge as a tool
+            const tools = Explorer.findShapes(allParts, oc.TopAbs_ShapeEnum.TopAbs_EDGE).map(e => oc.TopoDS.Edge(e));
+            const toolsList = new oc.TopTools_ListOfShape();
+            for (const t of tools) {
+                toolsList.Append(t);
+            }
+            splitter.SetTools(toolsList);
+            splitter.SetNonDestructive(true);
+            splitter.SetCheckInverted(true);
+            splitter.Build(new oc.Message_ProgressRange());
+            splitter.SimplifyResult(false, false, oc.Precision.Angular());
+            const result = splitter.Shape();
+            const areas = Explorer.findShapes(result, oc.TopAbs_ShapeEnum.TopAbs_FACE);
+            cells = areas.map(f => {
+                console.log('Converting cell face from OC shape', Explorer.getShapeType(f));
+                return Face.fromTopoDSFace(oc.TopoDS.Face(f));
+            });
+        }
+    }
+}

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

@@ -0,0 +1,33 @@
+import { Point2DLike } from "../../math/point.js";
+import { PlaneLike } from "../../math/plane.js";
+import { IGeometry, ISceneObject } from "../interfaces.js";
+interface HLineFunction {
+    /**
+     * Draws a horizontal line of the given distance.
+     * @param distance - The line length
+     * @param centered - Whether to center the line on the current position
+     */
+    (distance: number, centered?: boolean): IGeometry;
+    /**
+     * Draws a horizontal line from a start point.
+     * @param start - The start point
+     * @param distance - The line length
+     * @param centered - Whether to center the line on the start point
+     */
+    (start: Point2DLike, distance: number, centered?: boolean): IGeometry;
+    /**
+     * Draws a horizontal line on a specific plane.
+     * @param distance - The line length
+     * @param targetPlane - The plane to draw on
+     */
+    (distance: number, targetPlane: PlaneLike | ISceneObject): IGeometry;
+    /**
+     * Draws a horizontal line with centering on a specific plane.
+     * @param distance - The line length
+     * @param centered - Whether to center the line on the current position
+     * @param targetPlane - The plane to draw on
+     */
+    (distance: number, centered: boolean, targetPlane: PlaneLike | ISceneObject): IGeometry;
+}
+declare const _default: HLineFunction;
+export default _default;

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

@@ -0,0 +1,37 @@
+import { isPoint2DLike } from "../../math/point.js";
+import { Move } from "../../features/2d/move.js";
+import { HorizontalLine } from "../../features/2d/hline.js";
+import { normalizePoint2D } from "../../helpers/normalize.js";
+import { registerBuilder } from "../../index.js";
+import { isPlaneLike } from "../../math/plane.js";
+import { SceneObject } from "../../common/scene-object.js";
+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 && !isPoint2DLike(lastArg))) {
+                planeObj = resolvePlane(lastArg, context);
+                argCount--;
+            }
+        }
+        if (typeof arguments[0] !== 'number') {
+            // hline(start, distance) or hline(start, distance, centered)
+            const start = normalizePoint2D(arguments[0]);
+            const distance = arguments[1];
+            const centered = argCount >= 3 ? arguments[2] : false;
+            const hline = new HorizontalLine(distance, centered, planeObj);
+            context.addSceneObjects([new Move(start), hline]);
+            return hline;
+        }
+        const distance = arguments[0];
+        const centered = argCount >= 2 ? arguments[1] : false;
+        const hline = new HorizontalLine(distance, centered, planeObj);
+        context.addSceneObject(hline);
+        return hline;
+    };
+}
+export default registerBuilder(build);

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

@@ -0,0 +1,9 @@
+interface HMoveFunction {
+    /**
+     * Moves the cursor horizontally by the given distance.
+     * @param distance - The horizontal distance to move
+     */
+    (distance: number): void;
+}
+declare const _default: HMoveFunction;
+export default _default;

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

@@ -0,0 +1,11 @@
+import { HMove } from "../../features/2d/hmove.js";
+import { registerBuilder } from "../../index.js";
+function build(context) {
+    return function move() {
+        const distance = arguments[0];
+        const hmove = new HMove(distance);
+        context.addSceneObject(hmove);
+        return hmove;
+    };
+}
+export default registerBuilder(build);

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

@@ -0,0 +1,22 @@
+export { default as line } from './line.js';
+export { default as circle } from './circle.js';
+export { default as rect } from './rect.js';
+export { default as hMove } from './hmove.js';
+export { default as vMove } from './vmove.js';
+export { default as rMove } from './rmove.js';
+export { default as hLine } from './hline.js';
+export { default as vLine } from './vline.js';
+export { default as tLine } from './tline.js';
+export { default as tCircle } from './tcircle.js';
+export { default as tArc } from './tarc.js';
+export { default as arc } from './arc.js';
+export { default as move } from './move.js';
+export { default as pMove } from './pmove.js';
+export { default as aLine } from './aline.js';
+export { default as wire } from './wire.js';
+export { default as slot } from './slot.js';
+export { default as connect } from './connect.js';
+export { default as polygon } from './polygon.js';
+export { default as offset } from './offset.js';
+export { default as project } from './project.js';
+export { default as bezier } from './bezier.js';

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

@@ -0,0 +1,22 @@
+export { default as line } from './line.js';
+export { default as circle } from './circle.js';
+export { default as rect } from './rect.js';
+export { default as hMove } from './hmove.js';
+export { default as vMove } from './vmove.js';
+export { default as rMove } from './rmove.js';
+export { default as hLine } from './hline.js';
+export { default as vLine } from './vline.js';
+export { default as tLine } from './tline.js';
+export { default as tCircle } from './tcircle.js';
+export { default as tArc } from './tarc.js';
+export { default as arc } from './arc.js';
+export { default as move } from './move.js';
+export { default as pMove } from './pmove.js';
+export { default as aLine } from './aline.js';
+export { default as wire } from './wire.js';
+export { default as slot } from './slot.js';
+export { default as connect } from './connect.js';
+export { default as polygon } from './polygon.js';
+export { default as offset } from './offset.js';
+export { default as project } from './project.js';
+export { default as bezier } from './bezier.js';

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

@@ -0,0 +1,24 @@
+import { Point2DLike } from "../../math/point.js";
+import { PlaneLike } from "../../math/plane.js";
+import { IGeometry, ISceneObject } from "../interfaces.js";
+interface LineFunction {
+    /**
+     * Draws a line from the current position to the given point.
+     * @param end - The end point
+     */
+    (end: Point2DLike): IGeometry;
+    /**
+     * Draws a line between two points.
+     * @param start - The start point
+     * @param end - The end point
+     */
+    (start: Point2DLike, end: Point2DLike): IGeometry;
+    /**
+     * Draws a line to the given point on a specific plane.
+     * @param end - The end point
+     * @param targetPlane - The plane to draw on
+     */
+    (end: Point2DLike, targetPlane: PlaneLike | ISceneObject): IGeometry;
+}
+declare const _default: LineFunction;
+export default _default;

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

@@ -0,0 +1,40 @@
+import { isPoint2DLike } from "../../math/point.js";
+import { LineTo } from "../../features/2d/line.js";
+import { Move } from "../../features/2d/move.js";
+import { normalizePoint2D } from "../../helpers/normalize.js";
+import { registerBuilder } from "../../index.js";
+import { isPlaneLike } from "../../math/plane.js";
+import { SceneObject } from "../../common/scene-object.js";
+import { resolvePlane } from "../../helpers/resolve.js";
+function build(context) {
+    return function line() {
+        let line;
+        let planeObj = null;
+        let argCount = arguments.length;
+        // Detect plane as last argument
+        // Point2DLike is not plane-like so no conflict
+        if (argCount > 0) {
+            const lastArg = arguments[argCount - 1];
+            if (isPlaneLike(lastArg) || (lastArg instanceof SceneObject && !isPoint2DLike(lastArg))) {
+                planeObj = resolvePlane(lastArg, context);
+                argCount--;
+            }
+        }
+        if (argCount === 1) {
+            const vertex = normalizePoint2D(arguments[0]);
+            line = new LineTo(vertex, planeObj);
+            context.addSceneObject(line);
+        }
+        else if (argCount === 2) {
+            const start = normalizePoint2D(arguments[0]);
+            const end = normalizePoint2D(arguments[1]);
+            line = new LineTo(end, planeObj);
+            context.addSceneObjects([new Move(start), line]);
+        }
+        else {
+            throw new Error(`Invalid number of arguments for line(): ${argCount}`);
+        }
+        return line;
+    };
+}
+export default registerBuilder(build);

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

@@ -0,0 +1,13 @@
+import { Point2DLike } from "../../math/point.js";
+import { IGeometry } from "../interfaces.js";
+interface MoveFunction {
+    /** Moves the cursor to the origin. */
+    (): IGeometry;
+    /**
+     * Moves the cursor to the given point.
+     * @param to - The target point
+     */
+    (to: Point2DLike): IGeometry;
+}
+declare const _default: MoveFunction;
+export default _default;

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

@@ -0,0 +1,13 @@
+import { Point2D } from "../../math/point.js";
+import { Move } from "../../features/2d/move.js";
+import { normalizePoint2D } from "../../helpers/normalize.js";
+import { registerBuilder } from "../../index.js";
+function build(context) {
+    return function move() {
+        const to = normalizePoint2D(arguments[0] ?? new Point2D(0, 0));
+        const move = new Move(to);
+        context.addSceneObject(move);
+        return move;
+    };
+}
+export default registerBuilder(build);

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

@@ -0,0 +1,21 @@
+import { PlaneLike } from "../../math/plane.js";
+import { IExtrudableGeometry, ISceneObject } from "../interfaces.js";
+import { Extrudable } from "../../helpers/types.js";
+interface OffsetFunction {
+    /**
+     * Offsets the current sketch geometry by the given distance.
+     * @param distance - The offset distance (defaults to 1)
+     * @param removeOriginal - Whether to remove the original geometry
+     */
+    (distance?: number, removeOriginal?: boolean): IExtrudableGeometry;
+    /**
+     * Offsets source geometries onto a target plane.
+     * @param distance - The offset distance
+     * @param removeOriginal - Whether to remove the original geometry
+     * @param targetPlane - The plane to offset onto
+     * @param sourceGeometries - The geometries to offset
+     */
+    (distance: number, removeOriginal: boolean, targetPlane: PlaneLike | ISceneObject, ...sourceGeometries: Extrudable[]): IExtrudableGeometry;
+}
+declare const _default: OffsetFunction;
+export default _default;

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

@@ -0,0 +1,24 @@
+import { Offset } from "../../features/2d/offset.js";
+import { registerBuilder } from "../../index.js";
+import { resolvePlane } from "../../helpers/resolve.js";
+function build(context) {
+    return function offset(...args) {
+        // Outside-sketch mode: offset(distance, removeOriginal, plane, ...sourceGeometries)
+        if (args.length >= 3 && !Array.isArray(args[0])) {
+            const distance = args[0] ?? 1;
+            const removeOriginal = args[1] ?? false;
+            const planeObj = resolvePlane(args[2], context);
+            const sourceObjects = args.slice(3);
+            const off = new Offset(distance, removeOriginal, sourceObjects, planeObj);
+            context.addSceneObject(off);
+            return off;
+        }
+        // In-sketch mode: offset(distance, removeOriginal)
+        const distance = args[0] ?? 1;
+        const removeOriginal = args[1] ?? false;
+        const off = new Offset(distance, removeOriginal);
+        context.addSceneObject(off);
+        return off;
+    };
+}
+export default registerBuilder(build);

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

@@ -0,0 +1,11 @@
+import { IGeometry } from "../interfaces.js";
+interface PolarMoveFunction {
+    /**
+     * Moves the cursor by polar coordinates.
+     * @param radius - The distance to move
+     * @param angle - The angle in degrees
+     */
+    (radius: number, angle: number): IGeometry;
+}
+declare const _default: PolarMoveFunction;
+export default _default;

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

@@ -0,0 +1,12 @@
+import { PolarMove } from "../../features/2d/pmove.js";
+import { registerBuilder } from "../../index.js";
+function build(context) {
+    return function pmove() {
+        const radius = arguments[0];
+        const angle = arguments[1] * Math.PI / 180;
+        const pmove = new PolarMove(radius, angle);
+        context.addSceneObject(pmove);
+        return pmove;
+    };
+}
+export default registerBuilder(build);