fluidcad 0.0.15 → 0.0.16

package/bin/fluidcad.js

@@ -26,14 +26,14 @@ if (positionals[0] === 'init') {
     process.exit(1);
   }
 
-  writeFileSync(initPath, `import { init } from 'fluidcad'\n\nexport default init()\n`);
+  writeFileSync(initPath, `import { init } from 'fluidcad'\n\nexport default await init()\n`);
 
   const testPath = resolve(cwd, 'test.fluid.js');
   if (!existsSync(testPath)) {
     writeFileSync(testPath, `import { extrude, fillet, rect, shell, sketch } from "fluidcad/core";
 
 sketch("xy", () => {
-    rect(100, 50).radius(10).center();
+    rect(100, 50).radius(10).centered();
 });
 
 const e = extrude(30);

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

@@ -32,6 +32,7 @@ export declare abstract class SceneObject implements Comparable<SceneObject>, Se
     private _alwaysVisible;
     private _name;
     private _guide;
+    private _reusable;
     private _sourceLocation;
     private _error;
     protected _fusionScope?: FusionScope;
@@ -74,7 +75,7 @@ export declare abstract class SceneObject implements Comparable<SceneObject>, Se
     addShape(shape: Shape): void;
     addShapes(shapes: Shape[]): void;
     removeShape(shape: Shape, removedBy: SceneObject): void;
-    removeShapes(removedBy: SceneObject): void;
+    removeShapes(removedBy: SceneObject, force?: boolean): void;
     getOwnShapes(filter?: ShapeFilter, scope?: Set<SceneObject>): Shape[];
     getChildShapes(filter?: ShapeFilter, type?: ShapeType): Shape[];
     getShapes(filter?: ShapeFilter, type?: ShapeType): Shape[];
@@ -92,6 +93,8 @@ export declare abstract class SceneObject implements Comparable<SceneObject>, Se
     getName(): string;
     name(value: string): this;
     guide(): this;
+    reusable(): this;
+    isReusable(): boolean;
     setSourceLocation(loc: SourceLocation): void;
     getSourceLocation(): SourceLocation | null;
     setError(message: string): void;

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

@@ -10,6 +10,7 @@ export class SceneObject {
     _alwaysVisible = false;
     _name = null;
     _guide = false;
+    _reusable = false;
     _sourceLocation = null;
     _error = null;
     _fusionScope = 'all';
@@ -89,7 +90,7 @@ export class SceneObject {
         return this.getState('snapshot') || [];
     }
     compareTo(other) {
-        const match = this._guide === other._guide;
+        const match = this._guide === other._guide && this._reusable === other._reusable;
         if (!match) {
             return false;
         }
@@ -217,10 +218,13 @@ export class SceneObject {
             removedBy
         });
     }
-    removeShapes(removedBy) {
+    removeShapes(removedBy, force) {
+        if (this._reusable && !force) {
+            return;
+        }
         if (this.isContainer()) {
             for (const child of this.children) {
-                child.removeShapes(removedBy);
+                child.removeShapes(removedBy, force);
             }
             return;
         }
@@ -303,6 +307,13 @@ export class SceneObject {
         this._guide = true;
         return this;
     }
+    reusable() {
+        this._reusable = true;
+        return this;
+    }
+    isReusable() {
+        return this._reusable;
+    }
     setSourceLocation(loc) {
         this._sourceLocation = loc;
     }

package/lib/dist/core/interfaces.d.ts

@@ -13,6 +13,13 @@ export interface ISceneObject {
      * final geometry output unless explicitly included.
      */
     guide(): this;
+    /**
+     * Marks this object as reusable. Reusable objects retain their shapes when
+     * consumed by features (e.g., extrude, revolve), allowing multiple features
+     * to reference the same source geometry. Use `remove(obj)` to force-remove
+     * shapes from a reusable object.
+     */
+    reusable(): this;
 }
 export interface IFuseable extends ISceneObject {
     /**
@@ -243,6 +250,17 @@ export interface IExtrude extends IFuseable {
      * @param args - Numeric indices or {@link EdgeFilterBuilder} instances to filter the selection.
      */
     internalEdges(...args: (number | EdgeFilterBuilder)[]): ISceneObject;
+    /**
+     * Selects the cap faces at the open ends of a thin-walled extrusion from an open profile.
+     * These are the small faces connecting the inner and outer walls at the profile endpoints.
+     * @param args - Numeric indices or {@link FaceFilterBuilder} instances to filter the selection.
+     */
+    capFaces(...args: (number | FaceFilterBuilder)[]): ISceneObject;
+    /**
+     * Selects edges on the cap faces of a thin-walled extrusion from an open profile.
+     * @param args - Numeric indices or {@link EdgeFilterBuilder} instances to filter the selection.
+     */
+    capEdges(...args: (number | EdgeFilterBuilder)[]): ISceneObject;
     /**
      * Applies a draft (taper) angle to the extrusion walls.
      * @param value - A single angle for uniform draft, or a `[start, end]` tuple for asymmetric draft.

package/lib/dist/core/part.js

@@ -11,7 +11,7 @@ function part(name, callback) {
     const currentFile = getCurrentFile();
     const isDirectEdit = sourceLocation
         && currentFile
-        && sourceLocation.filePath.replace('virtual:live-render:', '') === currentFile;
+        && sourceLocation.filePath === currentFile;
     if (isDirectEdit) {
         const scene = getCurrentScene();
         if (scene) {

package/lib/dist/core/repeat.js

@@ -117,7 +117,8 @@ function build(context) {
                     offset = circularOptions.offset;
                 }
                 else {
-                    offset = circularOptions.angle / (count - 1);
+                    const angle = circularOptions.angle;
+                    offset = angle % 360 === 0 ? angle / count : angle / (count - 1);
                 }
                 const startOffset = centered ? -(count * offset) / 2 : 0;
                 const transformedObjects = [];

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

@@ -1,3 +1,4 @@
+import { SceneObject } from "../../common/scene-object.js";
 import { PlaneObjectBase } from "../plane-renderable-base.js";
 import { GeometrySceneObject } from "./geometry.js";
 export declare class AngledLine extends GeometrySceneObject {
@@ -7,6 +8,7 @@ export declare class AngledLine extends GeometrySceneObject {
     private targetPlane;
     constructor(length: number, angle: number, centered?: boolean, targetPlane?: PlaneObjectBase);
     build(): void;
+    createCopy(remap: Map<SceneObject, SceneObject>): SceneObject;
     compareTo(other: AngledLine): boolean;
     getType(): string;
     getUniqueType(): string;

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

@@ -47,6 +47,10 @@ export class AngledLine extends GeometrySceneObject {
         if (this.targetPlane)
             this.targetPlane.removeShapes(this);
     }
+    createCopy(remap) {
+        const targetPlane = this.targetPlane ? (remap.get(this.targetPlane) || this.targetPlane) : null;
+        return new AngledLine(this.length, this.angle, this.centered, targetPlane);
+    }
     compareTo(other) {
         if (!(other instanceof AngledLine)) {
             return false;

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

@@ -1,3 +1,4 @@
+import { SceneObject } from "../common/scene-object.js";
 import { Axis, AxisTransformOptions } from "../math/axis.js";
 import { AxisObjectBase } from "./axis-renderable-base.js";
 export declare class AxisObject extends AxisObjectBase {
@@ -5,6 +6,7 @@ export declare class AxisObject extends AxisObjectBase {
     private options?;
     constructor(axis: Axis, options?: AxisTransformOptions);
     build(): void;
+    createCopy(remap: Map<SceneObject, SceneObject>): SceneObject;
     compareTo(other: AxisObject): boolean;
     serialize(): {
         origin: import("../math/point.js").Point;

package/lib/dist/features/axis.js

@@ -18,6 +18,9 @@ export class AxisObject extends AxisObjectBase {
         edge.markAsMetaShape();
         this.addShape(edge);
     }
+    createCopy(remap) {
+        return new AxisObject(this.axis, this.options);
+    }
     compareTo(other) {
         if (!(other instanceof AxisObject)) {
             return false;

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

@@ -5,6 +5,7 @@ export declare class Color extends SceneObject {
     constructor(color: string, selection?: SceneObject);
     get selection(): SceneObject;
     build(context: BuildSceneObjectContext): void;
+    createCopy(remap: Map<SceneObject, SceneObject>): SceneObject;
     compareTo(other: Color): boolean;
     getType(): string;
     serialize(): {};

package/lib/dist/features/color.js

@@ -69,6 +69,10 @@ export class Color extends SceneObject {
             this.addShape(newSolid);
         }
     }
+    createCopy(remap) {
+        const selection = this._selection ? (remap.get(this._selection) || this._selection) : undefined;
+        return new Color(this.color, selection);
+    }
     compareTo(other) {
         if (!(other instanceof Color)) {
             return false;

package/lib/dist/features/extrude-base.d.ts

@@ -1,4 +1,5 @@
 import { Face } from "../common/face.js";
+import { Edge } from "../common/edge.js";
 import { SceneObject } from "../common/scene-object.js";
 import { Extrudable } from "../helpers/types.js";
 import { IExtrude } from "../core/interfaces.js";
@@ -30,6 +31,8 @@ export declare abstract class ExtrudeBase extends SceneObject implements IExtrud
     edges(...indices: number[]): SceneObject;
     internalFaces(...args: number[] | FaceFilterBuilder[]): SceneObject;
     internalEdges(...args: number[] | EdgeFilterBuilder[]): SceneObject;
+    capFaces(...args: number[] | FaceFilterBuilder[]): SceneObject;
+    capEdges(...args: number[] | EdgeFilterBuilder[]): SceneObject;
     private buildSuffix;
     private resolveFaces;
     private resolveEdges;
@@ -66,6 +69,16 @@ export declare abstract class ExtrudeBase extends SceneObject implements IExtrud
     getEndOffset(): number | undefined;
     getDrill(): boolean;
     protected syncWith(other: ExtrudeBase): this;
+    /**
+     * Reclassifies faces for thin open-profile extrusions into side, internal, and cap faces.
+     * Uses 2D midpoint projection (onto sketch plane) to match reference face edges to
+     * the inward/outward wire edges, then IsPartner within the solid to classify faces.
+     */
+    protected reclassifyThinFaces(remainingFaces: Face[], referenceFaces: Face[], plane: Plane, inwardEdges: Edge[], outwardEdges: Edge[]): {
+        sideFaces: Face[];
+        internalFaces: Face[];
+        capFaces: Face[];
+    };
     compareTo(other: ExtrudeBase): boolean;
     getType(): string;
 }

package/lib/dist/features/extrude-base.js

@@ -6,6 +6,7 @@ import { FaceMaker2 } from "../oc/face-maker2.js";
 import { FaceFilterBuilder } from "../filters/face/face-filter.js";
 import { EdgeFilterBuilder } from "../filters/edge/edge-filter.js";
 import { ShapeFilter } from "../filters/filter.js";
+import { EdgeOps } from "../oc/edge-ops.js";
 export class ExtrudeBase extends SceneObject {
     _extrudable = null;
     _draft;
@@ -144,6 +145,25 @@ export class ExtrudeBase extends SceneObject {
             return this.resolveEdges(edges, args);
         }, this);
     }
+    capFaces(...args) {
+        const suffix = this.buildSuffix('cap-faces', args);
+        return new LazySelectionSceneObject(`${this.generateUniqueName(suffix)}`, (parent) => {
+            const faces = parent.getState('cap-faces') || [];
+            const transform = parent.getTransform();
+            const originalFaces = transform
+                ? (this.getState('cap-faces') || [])
+                : null;
+            return this.resolveFaces(faces, args, transform, originalFaces);
+        }, this);
+    }
+    capEdges(...args) {
+        const suffix = this.buildSuffix('cap-edges', args);
+        return new LazySelectionSceneObject(`${this.generateUniqueName(suffix)}`, (parent) => {
+            const faces = parent.getState('cap-faces') || [];
+            const edges = faces.flatMap(f => f.getEdges());
+            return this.resolveEdges(edges, args);
+        }, this);
+    }
     buildSuffix(prefix, args) {
         if (args.length === 0) {
             return prefix;
@@ -321,6 +341,50 @@ export class ExtrudeBase extends SceneObject {
         this._thin = other._thin;
         return this;
     }
+    /**
+     * Reclassifies faces for thin open-profile extrusions into side, internal, and cap faces.
+     * Uses 2D midpoint projection (onto sketch plane) to match reference face edges to
+     * the inward/outward wire edges, then IsPartner within the solid to classify faces.
+     */
+    reclassifyThinFaces(remainingFaces, referenceFaces, plane, inwardEdges, outwardEdges) {
+        // Project edge midpoints to 2D on the sketch plane for height-independent matching
+        const to2D = (edge) => plane.worldToLocal(EdgeOps.getEdgeMidPointRaw(edge.getShape()));
+        const inwardMids = inwardEdges.map(to2D);
+        const outwardMids = outwardEdges.map(to2D);
+        // Find reference face edges matching inward/outward in 2D
+        const solidInwardEdges = [];
+        const solidOutwardEdges = [];
+        for (const rf of referenceFaces) {
+            for (const rfe of rf.getEdges()) {
+                const rfeMid = to2D(rfe);
+                if (inwardMids.some(mp => rfeMid.distanceTo(mp) < 1e-4)) {
+                    solidInwardEdges.push(rfe);
+                }
+                else if (outwardMids.some(mp => rfeMid.distanceTo(mp) < 1e-4)) {
+                    solidOutwardEdges.push(rfe);
+                }
+            }
+        }
+        // Classify remaining faces using IsPartner within the solid
+        const sideFaces = [];
+        const internalFaces = [];
+        const capFaces = [];
+        for (const f of remainingFaces) {
+            const faceEdges = f.getEdges();
+            const isInward = solidInwardEdges.length > 0 && faceEdges.some(fe => solidInwardEdges.some(ie => fe.getShape().IsPartner(ie.getShape())));
+            const isOutward = solidOutwardEdges.length > 0 && faceEdges.some(fe => solidOutwardEdges.some(oe => fe.getShape().IsPartner(oe.getShape())));
+            if (isInward) {
+                internalFaces.push(f);
+            }
+            else if (isOutward) {
+                sideFaces.push(f);
+            }
+            else {
+                capFaces.push(f);
+            }
+        }
+        return { sideFaces, internalFaces, capFaces };
+    }
     compareTo(other) {
         if (!super.compareTo(other)) {
             return false;

package/lib/dist/features/extrude-to-face.js

@@ -32,19 +32,39 @@ export class ExtrudeToFace extends ExtrudeBase {
         const allEndFaces = [];
         const allSideFaces = [];
         const allInternalFaces = [];
-        const faces = this.isThin()
-            ? ThinFaceMaker.make(this.extrudable.getGeometries(), plane, this._thin[0], this._thin[1])
-            : pickedFaces ?? FaceMaker2.getRegions(this.extrudable.getGeometries(), plane);
+        let faces;
+        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;
+        }
+        else {
+            faces = pickedFaces ?? FaceMaker2.getRegions(this.extrudable.getGeometries(), plane);
+        }
+        const allCapFaces = [];
         for (const startFace of faces) {
             if (isPlanar && FaceQuery.areFacePlanesParallel(startFace, targetFace)) {
                 const { shapes, extruder } = this.createSimpleExtrude(startFace, targetFace, plane);
                 for (const s of shapes) {
                     solids.push(s);
                 }
-                allStartFaces.push(...extruder.getStartFaces());
-                allEndFaces.push(...extruder.getEndFaces());
-                allSideFaces.push(...extruder.getSideFaces());
-                allInternalFaces.push(...extruder.getInternalFaces());
+                if (inwardEdges && inwardEdges.length > 0) {
+                    const result = this.reclassifyThinFaces([...extruder.getSideFaces(), ...extruder.getInternalFaces()], extruder.getStartFaces(), plane, inwardEdges, outwardEdges || []);
+                    allStartFaces.push(...extruder.getStartFaces());
+                    allEndFaces.push(...extruder.getEndFaces());
+                    allSideFaces.push(...result.sideFaces);
+                    allInternalFaces.push(...result.internalFaces);
+                    allCapFaces.push(...result.capFaces);
+                }
+                else {
+                    allStartFaces.push(...extruder.getStartFaces());
+                    allEndFaces.push(...extruder.getEndFaces());
+                    allSideFaces.push(...extruder.getSideFaces());
+                    allInternalFaces.push(...extruder.getInternalFaces());
+                }
             }
             else {
                 console.log("Creating advanced extrude for face:");
@@ -58,6 +78,7 @@ export class ExtrudeToFace extends ExtrudeBase {
         this.setState('end-faces', allEndFaces);
         this.setState('side-faces', allSideFaces);
         this.setState('internal-faces', allInternalFaces);
+        this.setState('cap-faces', allCapFaces);
         this.extrudable.removeShapes(this);
         if (this.face instanceof SceneObject) {
             this.face.removeShapes(this);

package/lib/dist/features/extrude-two-distances.js

@@ -3,6 +3,7 @@ import { fuseWithSceneObjects, cutWithSceneObjects } from "../helpers/scene-help
 import { BooleanOps } from "../oc/boolean-ops.js";
 import { Explorer } from "../oc/explorer.js";
 import { FaceMaker2 } from "../oc/face-maker2.js";
+import { EdgeOps } from "../oc/edge-ops.js";
 import { Extruder } from "./simple-extruder.js";
 import { ThinFaceMaker } from "../oc/thin-face-maker.js";
 export class ExtrudeTwoDistances extends ExtrudeBase {
@@ -20,43 +21,97 @@ export class ExtrudeTwoDistances extends ExtrudeBase {
         if (pickedFaces !== null && pickedFaces.length === 0) {
             return;
         }
-        const faces = this.isThin()
-            ? ThinFaceMaker.make(this.extrudable.getGeometries(), plane, this._thin[0], this._thin[1])
-            : pickedFaces ?? FaceMaker2.getRegions(this.extrudable.getGeometries(), plane, this.getDrill());
-        const extruder1 = new Extruder(faces, plane, this.distance1, this.getDraft(), this.getEndOffset());
+        let faces;
+        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;
+        }
+        else {
+            faces = pickedFaces ?? FaceMaker2.getRegions(this.extrudable.getGeometries(), plane, this.getDrill());
+        }
+        const draft = this.getDraft();
+        const draft1 = draft ? [draft[0], draft[0]] : undefined;
+        const draft2 = draft ? [draft[1], draft[1]] : undefined;
+        const extruder1 = new Extruder(faces, plane, this.distance1, draft1, this.getEndOffset());
         const extrusions1 = extruder1.extrude();
         const startFaces = extruder1.getEndFaces();
-        const extruder2 = new Extruder(faces, plane, -this.distance2, this.getDraft(), this.getEndOffset());
+        const extruder2 = new Extruder(faces, plane, -this.distance2, draft2, this.getEndOffset());
         const extrusions2 = extruder2.extrude();
         const endFaces = extruder2.getEndFaces();
-        const preFusionInternalFaces = [
-            ...extruder1.getInternalFaces(),
-            ...extruder2.getInternalFaces(),
-        ];
         const all = [...extrusions1, ...extrusions2];
         const { result: extrusions } = BooleanOps.fuse(all);
-        const sideFaces = [];
-        const internalFaces = [];
+        const remainingFaces = [];
+        const fusedStartFaces = [];
+        const fusedEndFaces = [];
         for (const solid of extrusions) {
             const allFaces = Explorer.findFacesWrapped(solid);
             for (const f of allFaces) {
                 const isStart = startFaces.some(sf => f.getShape().IsSame(sf.getShape()));
                 const isEnd = endFaces.some(ef => f.getShape().IsSame(ef.getShape()));
-                if (!isStart && !isEnd) {
-                    const isInternal = preFusionInternalFaces.some(pf => f.getShape().IsSame(pf.getShape()));
-                    if (isInternal) {
-                        internalFaces.push(f);
+                if (isStart) {
+                    fusedStartFaces.push(f);
+                }
+                else if (isEnd) {
+                    fusedEndFaces.push(f);
+                }
+                else {
+                    remainingFaces.push(f);
+                }
+            }
+        }
+        let sideFaces;
+        let internalFaces;
+        let capFaces = [];
+        if (inwardEdges && inwardEdges.length > 0) {
+            const result = this.reclassifyThinFaces(remainingFaces, [...fusedStartFaces, ...fusedEndFaces], plane, inwardEdges, outwardEdges || []);
+            sideFaces = result.sideFaces;
+            internalFaces = result.internalFaces;
+            capFaces = result.capFaces;
+        }
+        else {
+            const preInnerEdges = [];
+            for (const sf of extruder1.getStartFaces()) {
+                for (const wire of sf.getWires()) {
+                    if (!wire.isCW(plane.normal)) {
+                        for (const edge of wire.getEdges()) {
+                            preInnerEdges.push(edge);
+                        }
                     }
-                    else {
-                        sideFaces.push(f);
+                }
+            }
+            const fusedInnerEdges = [];
+            if (preInnerEdges.length > 0) {
+                const innerMids = preInnerEdges.map(e => plane.worldToLocal(EdgeOps.getEdgeMidPointRaw(e.getShape())));
+                for (const sf of fusedStartFaces) {
+                    for (const sfe of sf.getEdges()) {
+                        const mid = plane.worldToLocal(EdgeOps.getEdgeMidPointRaw(sfe.getShape()));
+                        if (innerMids.some(im => mid.distanceTo(im) < 1e-4)) {
+                            fusedInnerEdges.push(sfe);
+                        }
                     }
                 }
             }
+            sideFaces = [];
+            internalFaces = [];
+            for (const f of remainingFaces) {
+                const isInternal = fusedInnerEdges.length > 0 && f.getEdges().some(fe => fusedInnerEdges.some(ie => fe.getShape().IsPartner(ie.getShape())));
+                if (isInternal) {
+                    internalFaces.push(f);
+                }
+                else {
+                    sideFaces.push(f);
+                }
+            }
         }
         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);
         this.extrudable.removeShapes(this);
         if (this._operationMode === 'remove') {
             const scope = this.resolveFusionScope(context.getSceneObjects());