fluidcad 0.0.28 → 0.0.30

package/lib/dist/rendering/render.js

@@ -4,6 +4,7 @@ import { AxisObjectBase } from "../features/axis-renderable-base.js";
 import { Sketch } from "../features/2d/sketch.js";
 import { transformMeshes } from "./mesh-transform.js";
 import { ShapeOps } from "../oc/shape-ops.js";
+import { Profiler } from "../common/profiler.js";
 export class SceneRenderer {
     meshBuilder = new MeshBuilder();
     render(scene) {
@@ -11,6 +12,7 @@ export class SceneRenderer {
         console.log("============ Rendering ==============", sceneObjects.length);
         const skippedContainers = new Set();
         const buildDurations = new Map();
+        const profilers = new Map();
         for (const object of sceneObjects) {
             // Skip descendants of cloned sketches — their edges are already
             // computed by the parent sketch's clone-mode build.
@@ -21,7 +23,9 @@ export class SceneRenderer {
             }
             console.log("Rendering object:", object.getUniqueType());
             if (!scene.isCached(object)) {
-                buildDurations.set(object, this.buildObject(object, scene));
+                const result = this.buildObject(object, scene);
+                buildDurations.set(object, result.totalMs);
+                profilers.set(object, result.profiler);
             }
             // After building, mark cloned sketches so their children are skipped —
             // the sketch's build() already populated them with transformed shapes.
@@ -35,9 +39,20 @@ export class SceneRenderer {
             }
             object.clean(scene.getPartScopedAllObjects(object));
         }
+        const prepared = new Map();
+        for (const object of sceneObjects) {
+            const profiler = profilers.get(object);
+            const start = performance.now();
+            prepared.set(object, this.prepareRenderedShapes(object, profiler));
+            const meshMs = performance.now() - start;
+            const existing = buildDurations.get(object);
+            if (existing !== undefined) {
+                buildDurations.set(object, existing + meshMs);
+            }
+        }
         this.aggregateContainerDurations(sceneObjects, scene, buildDurations);
         for (const object of sceneObjects) {
-            this.renderObject(object, scene, buildDurations.get(object));
+            this.emitRenderObject(object, scene, prepared.get(object) ?? { renderedSceneShapes: [], ownShapeCount: 0 }, buildDurations.get(object), profilers.get(object));
         }
         return scene;
     }
@@ -50,7 +65,7 @@ export class SceneRenderer {
         }
         scene.clearRenderedObjects();
         for (const obj of allObjects) {
-            if (!scope.has(obj)) {
+            if (!scope.has(obj) || obj.isLazy()) {
                 this.emitRendered(obj, scene, {
                     sceneShapes: [],
                     visible: false,
@@ -59,7 +74,7 @@ export class SceneRenderer {
                 });
                 continue;
             }
-            const sceneShapes = obj.getOwnShapes({ excludeMeta: false }, scope);
+            const sceneShapes = obj.getOwnShapes({ excludeMeta: false, excludeGuide: false }, scope);
             const renderedSceneShapes = sceneShapes.map(s => this.toRenderedShape(s));
             this.emitRendered(obj, scene, {
                 sceneShapes: renderedSceneShapes,
@@ -72,40 +87,53 @@ export class SceneRenderer {
         console.table(result);
         return scene;
     }
-    renderObject(obj, scene, buildDurationMs) {
-        const sceneShapes = obj.getOwnShapes({ excludeMeta: false, excludeGuide: false });
+    prepareRenderedShapes(obj, profiler) {
         const renderedSceneShapes = [];
+        if (obj.isLazy()) {
+            return { renderedSceneShapes, ownShapeCount: 0 };
+        }
         try {
+            const sceneShapes = obj.getOwnShapes({ excludeMeta: false, excludeGuide: false });
             if (sceneShapes.length) {
                 console.log(` - Scene shapes: ${sceneShapes.length}`);
                 for (const shape of sceneShapes) {
-                    renderedSceneShapes.push(this.toRenderedShape(shape));
+                    renderedSceneShapes.push(this.toRenderedShape(shape, profiler));
                 }
             }
-            const errorMessage = obj.getError();
-            this.emitRendered(obj, scene, {
-                sceneShapes: renderedSceneShapes,
-                visible: this.computeVisibility(obj, scene, sceneShapes.length),
-                hasError: !!errorMessage,
-                errorMessage: errorMessage || undefined,
-                buildDurationMs,
-            });
+            return { renderedSceneShapes, ownShapeCount: sceneShapes.length };
         }
         catch (error) {
             const message = error instanceof Error ? error.message : String(error);
             console.error(`Error rendering object ${obj.getUniqueType()}:`, error);
+            return { renderedSceneShapes, ownShapeCount: renderedSceneShapes.length, prepError: message };
+        }
+    }
+    emitRenderObject(obj, scene, prepared, buildDurationMs, profiler) {
+        if (prepared.prepError) {
             this.emitRendered(obj, scene, {
-                sceneShapes: renderedSceneShapes,
+                sceneShapes: prepared.renderedSceneShapes,
                 visible: false,
                 hasError: true,
-                errorMessage: message,
+                errorMessage: prepared.prepError,
                 buildDurationMs,
+                profiler,
             });
+            return;
         }
+        const errorMessage = obj.getError();
+        this.emitRendered(obj, scene, {
+            sceneShapes: prepared.renderedSceneShapes,
+            visible: this.computeVisibility(obj, scene, prepared.ownShapeCount),
+            hasError: !!errorMessage,
+            errorMessage: errorMessage || undefined,
+            buildDurationMs,
+            profiler,
+        });
     }
     buildObject(object, scene) {
         object.clearError();
         const start = performance.now();
+        const profiler = new Profiler();
         try {
             object.build({
                 getSceneObjects: () => scene.getPartScopedObjectsUpTo(object),
@@ -122,6 +150,7 @@ export class SceneRenderer {
                     }
                     return null;
                 },
+                getProfiler: () => profiler,
             });
             const appliedTransform = object.getAppliedTransform();
             if (appliedTransform && !object.isContainer()) {
@@ -136,33 +165,40 @@ export class SceneRenderer {
             console.error(`Error building object ${object.getUniqueType()}:`, error);
             object.setError(message);
         }
-        return performance.now() - start;
+        const totalMs = performance.now() - start;
+        return { totalMs, profiler };
     }
-    getOrBuildMeshes(shape) {
+    getOrBuildMeshes(shape, profiler) {
         const existing = shape.getMeshes();
         if (existing) {
             return existing;
         }
-        let meshes;
-        const meshSource = shape.getMeshSource();
-        if (meshSource) {
-            let sourceMeshes = meshSource.shape.getMeshes();
-            if (!sourceMeshes) {
-                sourceMeshes = this.meshBuilder.build(meshSource.shape);
-                meshSource.shape.setMeshes(sourceMeshes);
+        profiler?.start("Triangulation");
+        try {
+            let meshes;
+            const meshSource = shape.getMeshSource();
+            if (meshSource) {
+                let sourceMeshes = meshSource.shape.getMeshes();
+                if (!sourceMeshes) {
+                    sourceMeshes = this.meshBuilder.build(meshSource.shape);
+                    meshSource.shape.setMeshes(sourceMeshes);
+                }
+                meshes = sourceMeshes ? transformMeshes(sourceMeshes, meshSource.matrix) : this.meshBuilder.build(shape);
+            }
+            else {
+                meshes = this.meshBuilder.build(shape);
             }
-            meshes = sourceMeshes ? transformMeshes(sourceMeshes, meshSource.matrix) : this.meshBuilder.build(shape);
+            shape.setMeshes(meshes);
+            return meshes;
         }
-        else {
-            meshes = this.meshBuilder.build(shape);
+        finally {
+            profiler?.end("Triangulation");
         }
-        shape.setMeshes(meshes);
-        return meshes;
     }
-    toRenderedShape(shape) {
+    toRenderedShape(shape, profiler) {
         return {
             shapeId: shape.id,
-            meshes: this.getOrBuildMeshes(shape),
+            meshes: this.getOrBuildMeshes(shape, profiler),
             shapeType: shape.getType(),
             isMetaShape: shape.isMetaShape() || undefined,
             isGuide: shape.isGuideShape() || undefined,
@@ -209,6 +245,8 @@ export class SceneRenderer {
         }
     }
     emitRendered(obj, scene, opts) {
+        const categories = opts.profiler?.getCategories();
+        const profileCategories = categories && categories.length > 0 ? categories : undefined;
         const rendered = {
             id: obj.id,
             name: obj.getName(),
@@ -224,6 +262,7 @@ export class SceneRenderer {
             errorMessage: opts.errorMessage,
             sourceLocation: obj.getSourceLocation() || undefined,
             buildDurationMs: opts.buildDurationMs,
+            profileCategories,
         };
         scene.addRenderedObject(obj, rendered);
     }

package/lib/dist/rendering/scene.d.ts

@@ -40,6 +40,10 @@ export type SceneObjectRender = {
         column: number;
     };
     buildDurationMs?: number;
+    profileCategories?: {
+        category: string;
+        durationMs: number;
+    }[];
 };
 export declare class Scene {
     private sceneObjects;

package/lib/dist/tests/features/2d/back.test.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/dist/tests/features/2d/back.test.js

@@ -0,0 +1,60 @@
+import { describe, it, expect } from "vitest";
+import { setupOC, render } from "../../setup.js";
+import sketch from "../../../core/sketch.js";
+import extrude from "../../../core/extrude.js";
+import { move, hMove, back, rect } from "../../../core/2d/index.js";
+import { ShapeOps } from "../../../oc/shape-ops.js";
+describe("back", () => {
+    setupOC();
+    it("should revert cursor to the previous position", () => {
+        sketch("xy", () => {
+            move([30, 20]);
+            move([100, 100]);
+            back();
+            rect(10, 10);
+        });
+        const e = extrude(5);
+        render();
+        const bbox = ShapeOps.getBoundingBox(e.getShapes()[0]);
+        expect(bbox.minX).toBeCloseTo(30, 0);
+        expect(bbox.minY).toBeCloseTo(20, 0);
+    });
+    it("should revert N positions back when given a count", () => {
+        sketch("xy", () => {
+            hMove(10);
+            hMove(20);
+            hMove(40);
+            back(2);
+            rect(5, 5);
+        });
+        const e = extrude(5);
+        render();
+        const bbox = ShapeOps.getBoundingBox(e.getShapes()[0]);
+        expect(bbox.minX).toBeCloseTo(10, 0);
+        expect(bbox.minY).toBeCloseTo(0, 0);
+    });
+    it("should fall back to sketch start point when count exceeds history", () => {
+        sketch("xy", () => {
+            hMove(50);
+            back(99);
+            rect(10, 10);
+        });
+        const e = extrude(5);
+        render();
+        const bbox = ShapeOps.getBoundingBox(e.getShapes()[0]);
+        expect(bbox.minX).toBeCloseTo(0, 0);
+        expect(bbox.minY).toBeCloseTo(0, 0);
+    });
+    it("should toggle on consecutive back() calls", () => {
+        sketch("xy", () => {
+            hMove(40);
+            back();
+            back();
+            rect(10, 10);
+        });
+        const e = extrude(5);
+        render();
+        const bbox = ShapeOps.getBoundingBox(e.getShapes()[0]);
+        expect(bbox.minX).toBeCloseTo(40, 0);
+    });
+});

package/lib/dist/tests/features/2d/circle.test.js

@@ -53,7 +53,7 @@ describe("circle", () => {
     });
     describe("standalone with targetPlane", () => {
         it("should create a circle on a specific plane", () => {
-            circle(60, "xy");
+            circle("xy", 60);
             const e = extrude(10);
             render();
             const solid = e.getShapes()[0];

package/lib/dist/tests/features/2d/constrained.test.js

@@ -89,7 +89,7 @@ describe("constrained geometries", () => {
     describe("tCircle between circle and line", () => {
         it("should create a tangent circle to a circle and a line", () => {
             const s = sketch("xy", () => {
-                const l = aLine(150, 45);
+                const l = aLine(45, 150);
                 const c = circle([100, 0], 60);
                 tCircle(c, l, 100).guide();
             });
@@ -101,7 +101,7 @@ describe("constrained geometries", () => {
     describe("tCircle between two lines", () => {
         it("should create a tangent circle between two lines", () => {
             const s = sketch("xy", () => {
-                const l1 = aLine(300, 45);
+                const l1 = aLine(45, 300);
                 move([-50, 0]);
                 const l2 = vLine(300);
                 tCircle(l1, l2, 200, true).guide();
@@ -136,7 +136,7 @@ describe("constrained geometries", () => {
     describe("tArc between circle and line", () => {
         it("should create a tangent arc to a circle and a line", () => {
             const s = sketch("xy", () => {
-                const l = aLine(150, 45);
+                const l = aLine(45, 150);
                 const c = circle([100, 0], 40);
                 tArc(c, l, 50).guide();
             });
@@ -148,7 +148,7 @@ describe("constrained geometries", () => {
     describe("tArc between two lines", () => {
         it("should create a fillet arc between two lines", () => {
             const s = sketch("xy", () => {
-                const l1 = aLine(150, 45);
+                const l1 = aLine(45, 150);
                 move([-50, 0]);
                 const l2 = vLine(100);
                 tArc(l1, l2, 50).guide();

package/lib/dist/tests/features/2d/ellipse.test.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/dist/tests/features/2d/ellipse.test.js

@@ -0,0 +1,100 @@
+import { describe, it, expect } from "vitest";
+import { setupOC, render } from "../../setup.js";
+import sketch from "../../../core/sketch.js";
+import extrude from "../../../core/extrude.js";
+import { ellipse } from "../../../core/2d/index.js";
+import { ShapeOps } from "../../../oc/shape-ops.js";
+describe("ellipse", () => {
+    setupOC();
+    describe("in sketch", () => {
+        it("creates an ellipse with rx along X and ry along Y", () => {
+            sketch("xy", () => {
+                ellipse(50, 30);
+            });
+            const e = extrude(10);
+            render();
+            const solid = e.getShapes()[0];
+            const bbox = ShapeOps.getBoundingBox(solid);
+            expect(bbox.maxX - bbox.minX).toBeCloseTo(100, 0);
+            expect(bbox.maxY - bbox.minY).toBeCloseTo(60, 0);
+        });
+        it("handles ry > rx (axis-swap path)", () => {
+            sketch("xy", () => {
+                ellipse(30, 50);
+            });
+            const e = extrude(10);
+            render();
+            const solid = e.getShapes()[0];
+            const bbox = ShapeOps.getBoundingBox(solid);
+            expect(bbox.maxX - bbox.minX).toBeCloseTo(60, 0);
+            expect(bbox.maxY - bbox.minY).toBeCloseTo(100, 0);
+        });
+        it("creates an ellipse at a given center", () => {
+            sketch("xy", () => {
+                ellipse([50, 30], 40, 20);
+            });
+            const e = extrude(10);
+            render();
+            const bbox = ShapeOps.getBoundingBox(e.getShapes()[0]);
+            expect(bbox.centerX).toBeCloseTo(50, 0);
+            expect(bbox.centerY).toBeCloseTo(30, 0);
+            expect(bbox.maxX - bbox.minX).toBeCloseTo(80, 0);
+            expect(bbox.maxY - bbox.minY).toBeCloseTo(40, 0);
+        });
+        it("falls through to a circle when rx == ry", () => {
+            sketch("xy", () => {
+                ellipse(25, 25);
+            });
+            const e = extrude(10);
+            render();
+            const solid = e.getShapes()[0];
+            const bbox = ShapeOps.getBoundingBox(solid);
+            expect(bbox.maxX - bbox.minX).toBeCloseTo(50, 0);
+            expect(bbox.maxY - bbox.minY).toBeCloseTo(50, 0);
+        });
+        it("rejects zero or negative radii", () => {
+            let zeroEllipse;
+            sketch("xy", () => {
+                zeroEllipse = ellipse(0, 30);
+            });
+            render();
+            expect(zeroEllipse?.getError()).toMatch(/positive/i);
+            let negEllipse;
+            sketch("xy", () => {
+                negEllipse = ellipse(-10, 5);
+            });
+            render();
+            expect(negEllipse?.getError()).toMatch(/positive/i);
+        });
+        it("throws when given a plane inside a sketch", () => {
+            expect(() => {
+                sketch("xy", () => {
+                    ellipse("xy", 30, 20);
+                });
+                render();
+            }).toThrow();
+        });
+    });
+    describe("standalone with targetPlane", () => {
+        it("creates an ellipse on a specific plane", () => {
+            ellipse("xy", 60, 40);
+            const e = extrude(10);
+            render();
+            const solid = e.getShapes()[0];
+            const bbox = ShapeOps.getBoundingBox(solid);
+            expect(bbox.maxX - bbox.minX).toBeCloseTo(120, 0);
+            expect(bbox.maxY - bbox.minY).toBeCloseTo(80, 0);
+        });
+        it("creates an ellipse on a plane at a given center", () => {
+            ellipse("xy", [10, 20], 30, 15);
+            const e = extrude(10);
+            render();
+            const solid = e.getShapes()[0];
+            const bbox = ShapeOps.getBoundingBox(solid);
+            expect(bbox.centerX).toBeCloseTo(10, 0);
+            expect(bbox.centerY).toBeCloseTo(20, 0);
+            expect(bbox.maxX - bbox.minX).toBeCloseTo(60, 0);
+            expect(bbox.maxY - bbox.minY).toBeCloseTo(30, 0);
+        });
+    });
+});

package/lib/dist/tests/features/2d/line.test.js

@@ -2,8 +2,9 @@ import { describe, it, expect } from "vitest";
 import { setupOC, render } from "../../setup.js";
 import sketch from "../../../core/sketch.js";
 import extrude from "../../../core/extrude.js";
-import { line, hLine, vLine, aLine } from "../../../core/2d/index.js";
+import { line, hLine, vLine, aLine, circle, move } from "../../../core/2d/index.js";
 import { ShapeOps } from "../../../oc/shape-ops.js";
+import { Edge } from "../../../common/edge.js";
 describe("line functions", () => {
     setupOC();
     describe("line", () => {
@@ -32,7 +33,7 @@ describe("line functions", () => {
             expect(bbox.maxY - bbox.minY).toBeCloseTo(40, 0);
         });
         it("should support standalone mode with targetPlane", () => {
-            hLine(50, "xy");
+            hLine("xy", 50);
             render();
             // Just verify no error — standalone line doesn't form a closed shape
         });
@@ -57,7 +58,7 @@ describe("line functions", () => {
         it("should create an angled line", () => {
             sketch("xy", () => {
                 hLine(50);
-                aLine(50, 90);
+                aLine(90, 50);
                 hLine(-50);
                 vLine(-50);
             });
@@ -66,6 +67,91 @@ describe("line functions", () => {
             expect(e.getShapes()).toHaveLength(1);
         });
     });
+    describe("hLine to target geometry", () => {
+        it("should end at the nearest intersection with a circle", () => {
+            let h;
+            sketch("xy", () => {
+                const c = circle([100, 0], 50);
+                h = hLine([0, 0], c);
+            });
+            render();
+            const edges = h.getOwnShapes().filter((sh) => sh instanceof Edge);
+            expect(edges).toHaveLength(1);
+            const endPoint = edges[0].getLastVertex().toPoint();
+            // Circle at (100, 0) with diameter 50 → radius 25 → near edge at x=75
+            expect(endPoint.x).toBeCloseTo(75, 1);
+            expect(endPoint.y).toBeCloseTo(0, 1);
+        });
+        it("should pick nearest intersection when target is behind the start", () => {
+            let h;
+            sketch("xy", () => {
+                const c = circle([-100, 0], 50);
+                h = hLine([0, 0], c);
+            });
+            render();
+            const edges = h.getOwnShapes().filter((sh) => sh instanceof Edge);
+            const endPoint = edges[0].getLastVertex().toPoint();
+            // Circle at (-100, 0) with diameter 50 → near edge at x=-75
+            expect(endPoint.x).toBeCloseTo(-75, 1);
+            expect(endPoint.y).toBeCloseTo(0, 1);
+        });
+        it("should record an error when there is no intersection", () => {
+            let h;
+            sketch("xy", () => {
+                const c = circle([0, 100], 20);
+                h = hLine([0, 0], c);
+            });
+            render();
+            expect(h.getError()).toMatch(/does not intersect/);
+        });
+        it("should record an error when .centered() is combined with a target", () => {
+            let h;
+            sketch("xy", () => {
+                const c = circle([100, 0], 40);
+                h = hLine([0, 0], c).centered();
+            });
+            render();
+            expect(h.getError()).toMatch(/centered/);
+        });
+    });
+    describe("vLine to target geometry", () => {
+        it("should end at the nearest intersection with a circle above", () => {
+            let v;
+            sketch("xy", () => {
+                const c = circle([0, 100], 50);
+                v = vLine([0, 0], c);
+            });
+            render();
+            const edges = v.getOwnShapes().filter((sh) => sh instanceof Edge);
+            const endPoint = edges[0].getLastVertex().toPoint();
+            expect(endPoint.x).toBeCloseTo(0, 1);
+            expect(endPoint.y).toBeCloseTo(75, 1);
+        });
+    });
+    describe("aLine to target geometry", () => {
+        it("should end where the angled line meets a horizontal line", () => {
+            let a;
+            sketch("xy", () => {
+                // A horizontal segment at y = 50 (drawn as guide for intersection).
+                // Use hLine starting at (-100, 50) with length 200 so it spans x ∈ [-100, 100].
+                const h = hLine([-100, 50], 200);
+                // Now place a 45° line starting at the origin; previous tangent is (1,0)
+                // (left over from h's hLine). Rotated 45° CCW that's direction (√2/2, √2/2).
+                // Starting from (100, 50)? Actually current position after h is (100, 50).
+                // We want aLine at angle 45° from current direction (1,0) rotated by 45°
+                // → direction (√2/2, √2/2). Starting from (100, 50), going at 45° → never
+                // hits the segment again. Use move() to reset start.
+                move([0, 0]);
+                a = aLine(45, h);
+            });
+            render();
+            const edges = a.getOwnShapes().filter((sh) => sh instanceof Edge);
+            const endPoint = edges[0].getLastVertex().toPoint();
+            // 45° line from (0,0) hits y=50 at x=50.
+            expect(endPoint.x).toBeCloseTo(50, 1);
+            expect(endPoint.y).toBeCloseTo(50, 1);
+        });
+    });
     describe("combined line functions", () => {
         it("should create an L-shape with hLine and vLine", () => {
             sketch("xy", () => {

package/lib/dist/tests/features/2d/offset.test.js

@@ -91,7 +91,7 @@ describe("offset", () => {
             const s = sketch("xy", () => {
                 circle(40);
             });
-            offset(5, false, "xy", s);
+            offset("xy", 5, false, s);
             render();
             // Offset edges should exist on the target plane
         });

package/lib/dist/tests/features/2d/polygon.test.js

@@ -133,14 +133,14 @@ describe("polygon", () => {
     });
     describe("standalone with targetPlane", () => {
         it("should create a polygon on a specific plane", () => {
-            polygon(5, 50, "xy");
+            polygon("xy", 5, 50);
             const e = extrude(10);
             render();
             const solid = e.getShapes()[0];
             expect(solid.getFaces()).toHaveLength(7);
         });
         it("should create a circumscribed polygon on a specific plane", () => {
-            polygon(6, 60, "circumscribed", "xy");
+            polygon("xy", 6, 60, "circumscribed");
             const e = extrude(10);
             render();
             const solid = e.getShapes()[0];

package/lib/dist/tests/features/2d/rect.test.js

@@ -54,7 +54,7 @@ describe("rect", () => {
     });
     describe("standalone with targetPlane", () => {
         it("should create a rectangle on a specific plane", () => {
-            rect(80, 40, "xy");
+            rect("xy", 80, 40);
             const e = extrude(10);
             render();
             const solid = e.getShapes()[0];

package/lib/dist/tests/features/2d/slot-from-edge.test.js

@@ -15,7 +15,7 @@ describe("slot from edge", () => {
     });
     it("should create a slot from an angled line", () => {
         const s = sketch("xy", () => {
-            const l = aLine(60, 45);
+            const l = aLine(45, 60);
             slot(l, 10);
         });
         render();

package/lib/dist/tests/features/2d/slot.test.js

@@ -35,7 +35,7 @@ describe("slot", () => {
     });
     describe("standalone with targetPlane", () => {
         it("should create a slot on a specific plane", () => {
-            slot(60, 10, "xy");
+            slot("xy", 60, 10);
             const e = extrude(10);
             render();
             expect(e.getShapes()).toHaveLength(1);