fluidcad 0.0.2

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

@@ -0,0 +1,17 @@
+import type { TopoDS_Vertex } from "occjs-wrapper";
+import { ShapeType } from "./shape-type.js";
+import { Shape } from "./shape.js";
+import { Point, Point2D } from "../math/point.js";
+export declare class Vertex extends Shape<TopoDS_Vertex> {
+    constructor(vertex: TopoDS_Vertex);
+    getType(): ShapeType;
+    isVertex(): boolean;
+    toPoint(): Point;
+    toPoint2D(): Point2D;
+    getSubShapes(): Shape[];
+    static fromTopoDSVertex(vertex: TopoDS_Vertex): Vertex;
+    static fromPoint(point: Point): Vertex;
+    static fromPoint2D(point: Point2D): Vertex;
+    compareTo(other: Vertex): boolean;
+    serialize(): {};
+}

package/lib/dist/common/vertex.js

@@ -0,0 +1,44 @@
+import { Shape } from "./shape.js";
+import { Point, Point2D } from "../math/point.js";
+import { VertexOps } from "../oc/vertex-ops.js";
+export class Vertex extends Shape {
+    constructor(vertex) {
+        super(vertex);
+    }
+    getType() {
+        return "vertex";
+    }
+    isVertex() {
+        return true;
+    }
+    toPoint() {
+        return VertexOps.toPointRaw(this.getShape());
+    }
+    toPoint2D() {
+        const pnt = this.toPoint();
+        return new Point2D(pnt.x, pnt.y);
+    }
+    getSubShapes() {
+        return [];
+    }
+    static fromTopoDSVertex(vertex) {
+        return new Vertex(vertex);
+    }
+    static fromPoint(point) {
+        const vertex = VertexOps.fromPointRaw(point);
+        return new Vertex(vertex);
+    }
+    static fromPoint2D(point) {
+        console.log("Creating vertex from point2D:", point);
+        return Vertex.fromPoint(new Point(point.x, point.y, 0));
+    }
+    compareTo(other) {
+        if (!(other instanceof Vertex)) {
+            return false;
+        }
+        return this.getShape().IsPartner(other.getShape());
+    }
+    serialize() {
+        return {};
+    }
+}

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

@@ -0,0 +1,22 @@
+import type { TopoDS_Wire } from "occjs-wrapper";
+import { ShapeType } from "./shape-type.js";
+import { Shape } from "./shape.js";
+import { Vector3d } from "../math/vector3d.js";
+import { Vertex } from "./vertex.js";
+import { Edge } from "./edge.js";
+export declare class Wire extends Shape<TopoDS_Wire> {
+    vertices: Vertex[] | null;
+    edges: Edge[] | null;
+    constructor(wire: TopoDS_Wire);
+    getType(): ShapeType;
+    isWire(): boolean;
+    isCW(normal: Vector3d): boolean;
+    getSubShapes(type: ShapeType): Shape[];
+    getEdges(): Edge[];
+    private static normalizeStartEdge;
+    getFirstVertex(): Vertex;
+    getLastVertex(): Vertex;
+    static fromTopoDSWire(wire: TopoDS_Wire): Wire;
+    isClosed(): boolean;
+    getVertices(): Vertex[];
+}

package/lib/dist/common/wire.js

@@ -0,0 +1,97 @@
+import { WireOps } from "../oc/wire-ops.js";
+import { Shape } from "./shape.js";
+import { Explorer } from "../oc/explorer.js";
+import { EdgeOps } from "../oc/edge-ops.js";
+export class Wire extends Shape {
+    vertices = null;
+    edges = null;
+    constructor(wire) {
+        super(wire);
+    }
+    getType() {
+        return "wire";
+    }
+    isWire() {
+        return true;
+    }
+    isCW(normal) {
+        return WireOps.isCW(this, normal);
+    }
+    getSubShapes(type) {
+        if (type === 'edge') {
+            return this.getEdges();
+        }
+        if (type === 'wire') {
+            return [this];
+        }
+        return [];
+    }
+    getEdges() {
+        if (this.edges) {
+            return this.edges;
+        }
+        // Use BRepTools_WireExplorer (via findEdgesInWireOrderWrapped) instead of
+        // TopExp_Explorer to get edges in wire-parametric order. TopExp_Explorer
+        // returns edges in topology-graph order which varies depending on how the
+        // shape was constructed (e.g. mirrored vs original extrusions).
+        let edges = Explorer.findEdgesInWireOrderWrapped(this);
+        // For closed wires, the starting edge from BRepTools_WireExplorer is still
+        // construction-dependent. Normalize by rotating to start from the edge with
+        // the lexicographically smallest midpoint, making indices geometry-based.
+        if (this.isClosed() && edges.length > 1) {
+            edges = Wire.normalizeStartEdge(edges);
+        }
+        this.edges = edges;
+        return this.edges;
+    }
+    // Rotates the edge list so it starts from the edge with the smallest midpoint
+    // (lexicographic x → y → z). This ensures consistent indexing regardless of
+    // how OCCT constructed the wire internally.
+    static normalizeStartEdge(edges) {
+        const eps = 1e-10;
+        let minIdx = 0;
+        let minMid = EdgeOps.getEdgeMidPoint(edges[0]);
+        for (let i = 1; i < edges.length; i++) {
+            const mid = EdgeOps.getEdgeMidPoint(edges[i]);
+            if (mid.x < minMid.x - eps
+                || (Math.abs(mid.x - minMid.x) < eps && mid.y < minMid.y - eps)
+                || (Math.abs(mid.x - minMid.x) < eps && Math.abs(mid.y - minMid.y) < eps && mid.z < minMid.z - eps)) {
+                minIdx = i;
+                minMid = mid;
+            }
+        }
+        if (minIdx === 0) {
+            return edges;
+        }
+        return [...edges.slice(minIdx), ...edges.slice(0, minIdx)];
+    }
+    getFirstVertex() {
+        const edges = this.getEdges();
+        if (edges.length === 0) {
+            return null;
+        }
+        const firstEdge = edges[0];
+        return firstEdge.getFirstVertex();
+    }
+    getLastVertex() {
+        const edges = this.getEdges();
+        if (edges.length === 0) {
+            return null;
+        }
+        const lastEdge = edges[edges.length - 1];
+        return lastEdge.getLastVertex();
+    }
+    static fromTopoDSWire(wire) {
+        return new Wire(wire);
+    }
+    isClosed() {
+        return this.getShape().Closed();
+    }
+    getVertices() {
+        if (this.vertices) {
+            return this.vertices;
+        }
+        this.vertices = Explorer.findVerticesWrapped(this);
+        return this.vertices;
+    }
+}

package/lib/dist/constraints/constraint.d.ts

@@ -0,0 +1,11 @@
+import { GccEnt_Position, gp_Pln } from "occjs-wrapper";
+import { Comparable, SceneObject } from "../common/scene-object.js";
+export type ConstraintQualifier = 'any' | 'outside' | 'enclosed' | 'enclosing';
+export declare class GeometricConstraint implements Comparable<GeometricConstraint> {
+    private object;
+    private qualifier;
+    constructor(object: SceneObject, qualifier: ConstraintQualifier);
+    getQualified(plane: gp_Pln): import("occjs-wrapper").GccEnt_QualifiedCirc | import("occjs-wrapper").GccEnt_QualifiedLin;
+    getQualifier(qualifier: ConstraintQualifier): GccEnt_Position;
+    compareTo(other: GeometricConstraint): boolean;
+}

package/lib/dist/constraints/constraint.js

@@ -0,0 +1,51 @@
+import { getOC } from "../load.js";
+import { Geometry } from "../oc/geometry.js";
+export class GeometricConstraint {
+    object;
+    qualifier;
+    constructor(object, qualifier) {
+        this.object = object;
+        this.qualifier = qualifier;
+    }
+    getQualified(plane) {
+        const oc = getOC();
+        const shape = this.object.getShapes()[0];
+        const adaptor = new oc.BRepAdaptor_Curve(shape.getShape());
+        const type = adaptor.GetType();
+        if (type === oc.GeomAbs_CurveType.GeomAbs_Circle) {
+            const circle = adaptor.Circle();
+            adaptor.delete();
+            const c1 = Geometry.get2dCircleRaw(plane, circle);
+            circle.delete();
+            const qualifier = this.getQualifier(this.qualifier);
+            const qualified = new oc.GccEnt_QualifiedCirc(c1, qualifier);
+            return qualified;
+        }
+        else if (type === oc.GeomAbs_CurveType.GeomAbs_Line) {
+            const line = adaptor.Line();
+            adaptor.delete();
+            const l1 = Geometry.get2dLineRaw(plane, line);
+            line.delete();
+            const qualifier = this.getQualifier(this.qualifier);
+            const qualified = new oc.GccEnt_QualifiedLin(l1, qualifier);
+            return qualified;
+        }
+        throw new Error('Unsupported shape type for constraint: ' + type);
+    }
+    getQualifier(qualifier) {
+        const oc = getOC();
+        switch (qualifier) {
+            case 'any':
+                return oc.GccEnt_Position.GccEnt_unqualified;
+            case 'enclosed':
+                return oc.GccEnt_Position.GccEnt_enclosed;
+            case 'enclosing':
+                return oc.GccEnt_Position.GccEnt_enclosing;
+            case 'outside':
+                return oc.GccEnt_Position.GccEnt_outside;
+        }
+    }
+    compareTo(other) {
+        return this.qualifier === other.qualifier && this.object.compareTo(other.object);
+    }
+}

package/lib/dist/constraints/outside.d.ts

@@ -0,0 +1,3 @@
+import { SceneObject } from "../common/scene-object.js";
+import { GeometricConstraint } from "./constraint.js";
+export declare function outside(sceneObject: SceneObject): GeometricConstraint;

package/lib/dist/constraints/outside.js

@@ -0,0 +1,4 @@
+import { GeometricConstraint } from "./constraint.js";
+export function outside(sceneObject) {
+    return new GeometricConstraint(sceneObject, 'outside');
+}

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

@@ -0,0 +1,28 @@
+import { PlaneLike } from "../../math/plane.js";
+import { IGeometry, ISceneObject } from "../interfaces.js";
+interface ALineFunction {
+    /**
+     * Draws a line at the given angle with the given length.
+     * @param length - The line length
+     * @param angle - The angle in degrees
+     * @param centered - Whether to center the line on the current position
+     */
+    (length: number, angle: number, centered?: boolean): IGeometry;
+    /**
+     * Draws a line at the given angle on a specific plane.
+     * @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;
+    /**
+     * Draws a centered line at the given angle on a specific plane.
+     * @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;
+}
+declare const _default: ALineFunction;
+export default _default;

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

@@ -0,0 +1,26 @@
+import { AngledLine } from "../../features/2d/aline.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) {
+                planeObj = resolvePlane(lastArg, context);
+                argCount--;
+            }
+        }
+        const length = arguments[0];
+        const angle = arguments[1];
+        const centered = argCount >= 3 ? arguments[2] : false;
+        const aline = new AngledLine(length, angle, centered, planeObj);
+        context.addSceneObject(aline);
+        return aline;
+    };
+}
+export default registerBuilder(build);

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

@@ -0,0 +1,77 @@
+import { Point2DLike } from "../../math/point.js";
+import { PlaneLike } from "../../math/plane.js";
+import { IGeometry, ISceneObject } from "../interfaces.js";
+interface ArcFunction {
+    /**
+     * Draws an arc to an end point with an optional bulge radius.
+     * @param endPoint - The end point of the arc
+     * @param radius - The bulge radius (0 = auto)
+     */
+    (endPoint: Point2DLike, radius?: number): IGeometry;
+    /**
+     * Draws an arc from a start point to an end point with an optional bulge radius.
+     * @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;
+    /**
+     * Draws an arc by radius and angle range.
+     * @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 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;
+    /**
+     * 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 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;
+    /**
+     * Draws an arc by radius and angle range on a specific plane.
+     * @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): IGeometry;
+}
+declare const _default: ArcFunction;
+export default _default;

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

@@ -0,0 +1,49 @@
+import { isPoint2DLike } from "../../math/point.js";
+import { ArcFromTwoAngles } from "../../features/2d/arc.js";
+import { ArcToPoint } from "../../features/2d/arc-to-point.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 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--;
+            }
+        }
+        // (startPoint, endPoint, radius?) — two Point2DLike args
+        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]);
+            return arcObj;
+        }
+        // (endPoint, radius?) — 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);
+            context.addSceneObject(arcObj);
+            return arcObj;
+        }
+        // (radius, startAngle, endAngle?, centered?) — 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);
+        context.addSceneObject(arcObj);
+        return arcObj;
+    };
+}
+export default registerBuilder(build);

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

@@ -0,0 +1,12 @@
+import { Point2DLike } from "../../math/point.js";
+import { Slot } from "../../features/2d/slot.js";
+import { PlaneLike } from "../../math/plane.js";
+import { SceneObject } from "../../common/scene-object.js";
+interface ASlotFunction {
+    (distance: number, radius: number, angle: number, centered?: boolean): Slot;
+    (start: Point2DLike, distance: number, radius: number, angle: number): Slot;
+    (distance: number, radius: number, angle: number, targetPlane: PlaneLike | SceneObject): Slot;
+    (distance: number, radius: number, angle: number, centered: boolean, targetPlane: PlaneLike | SceneObject): Slot;
+}
+declare const _default: ASlotFunction;
+export default _default;

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

@@ -0,0 +1,40 @@
+import { isPoint2DLike } from "../../math/point.js";
+import { Move } from "../../features/2d/move.js";
+import { Slot } from "../../features/2d/slot.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 aSlot() {
+        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') {
+            // aslot(start, distance, radius, angle)
+            const start = normalizePoint2D(arguments[0]);
+            const distance = arguments[1];
+            const radius = arguments[2];
+            const angle = arguments[3];
+            const s = new Slot(distance, radius, false, angle, planeObj);
+            context.addSceneObjects([new Move(start), s]);
+            return s;
+        }
+        const distance = arguments[0];
+        const radius = arguments[1];
+        const angle = arguments[2];
+        const centered = argCount === 4 ? arguments[3] : false;
+        const s = new Slot(distance, radius, centered, angle, planeObj);
+        context.addSceneObject(s);
+        return s;
+    };
+}
+export default registerBuilder(build);

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

@@ -0,0 +1,16 @@
+import { Point2DLike } from "../../math/point.js";
+import { IGeometry } from "../interfaces.js";
+interface BezierFunction {
+    /**
+     * Draws a bezier curve from the current position through control points to the end point.
+     * The last argument is the endpoint; all preceding arguments are control points.
+     * With 0 args: interactive mode placeholder (no geometry).
+     * With 1 arg: degree 1 (line).
+     * With 2 args: degree 2 (quadratic bezier).
+     * With 3 args: degree 3 (cubic bezier).
+     * @param points - Control points and end point
+     */
+    (...points: Point2DLike[]): IGeometry;
+}
+declare const _default: BezierFunction;
+export default _default;

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

@@ -0,0 +1,15 @@
+import { BezierCurve } from "../../features/2d/bezier.js";
+import { normalizePoint2D } from "../../helpers/normalize.js";
+import { registerBuilder } from "../../index.js";
+function build(context) {
+    return function bezier() {
+        const controlPoints = [];
+        for (let i = 0; i < arguments.length; i++) {
+            controlPoints.push(normalizePoint2D(arguments[i]));
+        }
+        const curve = new BezierCurve(controlPoints);
+        context.addSceneObject(curve);
+        return curve;
+    };
+}
+export default registerBuilder(build);

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

@@ -0,0 +1,24 @@
+import { Point2DLike } from "../../math/point.js";
+import { PlaneLike } from "../../math/plane.js";
+import { IExtrudableGeometry, ISceneObject } from "../interfaces.js";
+interface CircleFunction {
+    /**
+     * Draws a circle at a given center with an optional diameter.
+     * @param center - The center point
+     * @param diameter - The circle diameter (defaults to 40)
+     */
+    (center: Point2DLike, diameter?: number): IExtrudableGeometry;
+    /**
+     * Draws a circle at the origin with an optional diameter.
+     * @param diameter - The circle diameter (defaults to 40)
+     */
+    (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
+     */
+    (diameter: number, targetPlane: PlaneLike | ISceneObject): IExtrudableGeometry;
+}
+declare const _default: CircleFunction;
+export default _default;

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

@@ -0,0 +1,44 @@
+import { isPoint2DLike } from "../../math/point.js";
+import { Circle } from "../../features/2d/circle.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 circle() {
+        let diameter;
+        let center;
+        let circle;
+        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 === 0) {
+            diameter = 40;
+            circle = new Circle(diameter, null, planeObj);
+            context.addSceneObject(circle);
+        }
+        else if (argCount === 1) {
+            diameter = arguments[0] || 40;
+            circle = new Circle(diameter, null, planeObj);
+            context.addSceneObject(circle);
+        }
+        else {
+            center = normalizePoint2D(arguments[0]);
+            diameter = arguments[1] || 40;
+            circle = new Circle(diameter, null, planeObj);
+            const move = new Move(center);
+            context.addSceneObjects([move, circle]);
+        }
+        return circle;
+    };
+}
+export default registerBuilder(build);

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

@@ -0,0 +1,11 @@
+import { ConnectMode } from "../../features/2d/connect.js";
+import { IGeometry } from "../interfaces.js";
+interface ConnectFunction {
+    /**
+     * Connects the current position back to the start to close the sketch.
+     * @param mode - The connection mode
+     */
+    (mode?: ConnectMode): IGeometry;
+}
+declare const _default: ConnectFunction;
+export default _default;

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

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

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

@@ -0,0 +1,12 @@
+import { Point2DLike } from "../../math/point.js";
+import { Rect, RectOptions } from "../../features/2d/rect.js";
+import { PlaneLike } from "../../math/plane.js";
+import { SceneObject } from "../../common/scene-object.js";
+interface CRectFunction {
+    (width: number, height?: number, options?: RectOptions): Rect;
+    (start: Point2DLike, width: number, height?: number, options?: RectOptions): Rect;
+    (width: number, height: number, targetPlane: PlaneLike | SceneObject): Rect;
+    (width: number, height: number, options: RectOptions, targetPlane: PlaneLike | SceneObject): Rect;
+}
+declare const _default: CRectFunction;
+export default _default;