fluidcad 0.0.16 → 0.0.18

package/README.md

@@ -117,6 +117,50 @@ FluidCAD ships official extensions for **VS Code** and **Neovim**, but works wit
 
 ---
 
+## Tutorials
+
+Step-by-step tutorials from simple shapes to exam-level parts. [Browse all tutorials →](https://fluidcad.io/docs/tutorials/)
+
+<table>
+  <tr>
+    <td align="center" width="33%">
+      <a href="https://fluidcad.io/docs/tutorials/lantern">
+        <img src="https://fluidcad.io/img/docs/tutorials/lantern-final.png" alt="Lantern" height="180" /><br />
+        <strong>Lantern</strong>
+      </a>
+    </td>
+    <td align="center" width="33%">
+      <a href="https://fluidcad.io/docs/tutorials/ice-cube-tray">
+        <img src="https://fluidcad.io/img/docs/tutorials/ice-cube-tray-final.png" alt="Ice Cube Tray" height="180" /><br />
+        <strong>Ice Cube Tray</strong>
+      </a>
+    </td>
+    <td align="center" width="33%">
+      <a href="https://fluidcad.io/docs/tutorials/grooved-box">
+        <img src="https://fluidcad.io/img/docs/tutorials/grooved-box-final.png" alt="Grooved Box" height="180" /><br />
+        <strong>Grooved Box</strong>
+      </a>
+    </td>
+  </tr>
+  <tr>
+    <td align="center" width="33%">
+      <a href="https://fluidcad.io/docs/tutorials/flange-with-notch">
+        <img src="https://fluidcad.io/img/docs/tutorials/flange-with-notch-final.png" alt="Flange With Notch" height="180" /><br />
+        <strong>Flange With Notch</strong>
+      </a>
+    </td>
+    <td align="center" width="33%">
+      <a href="https://fluidcad.io/docs/tutorials/cswp-sample-exam">
+        <img src="https://fluidcad.io/img/docs/tutorials/cswp-sample-exam-final.png" alt="CSWP Sample Exam" height="180" /><br />
+        <strong>CSWP Sample Exam</strong>
+      </a>
+    </td>
+    <td width="33%"></td>
+  </tr>
+</table>
+
+---
+
 ## Getting Started
 
 ### 1. Create a New Project

package/bin/fluidcad.js

@@ -5,7 +5,7 @@ import { resolve, dirname } from 'path';
 import { fileURLToPath } from 'url';
 import { parseArgs } from 'util';
 import { writeFileSync, existsSync } from 'fs';
-import { createFileWatcher } from './watcher.js';
+import { createFileWatcher, findFluidFiles } from './watcher.js';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 
@@ -88,6 +88,11 @@ server.on('message', (msg) => {
     if (msg.success) {
       console.log('FluidCAD initialized successfully.');
       watcher = createFileWatcher(workspacePath, server);
+
+      const files = findFluidFiles(workspacePath);
+      if (files.length > 0) {
+        server.send({ type: 'process-file', filePath: files[0] });
+      }
     } else {
       console.error(`FluidCAD initialization failed: ${msg.error}`);
       process.exit(1);

package/bin/watcher.js

@@ -1,5 +1,6 @@
 import chokidar from 'chokidar';
-import { readFileSync } from 'fs';
+import { readFileSync, readdirSync } from 'fs';
+import { join } from 'path';
 
 /**
  * Creates a file watcher that monitors .fluid.js files in the workspace
@@ -53,3 +54,20 @@ export function createFileWatcher(workspacePath, server) {
 
   return watcher;
 }
+
+/**
+ * Finds `.fluid.js` files in the top level of the workspace directory,
+ * ignoring node_modules and .git.
+ *
+ * @param {string} workspacePath - Absolute path to the workspace directory
+ * @returns {string[]} Absolute paths to discovered `.fluid.js` files
+ */
+export function findFluidFiles(workspacePath) {
+  try {
+    return readdirSync(workspacePath)
+      .filter((f) => f.endsWith('.fluid.js'))
+      .map((f) => join(workspacePath, f));
+  } catch {
+    return [];
+  }
+}

package/lib/dist/common/breakpoint-hit.d.ts

@@ -0,0 +1,5 @@
+import { SourceLocation } from "./scene-object.js";
+export declare class BreakpointHit extends Error {
+    readonly sourceLocation: SourceLocation | null;
+    constructor(sourceLocation: SourceLocation | null);
+}

package/lib/dist/common/breakpoint-hit.js

@@ -0,0 +1,9 @@
+export class BreakpointHit extends Error {
+    sourceLocation;
+    constructor(sourceLocation) {
+        super('FluidCAD breakpoint hit');
+        this.name = 'BreakpointHit';
+        this.sourceLocation = sourceLocation;
+        Object.setPrototypeOf(this, BreakpointHit.prototype);
+    }
+}

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

@@ -0,0 +1 @@
+export declare function breakpoint(): never;

package/lib/dist/core/breakpoint.js

@@ -0,0 +1,5 @@
+import { captureSourceLocation } from "../index.js";
+import { BreakpointHit } from "../common/breakpoint-hit.js";
+export function breakpoint() {
+    throw new BreakpointHit(captureSourceLocation());
+}

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

@@ -30,3 +30,4 @@ export { default as part } from "./part.js";
 export { default as use } from "./use.js";
 export type { PartHandle } from "./part.js";
 export * from "./2d/index.js";
+export { breakpoint } from "./breakpoint.js";

package/lib/dist/core/index.js

@@ -28,3 +28,4 @@ export { default as trim } from "./trim.js";
 export { default as part } from "./part.js";
 export { default as use } from "./use.js";
 export * from "./2d/index.js";
+export { breakpoint } from "./breakpoint.js";

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

@@ -367,6 +367,43 @@ export interface IRevolve extends IFuseable {
      * @param points - 2D points in the sketch plane identifying regions to revolve.
      */
     pick(...points: Point2DLike[]): this;
+    /**
+     * Enables thin revolve mode — offsets the profile edges to create a thin-walled
+     * solid of revolution instead of revolving filled faces. Positive values offset
+     * outward, negative values offset inward.
+     * @param offset - The wall offset distance. Positive = outward, negative = inward.
+     */
+    thin(offset: number): this;
+    /**
+     * Enables thin revolve mode with two offset directions.
+     * The two offsets must go in opposite directions. If both have the same sign,
+     * the second offset is automatically flipped.
+     * @param offset1 - The first wall offset distance. Positive = outward, negative = inward.
+     * @param offset2 - The second wall offset distance, in the opposite direction of offset1.
+     */
+    thin(offset1: number, offset2: number): this;
+    /**
+     * Selects faces created inside the solid during revolution (e.g., the inner
+     * wall of a thin-walled revolve from a closed profile).
+     * @param args - Numeric indices or {@link FaceFilterBuilder} instances to filter the selection.
+     */
+    internalFaces(...args: (number | FaceFilterBuilder)[]): ISceneObject;
+    /**
+     * Selects edges bounding the internal geometry created during revolution.
+     * @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 revolve 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 revolve from an open profile.
+     * @param args - Numeric indices or {@link EdgeFilterBuilder} instances to filter the selection.
+     */
+    capEdges(...args: (number | EdgeFilterBuilder)[]): ISceneObject;
 }
 export interface ILoft extends IFuseable {
     /**
@@ -399,6 +436,43 @@ export interface ILoft extends IFuseable {
      * @param args - Numeric indices or {@link EdgeFilterBuilder} instances to filter the selection.
      */
     sideEdges(...args: (number | EdgeFilterBuilder)[]): ISceneObject;
+    /**
+     * Enables thin loft mode — offsets the profile edges of each section to create a
+     * thin-walled shell instead of lofting filled faces. All profiles must be sketches
+     * and share the same topology. Positive values offset outward, negative offsets inward.
+     * @param offset - The wall offset distance. Positive = outward, negative = inward.
+     */
+    thin(offset: number): this;
+    /**
+     * Enables thin loft mode with two offset directions.
+     * The two offsets must go in opposite directions. If both have the same sign,
+     * the second offset is automatically flipped.
+     * @param offset1 - The first wall offset distance. Positive = outward, negative = inward.
+     * @param offset2 - The second wall offset distance, in the opposite direction of offset1.
+     */
+    thin(offset1: number, offset2: number): this;
+    /**
+     * Selects faces created inside the solid during loft (e.g., the inner
+     * wall of a thin-walled loft from closed profiles).
+     * @param args - Numeric indices or {@link FaceFilterBuilder} instances to filter the selection.
+     */
+    internalFaces(...args: (number | FaceFilterBuilder)[]): ISceneObject;
+    /**
+     * Selects edges bounding the internal geometry created during loft.
+     * @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 loft from open profiles.
+     * 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 loft from open profiles.
+     * @param args - Numeric indices or {@link EdgeFilterBuilder} instances to filter the selection.
+     */
+    capEdges(...args: (number | EdgeFilterBuilder)[]): ISceneObject;
 }
 export interface ISweep extends IFuseable {
     /**
@@ -461,6 +535,32 @@ export interface ISweep extends IFuseable {
      * @param points - 2D points in the sketch plane identifying regions to sweep.
      */
     pick(...points: Point2DLike[]): this;
+    /**
+     * Enables thin sweep mode — offsets the profile edges to create a thin-walled
+     * swept shell instead of sweeping filled faces. Positive values offset outward,
+     * negative values offset inward.
+     * @param offset - The wall offset distance. Positive = outward, negative = inward.
+     */
+    thin(offset: number): this;
+    /**
+     * Enables thin sweep mode with two offset directions.
+     * The two offsets must go in opposite directions. If both have the same sign,
+     * the second offset is automatically flipped.
+     * @param offset1 - The first wall offset distance. Positive = outward, negative = inward.
+     * @param offset2 - The second wall offset distance, in the opposite direction of offset1.
+     */
+    thin(offset1: number, offset2: number): this;
+    /**
+     * Selects the cap faces at the open ends of a thin-walled sweep 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 sweep from an open profile.
+     * @param args - Numeric indices or {@link EdgeFilterBuilder} instances to filter the selection.
+     */
+    capEdges(...args: (number | EdgeFilterBuilder)[]): ISceneObject;
 }
 export interface IShell extends ISceneObject {
     /**

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

@@ -5,10 +5,10 @@ export type LinearCopyOptions = {
     centered?: boolean;
     skip?: number[][];
 } & ({
-    offset: number;
+    offset: number | number[];
     length?: never;
 } | {
-    length: number;
+    length: number | number[];
     offset?: never;
 });
 export declare class CopyLinear extends SceneObject {

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

@@ -16,19 +16,24 @@ export class CopyLinear extends SceneObject {
         if (!this.targetObjects) {
             objects = context.getActiveSceneObjects();
         }
-        let length = this.options.length || 1;
         const { count, centered, skip } = this.options;
-        // Normalize count to per-axis array
         const counts = Array.isArray(count)
             ? count
             : this.axes.map(() => count);
-        let offset;
-        if ('offset' in this.options && this.options.offset !== undefined) {
-            offset = this.options.offset;
-        }
-        else {
-            offset = length / Math.max(...counts);
-        }
+        const offsets = 'offset' in this.options && this.options.offset !== undefined
+            ? (Array.isArray(this.options.offset) ? this.options.offset : this.axes.map(() => this.options.offset))
+            : null;
+        const lengths = 'length' in this.options && this.options.length !== undefined
+            ? (Array.isArray(this.options.length) ? this.options.length : this.axes.map(() => this.options.length))
+            : null;
+        const axisOffsets = this.axes.map((_, a) => {
+            if (offsets) {
+                return offsets[a] ?? offsets[0];
+            }
+            const len = lengths ? (lengths[a] ?? lengths[0]) : 1;
+            const axisCount = counts[a];
+            return axisCount > 1 ? len / (axisCount - 1) : 0;
+        });
         // Build grid positions as cartesian product of per-axis indices (0..counts[a]-1)
         let positions = [[]];
         for (let a = 0; a < this.axes.length; a++) {
@@ -49,8 +54,9 @@ export class CopyLinear extends SceneObject {
             let matrix = Matrix4.identity();
             for (let a = 0; a < this.axes.length; a++) {
                 const axisCount = counts[a];
-                const startOffset = centered ? -(axisCount * offset) / 2 : 0;
-                const distance = startOffset + offset * pos[a];
+                const axisOffset = axisOffsets[a];
+                const startOffset = centered ? -(axisCount * axisOffset) / 2 : 0;
+                const distance = startOffset + axisOffset * pos[a];
                 const translation = this.axes[a].direction.multiply(distance);
                 matrix = matrix.multiply(Matrix4.fromTranslationVector(translation));
             }

package/lib/dist/features/copy-linear2d.js

@@ -20,19 +20,24 @@ export class CopyLinear2D extends GeometrySceneObject {
         else {
             objects = allSiblings;
         }
-        let length = this.options.length || 1;
         const { count, centered, skip } = this.options;
-        // Normalize count to per-axis array
         const counts = Array.isArray(count)
             ? count
             : this.axes.map(() => count);
-        let offset;
-        if ('offset' in this.options && this.options.offset !== undefined) {
-            offset = this.options.offset;
-        }
-        else {
-            offset = length / Math.max(...counts);
-        }
+        const offsets = 'offset' in this.options && this.options.offset !== undefined
+            ? (Array.isArray(this.options.offset) ? this.options.offset : this.axes.map(() => this.options.offset))
+            : null;
+        const lengths = 'length' in this.options && this.options.length !== undefined
+            ? (Array.isArray(this.options.length) ? this.options.length : this.axes.map(() => this.options.length))
+            : null;
+        const axisOffsets = this.axes.map((_, a) => {
+            if (offsets) {
+                return offsets[a] ?? offsets[0];
+            }
+            const len = lengths ? (lengths[a] ?? lengths[0]) : 1;
+            const axisCount = counts[a];
+            return axisCount > 1 ? len / (axisCount - 1) : 0;
+        });
         // Build grid positions as cartesian product of per-axis indices (0..counts[a]-1)
         let positions = [[]];
         for (let a = 0; a < this.axes.length; a++) {
@@ -53,8 +58,9 @@ export class CopyLinear2D extends GeometrySceneObject {
             let matrix = Matrix4.identity();
             for (let a = 0; a < this.axes.length; a++) {
                 const axisCount = counts[a];
-                const startOffset = centered ? -(axisCount * offset) / 2 : 0;
-                const distance = startOffset + offset * pos[a];
+                const axisOffset = axisOffsets[a];
+                const startOffset = centered ? -(axisCount * axisOffset) / 2 : 0;
+                const distance = startOffset + axisOffset * pos[a];
                 const translation = this.axes[a].direction.multiply(distance);
                 matrix = matrix.multiply(Matrix4.fromTranslationVector(translation));
             }

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

@@ -236,7 +236,7 @@ export class ExtrudeBase extends SceneObject {
             pickPoints: this.isPicking()
                 ? this._pickPoints.map(p => { const pt = p.asPoint2D(); return [pt.x, pt.y]; })
                 : undefined,
-            trigger: 'region-picking',
+            trigger: this.isThin() ? undefined : 'region-picking',
             pickPlane: plane ? {
                 origin: plane.origin,
                 xDirection: plane.xDirection,

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

@@ -1,27 +1,21 @@
 import { BuildSceneObjectContext, SceneObject } from "../common/scene-object.js";
-import { FaceFilterBuilder } from "../filters/face/face-filter.js";
-import { EdgeFilterBuilder } from "../filters/edge/edge-filter.js";
 import { ILoft } from "../core/interfaces.js";
-export declare class Loft extends SceneObject implements ILoft {
+import { ExtrudeBase } from "./extrude-base.js";
+export declare class Loft extends ExtrudeBase implements ILoft {
     private _profiles;
     constructor(...profiles: SceneObject[]);
     get profiles(): SceneObject[];
     build(context: BuildSceneObjectContext): void;
+    private buildThinLoft;
     private getProfilePlane;
-    startFaces(...args: (number | FaceFilterBuilder)[]): SceneObject;
-    endFaces(...args: (number | FaceFilterBuilder)[]): SceneObject;
-    sideFaces(...args: (number | FaceFilterBuilder)[]): SceneObject;
-    startEdges(...args: (number | EdgeFilterBuilder)[]): SceneObject;
-    endEdges(...args: (number | EdgeFilterBuilder)[]): SceneObject;
-    sideEdges(...args: (number | EdgeFilterBuilder)[]): SceneObject;
-    private buildSuffix;
-    private resolveEdges;
-    private resolveFaces;
     private getWiresFromSceneObject;
+    getDependencies(): SceneObject[];
+    createCopy(remap: Map<SceneObject, SceneObject>): SceneObject;
     compareTo(other: Loft): boolean;
     getType(): string;
     serialize(): {
         profiles: any[];
         operationMode: "new" | "remove";
+        thin: [number, number] | [number];
     };
 }

package/lib/dist/features/loft.js

@@ -1,14 +1,12 @@
-import { SceneObject } from "../common/scene-object.js";
 import { Explorer } from "../oc/explorer.js";
 import { LoftOps } from "../oc/loft-ops.js";
 import { FaceMaker2 } from "../oc/face-maker2.js";
-import { LazySelectionSceneObject } from "./lazy-scene-object.js";
-import { FaceFilterBuilder } from "../filters/face/face-filter.js";
-import { EdgeFilterBuilder } from "../filters/edge/edge-filter.js";
-import { ShapeFilter } from "../filters/filter.js";
 import { FaceOps } from "../oc/face-ops.js";
+import { BooleanOps } from "../oc/boolean-ops.js";
 import { fuseWithSceneObjects, cutWithSceneObjects } from "../helpers/scene-helpers.js";
-export class Loft extends SceneObject {
+import { ExtrudeBase } from "./extrude-base.js";
+import { ThinFaceMaker } from "../oc/thin-face-maker.js";
+export class Loft extends ExtrudeBase {
     _profiles = [];
     constructor(...profiles) {
         super();
@@ -21,17 +19,23 @@ export class Loft extends SceneObject {
         if (this.profiles.length < 2) {
             throw new Error("Loft requires at least two profiles.");
         }
-        const allWires = [];
-        for (const profile of this.profiles) {
-            const wires = this.getWiresFromSceneObject(profile);
-            if (wires.length === 0) {
-                throw new Error("Could not extract wire from profile.");
-            }
-            for (const wire of wires) {
-                allWires.push(wire);
+        let newShapes;
+        if (this.isThin()) {
+            newShapes = this.buildThinLoft();
+        }
+        else {
+            const allWires = [];
+            for (const profile of this.profiles) {
+                const wires = this.getWiresFromSceneObject(profile);
+                if (wires.length === 0) {
+                    throw new Error("Could not extract wire from profile.");
+                }
+                for (const wire of wires) {
+                    allWires.push(wire);
+                }
             }
+            newShapes = LoftOps.makeLoft(allWires);
         }
-        const newShapes = LoftOps.makeLoft(allWires);
         for (const profile of this.profiles) {
             profile.removeShapes(this);
         }
@@ -78,124 +82,39 @@ export class Loft extends SceneObject {
         }
         this.addShapes(fusionResult.newShapes);
     }
-    getProfilePlane(profile) {
-        if ('getPlane' in profile && typeof profile.getPlane === 'function') {
-            return profile.getPlane();
-        }
-        return null;
-    }
-    startFaces(...args) {
-        const suffix = this.buildSuffix('start-faces', args);
-        return new LazySelectionSceneObject(`${this.generateUniqueName(suffix)}`, (parent) => {
-            const faces = parent.getState('start-faces') || [];
-            const transform = parent.getTransform();
-            const originalFaces = transform
-                ? (this.getState('start-faces') || [])
-                : null;
-            return this.resolveFaces(faces, args, transform, originalFaces);
-        }, this);
-    }
-    endFaces(...args) {
-        const suffix = this.buildSuffix('end-faces', args);
-        return new LazySelectionSceneObject(`${this.generateUniqueName(suffix)}`, (parent) => {
-            const faces = parent.getState('end-faces') || [];
-            const transform = parent.getTransform();
-            const originalFaces = transform
-                ? (this.getState('end-faces') || [])
-                : null;
-            return this.resolveFaces(faces, args, transform, originalFaces);
-        }, this);
-    }
-    sideFaces(...args) {
-        const suffix = this.buildSuffix('side-faces', args);
-        return new LazySelectionSceneObject(`${this.generateUniqueName(suffix)}`, (parent) => {
-            const faces = parent.getState('side-faces') || [];
-            const transform = parent.getTransform();
-            const originalFaces = transform
-                ? (this.getState('side-faces') || [])
-                : null;
-            return this.resolveFaces(faces, args, transform, originalFaces);
-        }, this);
-    }
-    startEdges(...args) {
-        const suffix = this.buildSuffix('start-edges', args);
-        return new LazySelectionSceneObject(`${this.generateUniqueName(suffix)}`, (parent) => {
-            const faces = parent.getState('start-faces') || [];
-            const edges = faces.flatMap(f => f.getEdges());
-            const transform = parent.getTransform();
-            const originalEdges = transform
-                ? (this.getState('start-faces') || []).flatMap(f => f.getEdges())
-                : null;
-            return this.resolveEdges(edges, args, transform, originalEdges);
-        }, this);
-    }
-    endEdges(...args) {
-        const suffix = this.buildSuffix('end-edges', args);
-        return new LazySelectionSceneObject(`${this.generateUniqueName(suffix)}`, (parent) => {
-            const faces = parent.getState('end-faces') || [];
-            const edges = faces.flatMap(f => f.getEdges());
-            const transform = parent.getTransform();
-            const originalEdges = transform
-                ? (this.getState('end-faces') || []).flatMap(f => f.getEdges())
-                : null;
-            return this.resolveEdges(edges, args, transform, originalEdges);
-        }, this);
-    }
-    sideEdges(...args) {
-        const suffix = this.buildSuffix('side-edges', args);
-        return new LazySelectionSceneObject(`${this.generateUniqueName(suffix)}`, (parent) => {
-            const sideFaces = parent.getState('side-faces') || [];
-            const startFaces = parent.getState('start-faces') || [];
-            const endFaces = parent.getState('end-faces') || [];
-            const excludedEdges = [...startFaces, ...endFaces].flatMap(f => f.getEdges());
-            const edges = sideFaces.flatMap(f => f.getEdges())
-                .filter(e => !excludedEdges.some(ex => e.getShape().IsSame(ex.getShape())))
-                .filter((e, i, arr) => arr.findIndex(o => o.getShape().IsSame(e.getShape())) === i);
-            return this.resolveEdges(edges, args);
-        }, this);
-    }
-    buildSuffix(prefix, args) {
-        if (args.length === 0) {
-            return prefix;
-        }
-        const key = args.map(a => typeof a === 'number' ? a : 'f').join('-');
-        return `${prefix}-${key}`;
-    }
-    resolveEdges(shapes, args, transform = null, originalShapes = null) {
-        if (args.length === 0) {
-            return shapes;
-        }
-        if (args.every(a => typeof a === 'number')) {
-            const indices = args;
-            let filters = indices.map(i => new EdgeFilterBuilder().atIndex(i, shapes, originalShapes));
-            if (transform) {
-                filters = filters.map(f => f.transform(transform));
+    buildThinLoft() {
+        const outerWires = [];
+        const innerWires = [];
+        for (const profile of this.profiles) {
+            if (!profile.isExtrudable()) {
+                throw new Error("Thin loft requires all profiles to be sketches.");
+            }
+            const extrudable = profile;
+            const profilePlane = extrudable.getPlane();
+            const thinResult = ThinFaceMaker.make(extrudable.getGeometries(), profilePlane, this._thin[0], this._thin[1]);
+            for (const face of thinResult.faces) {
+                const wires = face.getWires();
+                outerWires.push(wires[0]);
+                if (wires.length > 1) {
+                    innerWires.push(wires[1]);
+                }
             }
-            return new ShapeFilter(shapes, ...filters).apply();
         }
-        let filters = args.filter(a => a instanceof EdgeFilterBuilder);
-        if (transform) {
-            filters = filters.map(f => f.transform(transform));
+        const outerSolids = LoftOps.makeLoft(outerWires);
+        if (innerWires.length > 0 && innerWires.length === outerWires.length) {
+            const innerSolids = LoftOps.makeLoft(innerWires);
+            const { result: outerFused } = BooleanOps.fuse(outerSolids);
+            const { result: innerFused } = BooleanOps.fuse(innerSolids);
+            const cutResult = BooleanOps.cutShapes(outerFused[0], innerFused[0]);
+            return [cutResult];
         }
-        return new ShapeFilter(shapes, ...filters).apply();
+        return outerSolids;
     }
-    resolveFaces(shapes, args, transform = null, originalShapes = null) {
-        if (args.length === 0) {
-            return shapes;
-        }
-        if (args.every(a => typeof a === 'number')) {
-            const indices = args;
-            let filters = indices.map(i => new FaceFilterBuilder().atIndex(i, shapes, originalShapes));
-            if (transform) {
-                filters = filters.map(f => f.transform(transform));
-            }
-            return new ShapeFilter(shapes, ...filters).apply();
-        }
-        let filters = args.filter(a => a instanceof FaceFilterBuilder);
-        if (transform) {
-            filters = filters.map(f => f.transform(transform));
+    getProfilePlane(profile) {
+        if ('getPlane' in profile && typeof profile.getPlane === 'function') {
+            return profile.getPlane();
         }
-        return new ShapeFilter(shapes, ...filters).apply();
+        return null;
     }
     getWiresFromSceneObject(obj) {
         const shapes = obj.getShapes({ excludeMeta: false });
@@ -245,6 +164,13 @@ export class Loft extends SceneObject {
         }
         return [];
     }
+    getDependencies() {
+        return [...this._profiles];
+    }
+    createCopy(remap) {
+        const profiles = this._profiles.map(p => remap.get(p) || p);
+        return new Loft(...profiles).syncWith(this);
+    }
     compareTo(other) {
         if (!(other instanceof Loft)) {
             return false;
@@ -269,6 +195,7 @@ export class Loft extends SceneObject {
         return {
             profiles: this.profiles.map(f => f.serialize()),
             operationMode: this._operationMode !== 'add' ? this._operationMode : undefined,
+            thin: this._thin,
         };
     }
 }

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

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