fluidcad 0.0.16 → 0.0.18

package/lib/dist/features/repeat-circular.js

@@ -10,6 +10,9 @@ export class RepeatCircular extends SceneObject {
         this.targetObjects = targetObjects;
         this.setAlwaysVisible();
     }
+    isContainer() {
+        return true;
+    }
     build(context) {
         this.saveShapesSnapshot(context);
     }

package/lib/dist/features/repeat-linear.d.ts

@@ -16,6 +16,7 @@ export declare class RepeatLinear extends SceneObject {
     options: LinearRepeatOptions;
     targetObjects: SceneObject[] | null;
     constructor(axes: Axis[], options: LinearRepeatOptions, targetObjects?: SceneObject[] | null);
+    isContainer(): boolean;
     build(context: BuildSceneObjectContext): void;
     compareTo(other: RepeatLinear): boolean;
     getType(): string;

package/lib/dist/features/repeat-linear.js

@@ -10,6 +10,9 @@ export class RepeatLinear extends SceneObject {
         this.targetObjects = targetObjects;
         this.setAlwaysVisible();
     }
+    isContainer() {
+        return true;
+    }
     build(context) {
         this.saveShapesSnapshot(context);
     }

package/lib/dist/features/revolve.d.ts

@@ -26,5 +26,6 @@ export declare class Revolve extends ExtrudeBase implements IRevolve {
         axis: any;
         operationMode: "new" | "remove";
         symmetric: true;
+        thin: [number, number] | [number];
     };
 }

package/lib/dist/features/revolve.js

@@ -8,6 +8,7 @@ import { FaceMaker2 } from "../oc/face-maker2.js";
 import { ExtrudeBase } from "./extrude-base.js";
 import { BooleanOps } from "../oc/boolean-ops.js";
 import { FaceOps } from "../oc/face-ops.js";
+import { ThinFaceMaker } from "../oc/thin-face-maker.js";
 export class Revolve extends ExtrudeBase {
     axis;
     angle;
@@ -25,24 +26,23 @@ export class Revolve extends ExtrudeBase {
         const solids = [];
         const allStartFaces = [];
         const allEndFaces = [];
-        const allSideFaces = [];
-        const allInternalFaces = [];
-        const faces = pickedFaces ?? FaceMaker2.getRegions(this.extrudable.getGeometries(), plane);
+        let allSideFaces = [];
+        let allInternalFaces = [];
+        let allCapFaces = [];
+        let faces = pickedFaces ?? FaceMaker2.getRegions(this.extrudable.getGeometries(), plane);
+        let inwardEdges;
+        let outwardEdges;
+        if (this.isThin()) {
+            const thinResult = ThinFaceMaker.make(this.extrudable.getGeometries(), plane, this._thin[0], this._thin[1]);
+            faces = thinResult.faces;
+            inwardEdges = thinResult.inwardEdges;
+            outwardEdges = thinResult.outwardEdges;
+        }
         const { result: fusedFaces } = BooleanOps.fuseFaces(faces);
         const axis = this.axis.getAxis();
         const isFullRevolution = Math.abs(this.angle) >= 360;
         for (const face of fusedFaces) {
             const solid = ExtrudeOps.makeRevol(face, axis, rad(this.angle));
-            // Collect inner wire edges for internal face detection
-            const innerWireEdges = [];
-            const wires = face.getWires();
-            for (const wire of wires) {
-                if (!wire.isCW(plane.normal)) {
-                    for (const edge of wire.getEdges()) {
-                        innerWireEdges.push(edge);
-                    }
-                }
-            }
             let resultSolid;
             if (this._symmetric) {
                 const rotated = ShapeOps.rotateShape(solid.getShape(), axis, -rad(this.angle) / 2);
@@ -59,15 +59,7 @@ export class Revolve extends ExtrudeBase {
                 if (isOnSourcePlane && !isFullRevolution) {
                     allStartFaces.push(f);
                 }
-                else if (!isOnSourcePlane) {
-                    if (innerWireEdges.length > 0) {
-                        const faceEdges = f.getEdges();
-                        const isInternal = faceEdges.some(fe => innerWireEdges.some(iwe => fe.getShape().IsPartner(iwe.getShape())));
-                        if (isInternal) {
-                            allInternalFaces.push(f);
-                            continue;
-                        }
-                    }
+                else {
                     allSideFaces.push(f);
                 }
             }
@@ -81,10 +73,42 @@ export class Revolve extends ExtrudeBase {
             allStartFaces.push(...startSlice);
             allEndFaces.push(...endSlice);
         }
+        if (inwardEdges && inwardEdges.length > 0) {
+            const result = this.reclassifyThinFaces(allSideFaces, allStartFaces, plane, inwardEdges, outwardEdges || []);
+            allSideFaces = result.sideFaces;
+            allInternalFaces = result.internalFaces;
+            allCapFaces = result.capFaces;
+        }
+        else {
+            const innerWireEdges = [];
+            for (const sf of allStartFaces) {
+                for (const wire of sf.getWires()) {
+                    if (!wire.isCW(plane.normal)) {
+                        for (const edge of wire.getEdges()) {
+                            innerWireEdges.push(edge);
+                        }
+                    }
+                }
+            }
+            if (innerWireEdges.length > 0) {
+                const remaining = [];
+                for (const f of allSideFaces) {
+                    const isInternal = f.getEdges().some(fe => innerWireEdges.some(iwe => fe.getShape().IsPartner(iwe.getShape())));
+                    if (isInternal) {
+                        allInternalFaces.push(f);
+                    }
+                    else {
+                        remaining.push(f);
+                    }
+                }
+                allSideFaces = remaining;
+            }
+        }
         this.setState('start-faces', allStartFaces);
         this.setState('end-faces', allEndFaces);
         this.setState('side-faces', allSideFaces);
         this.setState('internal-faces', allInternalFaces);
+        this.setState('cap-faces', allCapFaces);
         this.extrudable.removeShapes(this);
         this.axis.removeShapes(this);
         if (this._operationMode === 'remove') {
@@ -141,6 +165,7 @@ export class Revolve extends ExtrudeBase {
             axis: this.axis.serialize(),
             operationMode: this._operationMode !== 'add' ? this._operationMode : undefined,
             symmetric: this._symmetric || undefined,
+            thin: this._thin,
             ...this.serializePickFields(),
         };
     }

package/lib/dist/features/sweep.d.ts

@@ -25,5 +25,6 @@ export declare class Sweep extends ExtrudeBase implements ISweep {
         path: any;
         extrudable: any;
         operationMode: "new" | "remove";
+        thin: [number, number] | [number];
     };
 }

package/lib/dist/features/sweep.js

@@ -4,6 +4,7 @@ import { WireOps } from "../oc/wire-ops.js";
 import { FaceMaker2 } from "../oc/face-maker2.js";
 import { ExtrudeBase } from "./extrude-base.js";
 import { fuseWithSceneObjects, cutWithSceneObjects } from "../helpers/scene-helpers.js";
+import { ThinFaceMaker } from "../oc/thin-face-maker.js";
 export class Sweep extends ExtrudeBase {
     _path;
     constructor(path, extrudable) {
@@ -22,7 +23,15 @@ export class Sweep extends ExtrudeBase {
         // Extract spine wire from path
         const spineWire = this.getSpineWire(this._path);
         // Extract profile faces from extrudable
-        const profileFaces = pickedFaces ?? FaceMaker2.getRegions(this.extrudable.getGeometries(), plane, this.getDrill());
+        let profileFaces = pickedFaces ?? FaceMaker2.getRegions(this.extrudable.getGeometries(), plane, this.getDrill());
+        let inwardEdges;
+        let outwardEdges;
+        if (this.isThin()) {
+            const thinResult = ThinFaceMaker.make(this.extrudable.getGeometries(), plane, this._thin[0], this._thin[1]);
+            profileFaces = thinResult.faces;
+            inwardEdges = thinResult.inwardEdges;
+            outwardEdges = thinResult.outwardEdges;
+        }
         if (profileFaces.length === 0) {
             throw new Error("Could not extract profile faces from extrudable.");
         }
@@ -32,7 +41,7 @@ export class Sweep extends ExtrudeBase {
         // Classify faces using FirstShape/LastShape from the OC result
         const startFaces = [];
         const endFaces = [];
-        const sideFaces = [];
+        let sideFaces = [];
         const firstShapeFromOC = sweepResult.firstShape;
         const lastShapeFromOC = sweepResult.lastShape;
         for (const shape of newShapes) {
@@ -49,9 +58,44 @@ export class Sweep extends ExtrudeBase {
                 }
             }
         }
+        let internalFaces = [];
+        let capFaces = [];
+        if (inwardEdges && inwardEdges.length > 0) {
+            const result = this.reclassifyThinFaces(sideFaces, startFaces, plane, inwardEdges, outwardEdges || []);
+            sideFaces = result.sideFaces;
+            internalFaces = result.internalFaces;
+            capFaces = result.capFaces;
+        }
+        else {
+            const innerWireEdges = [];
+            for (const sf of startFaces) {
+                for (const wire of sf.getWires()) {
+                    if (!wire.isCW(plane.normal)) {
+                        for (const edge of wire.getEdges()) {
+                            innerWireEdges.push(edge);
+                        }
+                    }
+                }
+            }
+            if (innerWireEdges.length > 0) {
+                const remaining = [];
+                for (const f of sideFaces) {
+                    const isInternal = f.getEdges().some(fe => innerWireEdges.some(iwe => fe.getShape().IsPartner(iwe.getShape())));
+                    if (isInternal) {
+                        internalFaces.push(f);
+                    }
+                    else {
+                        remaining.push(f);
+                    }
+                }
+                sideFaces = remaining;
+            }
+        }
         this.setState('start-faces', startFaces);
         this.setState('end-faces', endFaces);
         this.setState('side-faces', sideFaces);
+        this.setState('internal-faces', internalFaces);
+        this.setState('cap-faces', capFaces);
         // Remove consumed input shapes
         this.extrudable.removeShapes(this);
         this._path.removeShapes(this);
@@ -120,6 +164,7 @@ export class Sweep extends ExtrudeBase {
             path: this._path.serialize(),
             extrudable: this.extrudable.serialize(),
             operationMode: this._operationMode !== 'add' ? this._operationMode : undefined,
+            thin: this._thin,
             ...this.serializePickFields(),
         };
     }

package/lib/dist/index.js

@@ -7,17 +7,22 @@ export function captureSourceLocation() {
     }
     const lines = stack.split('\n');
     for (const frame of lines) {
-        const match = frame.match(/((?:[A-Za-z]:)?\/[^\s]+?\.fluid\.js):(\d+):(\d+)/);
-        if (match) {
-            let filePath = match[1];
-            const virtualIdx = filePath.indexOf('virtual:live-render:');
-            if (virtualIdx !== -1) {
-                filePath = filePath.substring(virtualIdx + 'virtual:live-render:'.length);
-            }
+        // Match the Vite live-render virtual prefix first so the path regex
+        // does not accidentally match `r:/…` inside the word `render:`.
+        const virtualMatch = frame.match(/virtual:live-render:((?:[A-Za-z]:)?\/[^\s]+?\.fluid\.js):(\d+):(\d+)/);
+        if (virtualMatch) {
+            return {
+                filePath: virtualMatch[1],
+                line: parseInt(virtualMatch[2], 10),
+                column: parseInt(virtualMatch[3], 10),
+            };
+        }
+        const realMatch = frame.match(/((?:[A-Za-z]:)?\/[^\s]+?\.fluid\.js):(\d+):(\d+)/);
+        if (realMatch) {
             return {
-                filePath,
-                line: parseInt(match[2], 10),
-                column: parseInt(match[3], 10),
+                filePath: realMatch[1],
+                line: parseInt(realMatch[2], 10),
+                column: parseInt(realMatch[3], 10),
             };
         }
     }

package/lib/dist/rendering/render.js

@@ -3,7 +3,7 @@ import { PlaneObjectBase } from "../features/plane-renderable-base.js";
 import { AxisObjectBase } from "../features/axis-renderable-base.js";
 import { Sketch } from "../features/2d/sketch.js";
 const meshBuilder = new MeshBuilder();
-function renderSceneObject(obj, scene) {
+function renderSceneObject(obj, scene, buildDurationMs) {
     const hasError = !!obj.getError();
     const sceneShapes = obj.getOwnShapes({ excludeMeta: false, excludeGuide: false });
     const renderedSceneShapes = [];
@@ -52,6 +52,7 @@ function renderSceneObject(obj, scene) {
         hasError,
         errorMessage: obj.getError() || undefined,
         sourceLocation: obj.getSourceLocation() || undefined,
+        buildDurationMs,
     });
 }
 export function renderSceneRollback(scene, rollbackIndex) {
@@ -136,6 +137,7 @@ export function renderScene(scene) {
     const sceneObjects = scene.getAllSceneObjects();
     console.log("============ Rendering ==============", sceneObjects.length);
     const skippedContainers = new Set();
+    const buildDurations = 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.
@@ -148,6 +150,7 @@ export function renderScene(scene) {
         const isCached = scene.isCached(object);
         if (!isCached) {
             object.clearError();
+            const buildStart = performance.now();
             try {
                 object.build({
                     getSceneObjects() {
@@ -179,6 +182,7 @@ export function renderScene(scene) {
                 console.error(`Error building object ${object.getUniqueType()}:`, error);
                 object.setError(message);
             }
+            buildDurations.set(object, performance.now() - buildStart);
         }
         // After building, mark cloned sketches so their children are skipped
         if (object instanceof Sketch && object.getState('cloned-edges')) {
@@ -192,8 +196,28 @@ export function renderScene(scene) {
         }
         object.clean(scene.getPartScopedAllObjects(object));
     }
+    // Roll up container durations: include own build time plus all descendants.
+    // Iterate in reverse so nested containers are aggregated before their parents.
+    for (let i = sceneObjects.length - 1; i >= 0; i--) {
+        const object = sceneObjects[i];
+        if (!object.isContainer()) {
+            continue;
+        }
+        const own = buildDurations.get(object);
+        if (own === undefined) {
+            continue;
+        }
+        let total = own;
+        for (const child of scene.getChildren(object)) {
+            const childDuration = buildDurations.get(child);
+            if (childDuration !== undefined) {
+                total += childDuration;
+            }
+        }
+        buildDurations.set(object, total);
+    }
     for (const object of sceneObjects) {
-        renderSceneObject(object, scene);
+        renderSceneObject(object, scene, buildDurations.get(object));
     }
     const result = scene.getRenderedObjects();
     console.table(result);

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

@@ -39,6 +39,7 @@ export type SceneObjectRender = {
         line: number;
         column: number;
     };
+    buildDurationMs?: number;
 };
 export declare class Scene {
     private sceneObjects;

package/lib/dist/tests/features/copy-linear.test.js

@@ -62,13 +62,13 @@ describe("copy linear", () => {
             rect(20, 20);
         });
         const e = extrude(10).new();
-        // 4 copies over length 120 → offset = 120/4 = 30
+        // 4 copies over length 120 → offset = 120/(4-1) = 40
         const c = copy("linear", "x", { count: 4, length: 120 }, e);
         render();
         const shapes = c.getShapes();
         expect(shapes).toHaveLength(3);
         const bbox = ShapeOps.getBoundingBox(shapes[0]);
-        expect(bbox.minX).toBeCloseTo(30, 0);
+        expect(bbox.minX).toBeCloseTo(40, 0);
     });
     it("should create a 2D grid with multiple axes", () => {
         sketch("xy", () => {

package/lib/dist/tests/features/thin-loft.test.d.ts

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

package/lib/dist/tests/features/thin-loft.test.js

@@ -0,0 +1,151 @@
+import { describe, it, expect } from "vitest";
+import { setupOC, render } from "../setup.js";
+import sketch from "../../core/sketch.js";
+import plane from "../../core/plane.js";
+import loft from "../../core/loft.js";
+import extrude from "../../core/extrude.js";
+import { rect, circle } from "../../core/2d/index.js";
+import { ShapeOps } from "../../oc/shape-ops.js";
+import { ShapeProps } from "../../oc/props.js";
+import { EdgeQuery } from "../../oc/edge-query.js";
+describe("thin loft", () => {
+    setupOC();
+    describe("closed profile - same size", () => {
+        it("should create a thin-walled loft between two rects", () => {
+            const s1 = sketch("xy", () => {
+                rect(40, 40);
+            });
+            const s2 = sketch(plane("xy", { offset: 30 }), () => {
+                rect(40, 40);
+            });
+            const l = loft(s1, s2).thin(5);
+            render();
+            const shapes = l.getShapes();
+            expect(shapes).toHaveLength(1);
+            expect(shapes[0].getType()).toBe("solid");
+            const bbox = ShapeOps.getBoundingBox(shapes[0]);
+            expect(bbox.maxZ - bbox.minZ).toBeCloseTo(30, 0);
+        });
+        it("should have less volume than a solid loft", () => {
+            const s1 = sketch("xy", () => {
+                rect(60, 60);
+            });
+            const s2 = sketch(plane("xy", { offset: 40 }), () => {
+                rect(60, 60);
+            });
+            const solidS1 = sketch("xy", () => {
+                rect(60, 60);
+            });
+            const solidS2 = sketch(plane("xy", { offset: 40 }), () => {
+                rect(60, 60);
+            });
+            const thinLoft = loft(s1, s2).thin(3).new();
+            const solidLoft = loft(solidS1, solidS2).new();
+            render();
+            const thinVolume = ShapeProps.getProperties(thinLoft.getShapes()[0].getShape()).volumeMm3;
+            const solidVolume = ShapeProps.getProperties(solidLoft.getShapes()[0].getShape()).volumeMm3;
+            expect(thinVolume).toBeLessThan(solidVolume * 0.9);
+            expect(thinVolume).toBeGreaterThan(0);
+        });
+    });
+    describe("closed profile - different sizes", () => {
+        it("should create a thin-walled tapered loft", () => {
+            const s1 = sketch("xy", () => {
+                rect(40, 40);
+            });
+            const s2 = sketch(plane("xy", { offset: 30 }), () => {
+                rect(20, 20);
+            });
+            const l = loft(s1, s2).thin(3);
+            render();
+            const shapes = l.getShapes();
+            expect(shapes).toHaveLength(1);
+            expect(shapes[0].getType()).toBe("solid");
+        });
+        it("should create a thin-walled loft between circle and rect", () => {
+            const s1 = sketch("xy", () => {
+                circle(20);
+            });
+            const s2 = sketch(plane("xy", { offset: 30 }), () => {
+                rect(30, 30);
+            });
+            const l = loft(s1, s2).thin(3);
+            render();
+            const shapes = l.getShapes();
+            expect(shapes).toHaveLength(1);
+            expect(shapes[0].getType()).toBe("solid");
+        });
+    });
+    describe("dual offset", () => {
+        it("should create a thin-walled loft with dual offset", () => {
+            const s1 = sketch("xy", () => {
+                circle(40);
+            });
+            const s2 = sketch(plane("xy", { offset: 30 }), () => {
+                circle(40);
+            });
+            const l = loft(s1, s2).thin(5, -3).new();
+            render();
+            const shapes = l.getShapes();
+            expect(shapes).toHaveLength(1);
+            expect(shapes[0].getType()).toBe("solid");
+            const edges = shapes[0].getSubShapes('edge');
+            const circleEdges = edges.filter(e => EdgeQuery.isCircleEdge(e));
+            expect(circleEdges).toHaveLength(4);
+        });
+    });
+    describe("face classification", () => {
+        it("should classify start and end faces", () => {
+            const s1 = sketch("xy", () => {
+                rect(40, 40);
+            });
+            const s2 = sketch(plane("xy", { offset: 30 }), () => {
+                rect(40, 40);
+            });
+            const l = loft(s1, s2).thin(5);
+            render();
+            const startFaces = l.getState('start-faces');
+            const endFaces = l.getState('end-faces');
+            const sideFaces = l.getState('side-faces');
+            expect(startFaces.length).toBeGreaterThan(0);
+            expect(endFaces.length).toBeGreaterThan(0);
+            expect(sideFaces.length).toBeGreaterThan(0);
+        });
+    });
+    describe("three profiles", () => {
+        it("should create a thin-walled loft through three profiles", () => {
+            const s1 = sketch("xy", () => {
+                rect(40, 40);
+            });
+            const s2 = sketch(plane("xy", { offset: 20 }), () => {
+                rect(30, 30);
+            });
+            const s3 = sketch(plane("xy", { offset: 40 }), () => {
+                rect(40, 40);
+            });
+            const l = loft(s1, s2, s3).thin(3);
+            render();
+            const shapes = l.getShapes();
+            expect(shapes).toHaveLength(1);
+            expect(shapes[0].getType()).toBe("solid");
+        });
+    });
+    describe("remove mode", () => {
+        it("should cut a thin-walled loft from existing geometry", () => {
+            sketch("xy", () => {
+                rect(200, 200);
+            });
+            extrude(50);
+            const s1 = sketch("xy", () => {
+                rect(40, 40);
+            });
+            const s2 = sketch(plane("xy", { offset: 40 }), () => {
+                rect(40, 40);
+            });
+            const l = loft(s1, s2).thin(5).remove();
+            render();
+            const shapes = l.getShapes();
+            expect(shapes.length).toBeGreaterThan(0);
+        });
+    });
+});

package/lib/dist/tests/features/thin-revolve.test.d.ts

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