fluidcad 0.0.37 → 0.0.39

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

@@ -1,9 +1,11 @@
+import { SceneObject } from "../../common/scene-object.js";
 import { GeometrySceneObject } from "./geometry.js";
 export type ConnectMode = 'line' | 'arc';
 export declare class Connect extends GeometrySceneObject {
     private mode;
     constructor(mode?: ConnectMode);
     build(): void;
+    createCopy(remap: Map<SceneObject, SceneObject>): SceneObject;
     compareTo(other: Connect): boolean;
     getType(): string;
     serialize(): {

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

@@ -85,6 +85,9 @@ export class Connect extends GeometrySceneObject {
         }
         this.addShape(wire);
     }
+    createCopy(remap) {
+        return new Connect(this.mode);
+    }
     compareTo(other) {
         if (!(other instanceof Connect)) {
             return false;

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

@@ -2,6 +2,7 @@ import { Vertex } from "../../common/vertex.js";
 import { SectionOps } from "../../oc/section-ops.js";
 import { WireOps } from "../../oc/wire-ops.js";
 import { ExtrudableGeometryBase } from "./extrudable-base.js";
+import { SelectSceneObject } from "../select.js";
 export class Intersect extends ExtrudableGeometryBase {
     sourceObjects;
     constructor(sourceObjects, targetPlane = null) {
@@ -33,7 +34,9 @@ export class Intersect extends ExtrudableGeometryBase {
             }
         }
         for (const obj of this.sourceObjects) {
-            obj.removeShapes(this);
+            if (obj instanceof SelectSceneObject) {
+                obj.removeShapes(this);
+            }
         }
         if (this.targetPlane) {
             this.targetPlane.removeShapes(this);

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

@@ -55,9 +55,9 @@ export class Offset extends ExtrudableGeometryBase {
             });
         }
         let lastOffsetWire = null;
+        const plane = this.getPlane();
         for (const wireInfo of wires) {
-            const isOpen = !wireInfo.wire.isClosed();
-            const offsetWire = WireOps.offsetWire(wireInfo.wire, this.distance, isOpen);
+            const offsetWire = WireOps.offsetWireOnPlane(wireInfo.wire, this.distance, wireInfo.wire.isClosed(), plane);
             lastOffsetWire = offsetWire;
             const edges = offsetWire.getEdges();
             for (const edge of edges) {

package/lib/dist/features/frozen-geometry.d.ts

@@ -0,0 +1,29 @@
+import { BuildSceneObjectContext, SceneObject } from "../common/scene-object.js";
+import { TransformablePrimitive } from "../common/transformable-primitive.js";
+/**
+ * A clone-only stand-in for sketch geometry that a repeated feature references
+ * but that lives in a sketch *outside* the cloned set — e.g. a `sweep` whose
+ * path is `otherSketch.regions.foo`.
+ *
+ * Such geometry cannot be rebuilt during the clone: a 2D curve resolves its
+ * plane by walking up to its owning `Sketch` (see GeometrySceneObject.sketch),
+ * and its pen position depends on sibling curves that are not part of the
+ * clone. Cloning it out of its sketch leaves it parented under the repeat
+ * container with no sketch ancestor, so `this.sketch` is `null` and build
+ * throws "Cannot read properties of null (reading 'getPlane')".
+ *
+ * Instead we freeze the source's already-built edges (which are final,
+ * world-space, and already incorporate any fillet/trim) and bake in the
+ * per-instance clone transform — exactly like cloned primitives
+ * (cylinder/sphere) do via {@link TransformablePrimitive.addPrimitiveShape}.
+ */
+export declare class FrozenGeometry extends TransformablePrimitive {
+    private source;
+    constructor(source: SceneObject);
+    build(context?: BuildSceneObjectContext): void;
+    getDependencies(): SceneObject[];
+    createCopy(remap: Map<SceneObject, SceneObject>): SceneObject;
+    compareTo(other: SceneObject): boolean;
+    getType(): string;
+    serialize(): {};
+}

package/lib/dist/features/frozen-geometry.js

@@ -0,0 +1,62 @@
+import { TransformablePrimitive } from "../common/transformable-primitive.js";
+/**
+ * A clone-only stand-in for sketch geometry that a repeated feature references
+ * but that lives in a sketch *outside* the cloned set — e.g. a `sweep` whose
+ * path is `otherSketch.regions.foo`.
+ *
+ * Such geometry cannot be rebuilt during the clone: a 2D curve resolves its
+ * plane by walking up to its owning `Sketch` (see GeometrySceneObject.sketch),
+ * and its pen position depends on sibling curves that are not part of the
+ * clone. Cloning it out of its sketch leaves it parented under the repeat
+ * container with no sketch ancestor, so `this.sketch` is `null` and build
+ * throws "Cannot read properties of null (reading 'getPlane')".
+ *
+ * Instead we freeze the source's already-built edges (which are final,
+ * world-space, and already incorporate any fillet/trim) and bake in the
+ * per-instance clone transform — exactly like cloned primitives
+ * (cylinder/sphere) do via {@link TransformablePrimitive.addPrimitiveShape}.
+ */
+export class FrozenGeometry extends TransformablePrimitive {
+    source;
+    constructor(source) {
+        super();
+        this.source = source;
+    }
+    build(context) {
+        // Read the source's raw built edges rather than getShapes(): the original
+        // feature that consumes this geometry (e.g. the un-cloned sweep) may have
+        // marked it removed via removeShapes(), which getShapes() filters out. The
+        // edges themselves are unchanged, so we still want them — skipping only
+        // meta/guide shapes, matching how a spine/region is normally read.
+        for (const shape of this.source.getAddedShapes()) {
+            if (shape.isMetaShape() || shape.isGuideShape()) {
+                continue;
+            }
+            this.addPrimitiveShape(shape, context);
+        }
+    }
+    getDependencies() {
+        // The source is the pre-existing original, not part of the clone set; it is
+        // built earlier in the scene order, so we read its shapes at build time
+        // rather than depending on a clone of it.
+        return [];
+    }
+    createCopy(remap) {
+        return new FrozenGeometry(this.source).syncPrimitiveWith(this);
+    }
+    compareTo(other) {
+        if (!(other instanceof FrozenGeometry)) {
+            return false;
+        }
+        if (!super.compareTo(other)) {
+            return false;
+        }
+        return this.source.compareTo(other.source);
+    }
+    getType() {
+        return "frozen-geometry";
+    }
+    serialize() {
+        return {};
+    }
+}

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

@@ -1,21 +1,58 @@
 import { BuildSceneObjectContext, SceneObject } from "../common/scene-object.js";
-import { ILoft } from "../core/interfaces.js";
+import { LoftEndCondition } from "../oc/loft-ops.js";
+import { ILoft, LoftConditionType } from "../core/interfaces.js";
+import { type NumberParam } from "../core/param.js";
 import { ExtrudeBase } from "./extrude-base.js";
 export declare class Loft extends ExtrudeBase implements ILoft {
     private _profiles;
+    private _guides;
+    private _startCondition?;
+    private _endCondition?;
     constructor(...profiles: SceneObject[]);
     get profiles(): SceneObject[];
+    /**
+     * Adds side guide curves the loft surface must follow. FluidCAD supports
+     * one or two guides (the underlying OCC algorithm has no notion of more);
+     * each guide must pass through every profile.
+     */
+    guides(...guides: SceneObject[]): this;
+    /**
+     * Constrains how the surface leaves the first profile: 'normal' takes off
+     * perpendicular to the profile plane, 'tangent' takes off inside the
+     * profile plane (outward), 'none' clears the constraint. The magnitude
+     * scales the takeoff strength (default 1).
+     */
+    startCondition(type: LoftConditionType, magnitude?: NumberParam): this;
+    /**
+     * Constrains how the surface arrives at the last profile — see
+     * {@link startCondition}.
+     */
+    endCondition(type: LoftConditionType, magnitude?: NumberParam): this;
+    private static resolveCondition;
+    private hasConditions;
     validate(): void;
     build(context: BuildSceneObjectContext): void;
+    /**
+     * The options for `LoftOps.makeLoft`, with guide objects resolved to wires.
+     * A single guide argument may carry several separate curves (e.g. a sketch
+     * with a curve and its mirror) — each connected chain counts as one guide.
+     * Returns undefined for a plain loft, keeping the legacy multi-wire path
+     * untouched.
+     */
+    private resolveLoftOptions;
     private buildThinLoft;
     private getProfilePlane;
     private getWiresFromSceneObject;
     getDependencies(): SceneObject[];
     createCopy(remap: Map<SceneObject, SceneObject>): SceneObject;
     compareTo(other: Loft): boolean;
+    private static conditionsEqual;
     getType(): string;
     serialize(): {
         profiles: any[];
+        guides: any[];
+        startCondition: LoftEndCondition;
+        endCondition: LoftEndCondition;
         operationMode: "new" | "remove";
         thin: [number, number] | [number];
     };

package/lib/dist/features/loft.js

@@ -3,12 +3,16 @@ import { LoftOps } from "../oc/loft-ops.js";
 import { FaceMaker2 } from "../oc/face-maker2.js";
 import { FaceOps } from "../oc/face-ops.js";
 import { BooleanOps } from "../oc/boolean-ops.js";
-import { fuseWithSceneObjects, cutWithSceneObjects } from "../helpers/scene-helpers.js";
+import { resolveParam } from "../core/param.js";
+import { fuseWithSceneObjects, cutWithSceneObjects, wiresFromSceneObjectEdges } from "../helpers/scene-helpers.js";
 import { ExtrudeBase } from "./extrude-base.js";
 import { ThinFaceMaker } from "../oc/thin-face-maker.js";
 import { requireShapes } from "../common/operand-check.js";
 export class Loft extends ExtrudeBase {
     _profiles = [];
+    _guides = [];
+    _startCondition;
+    _endCondition;
     constructor(...profiles) {
         super();
         this._profiles = profiles;
@@ -16,19 +20,78 @@ export class Loft extends ExtrudeBase {
     get profiles() {
         return this._profiles;
     }
+    /**
+     * Adds side guide curves the loft surface must follow. FluidCAD supports
+     * one or two guides (the underlying OCC algorithm has no notion of more);
+     * each guide must pass through every profile.
+     */
+    guides(...guides) {
+        if (guides.length === 0) {
+            throw new Error("loft.guides: provide at least one guide curve.");
+        }
+        this._guides = guides;
+        return this;
+    }
+    /**
+     * Constrains how the surface leaves the first profile: 'normal' takes off
+     * perpendicular to the profile plane, 'tangent' takes off inside the
+     * profile plane (outward), 'none' clears the constraint. The magnitude
+     * scales the takeoff strength (default 1).
+     */
+    startCondition(type, magnitude) {
+        this._startCondition = Loft.resolveCondition("startCondition", type, magnitude);
+        return this;
+    }
+    /**
+     * Constrains how the surface arrives at the last profile — see
+     * {@link startCondition}.
+     */
+    endCondition(type, magnitude) {
+        this._endCondition = Loft.resolveCondition("endCondition", type, magnitude);
+        return this;
+    }
+    static resolveCondition(method, type, magnitude) {
+        if (type === "none") {
+            if (magnitude !== undefined) {
+                throw new Error(`loft.${method}: magnitude has no effect with 'none'.`);
+            }
+            return undefined;
+        }
+        if (type !== "normal" && type !== "tangent") {
+            throw new Error(`loft.${method}: expected 'none', 'normal' or 'tangent', got '${type}'.`);
+        }
+        const value = magnitude === undefined ? 1 : resolveParam(magnitude);
+        if (value === 0) {
+            throw new Error(`loft.${method}: magnitude must be non-zero.`);
+        }
+        return { kind: type, magnitude: value };
+    }
+    hasConditions() {
+        return this._startCondition !== undefined || this._endCondition !== undefined;
+    }
     validate() {
         for (let i = 0; i < this._profiles.length; i++) {
             requireShapes(this._profiles[i], `profile ${i + 1}`, "loft");
         }
+        for (let i = 0; i < this._guides.length; i++) {
+            requireShapes(this._guides[i], `guide ${i + 1}`, "loft");
+        }
+        if (this._guides.length > 2) {
+            throw new Error("Loft supports at most two guide curves.");
+        }
+        if (this._guides.length > 0 && this.isThin()) {
+            throw new Error("Loft guides cannot be combined with thin mode.");
+        }
     }
     build(context) {
         if (this.profiles.length < 2) {
             throw new Error("Loft requires at least two profiles.");
         }
         const p = context.getProfiler();
+        const options = p.record('Resolve loft options', () => this.resolveLoftOptions());
         let newShapes;
         if (this.isThin()) {
-            newShapes = p.record('Build thin loft', () => this.buildThinLoft());
+            newShapes = p.record('Build thin loft', () => this.buildThinLoft(options));
         }
         else {
             const allWires = [];
@@ -37,15 +100,21 @@ export class Loft extends ExtrudeBase {
                 if (wires.length === 0) {
                     throw new Error("Could not extract wire from profile.");
                 }
+                if (options && wires.length !== 1) {
+                    throw new Error("Loft with guides or start/end conditions requires exactly one region per profile.");
+                }
                 for (const wire of wires) {
                     allWires.push(wire);
                 }
             }
-            newShapes = p.record('Make loft', () => LoftOps.makeLoft(allWires));
+            newShapes = p.record('Make loft', () => LoftOps.makeLoft(allWires, options));
         }
         for (const profile of this.profiles) {
             profile.removeShapes(this);
         }
+        for (const guide of this._guides) {
+            guide.removeShapes(this);
+        }
         // Classify faces into start/end/side using profile planes
         const firstPlane = this.getProfilePlane(this.profiles[0]);
         const lastPlane = this.getProfilePlane(this.profiles[this.profiles.length - 1]);
@@ -102,7 +171,31 @@ export class Loft extends ExtrudeBase {
         this.classifyExtrudeEdges();
         this.setFinalShapes(this.getShapes());
     }
-    buildThinLoft() {
+    /**
+     * The options for `LoftOps.makeLoft`, with guide objects resolved to wires.
+     * A single guide argument may carry several separate curves (e.g. a sketch
+     * with a curve and its mirror) — each connected chain counts as one guide.
+     * Returns undefined for a plain loft, keeping the legacy multi-wire path
+     * untouched.
+     */
+    resolveLoftOptions() {
+        if (this._guides.length === 0 && !this.hasConditions()) {
+            return undefined;
+        }
+        let guides;
+        if (this._guides.length > 0) {
+            guides = this._guides.flatMap((guide, i) => wiresFromSceneObjectEdges(guide, `loft guide ${i + 1}`));
+            if (guides.length > 2) {
+                throw new Error(`Loft supports at most two guide curves, got ${guides.length}.`);
+            }
+        }
+        return {
+            startCondition: this._startCondition,
+            endCondition: this._endCondition,
+            guides,
+        };
+    }
+    buildThinLoft(options) {
         const outerWires = [];
         const innerWires = [];
         for (const profile of this.profiles) {
@@ -120,9 +213,15 @@ export class Loft extends ExtrudeBase {
                 }
             }
         }
-        const outerSolids = LoftOps.makeLoft(outerWires);
+        // With conditions, both walls come from the in-house skin — assemble the
+        // thin solid directly (walls + ring caps). Booleans between two
+        // nearly-parallel B-spline shells take OCC seconds.
+        if (options && innerWires.length > 0 && innerWires.length === outerWires.length) {
+            return LoftOps.makeThinLoft(outerWires, innerWires, options);
+        }
+        const outerSolids = LoftOps.makeLoft(outerWires, options);
         if (innerWires.length > 0 && innerWires.length === outerWires.length) {
-            const innerSolids = LoftOps.makeLoft(innerWires);
+            const innerSolids = LoftOps.makeLoft(innerWires, options);
             const outerFuse = BooleanOps.fuse(outerSolids);
             const innerFuse = BooleanOps.fuse(innerSolids);
             const cutResult = BooleanOps.cutShapes(outerFuse.result[0], innerFuse.result[0]);
@@ -187,11 +286,16 @@ export class Loft extends ExtrudeBase {
         return [];
     }
     getDependencies() {
-        return [...this._profiles];
+        return [...this._profiles, ...this._guides];
     }
     createCopy(remap) {
         const profiles = this._profiles.map(p => remap.get(p) || p);
-        return new Loft(...profiles).syncWith(this);
+        const copy = new Loft(...profiles);
+        copy.syncWith(this);
+        copy._guides = this._guides.map(g => remap.get(g) || g);
+        copy._startCondition = this._startCondition ? { ...this._startCondition } : undefined;
+        copy._endCondition = this._endCondition ? { ...this._endCondition } : undefined;
+        return copy;
     }
     compareTo(other) {
         if (!(other instanceof Loft)) {
@@ -208,14 +312,35 @@ export class Loft extends ExtrudeBase {
                 return false;
             }
         }
+        if (this._guides.length !== other._guides.length) {
+            return false;
+        }
+        for (let i = 0; i < this._guides.length; i++) {
+            if (!this._guides[i].compareTo(other._guides[i])) {
+                return false;
+            }
+        }
+        if (!Loft.conditionsEqual(this._startCondition, other._startCondition)
+            || !Loft.conditionsEqual(this._endCondition, other._endCondition)) {
+            return false;
+        }
         return true;
     }
+    static conditionsEqual(a, b) {
+        if (a === undefined || b === undefined) {
+            return a === b;
+        }
+        return a.kind === b.kind && a.magnitude === b.magnitude;
+    }
     getType() {
         return "loft";
     }
     serialize() {
         return {
             profiles: this.profiles.map(f => f.serialize()),
+            guides: this._guides.length > 0 ? this._guides.map(g => g.serialize()) : undefined,
+            startCondition: this._startCondition,
+            endCondition: this._endCondition,
             operationMode: this._operationMode !== 'add' ? this._operationMode : undefined,
             thin: this._thin,
         };

package/lib/dist/features/plane-from-object.d.ts

@@ -1,15 +1,27 @@
 import { BuildSceneObjectContext, SceneObject } from "../common/scene-object.js";
-import { PlaneRenderableOptions } from "../core/plane.js";
+import { EdgePlanePosition, PlaneRenderableOptions } from "../core/plane.js";
 import { PlaneObjectBase } from "./plane-renderable-base.js";
 import { Face } from "../common/face.js";
 import { Point } from "../math/point.js";
 import { Plane } from "../math/plane.js";
 export declare class PlaneFromObject extends PlaneObjectBase {
     sourceObject: SceneObject;
-    options?: PlaneRenderableOptions;
-    constructor(sourceObject: SceneObject, options?: PlaneRenderableOptions);
+    optionsOrPosition?: PlaneRenderableOptions | EdgePlanePosition;
+    constructor(sourceObject: SceneObject, optionsOrPosition?: PlaneRenderableOptions | EdgePlanePosition);
     validate(): void;
     build(context?: BuildSceneObjectContext): void;
+    /**
+     * Builds a plane normal to `edge` at the configured position. The edge
+     * tangent at that point becomes the plane normal; the in-plane axes are
+     * an arbitrary (but deterministic) basis around it.
+     */
+    private buildFromEdge;
+    /**
+     * Resolves the second argument for a face/plane source. A bare number is a
+     * normal-offset distance; a string position is only meaningful for edges
+     * and is rejected here.
+     */
+    private faceOptions;
     getFromSceneObject(sceneObject: SceneObject): {
         plane: Plane;
         sourceFace: Face;
@@ -24,7 +36,7 @@ export declare class PlaneFromObject extends PlaneObjectBase {
         xDirection: import("../math/vector3d.js").Vector3d;
         yDirection: import("../math/vector3d.js").Vector3d;
         normal: import("../math/vector3d.js").Vector3d;
-        options: import("../math/plane.js").PlaneTransformOptions;
+        options: import("../math/plane.js").PlaneTransformOptions | EdgePlanePosition;
         center: any;
     };
 }

package/lib/dist/features/plane-from-object.js

@@ -1,15 +1,18 @@
 import { PlaneObjectBase } from "./plane-renderable-base.js";
 import { FaceOps } from "../oc/face-ops.js";
 import { ShapeOps } from "../oc/shape-ops.js";
+import { WireOps } from "../oc/wire-ops.js";
+import { PathSampler } from "../oc/path-sampler.js";
 import { Point } from "../math/point.js";
+import { Plane } from "../math/plane.js";
 import { requireShapes } from "../common/operand-check.js";
 export class PlaneFromObject extends PlaneObjectBase {
     sourceObject;
-    options;
-    constructor(sourceObject, options) {
+    optionsOrPosition;
+    constructor(sourceObject, optionsOrPosition) {
         super();
         this.sourceObject = sourceObject;
-        this.options = options;
+        this.optionsOrPosition = optionsOrPosition;
     }
     validate() {
         // PlaneObjectBase sources expose the plane directly — no shapes required.
@@ -19,6 +22,17 @@ export class PlaneFromObject extends PlaneObjectBase {
         requireShapes(this.sourceObject, "source", "plane");
     }
     build(context) {
+        // An edge source produces a plane normal to the edge at a position along
+        // it. The face-vs-edge decision is deferred to here (rather than the
+        // plane() builder) because the source shape type is only known once the
+        // selection has been resolved.
+        if (!(this.sourceObject instanceof PlaneObjectBase)) {
+            const shapes = this.sourceObject.getShapes({ excludeGuide: false });
+            if (shapes.length === 1 && shapes[0].isEdge()) {
+                this.buildFromEdge(context, shapes[0]);
+                return;
+            }
+        }
         let plane;
         let sourceFace;
         let center;
@@ -36,10 +50,11 @@ export class PlaneFromObject extends PlaneObjectBase {
             const bbox = ShapeOps.getBoundingBox(sourceFace.getShape());
             center = new Point(bbox.centerX, bbox.centerY, bbox.centerZ);
         }
-        if (this.options) {
+        const options = this.faceOptions();
+        if (options) {
             // Apply the same transform to the center so the preview face stays on
             // the rotated plane instead of floating at its pre-rotation position.
-            const matrix = plane.getTransformMatrix(this.options);
+            const matrix = plane.getTransformMatrix(options);
             plane = plane.applyMatrix(matrix);
             if (center) {
                 center = center.transform(matrix);
@@ -60,6 +75,53 @@ export class PlaneFromObject extends PlaneObjectBase {
         face.markAsMetaShape();
         this.addShape(face);
     }
+    /**
+     * Builds a plane normal to `edge` at the configured position. The edge
+     * tangent at that point becomes the plane normal; the in-plane axes are
+     * an arbitrary (but deterministic) basis around it.
+     */
+    buildFromEdge(context, edge) {
+        const t = normalizeEdgePosition(this.optionsOrPosition);
+        const frame = sampleEdgeFrame(edge, t);
+        // The forward tangent points *into* the edge at the start, so the plane
+        // would face inward there. Flip it at the start endpoint so it faces
+        // outward — like an extrude's start cap (the end already faces outward via
+        // the forward tangent). Interior/end positions keep the forward tangent.
+        const normal = t <= 0 ? frame.tangent.negate() : frame.tangent;
+        let plane = Plane.fromPointAndNormal(frame.point, normal);
+        let center = frame.point;
+        // Unlike the face path, an edge is only *referenced* to derive the plane —
+        // it is not consumed, so it stays available to its owning solid and to
+        // other features.
+        const transform = context?.getTransform() ?? null;
+        if (transform) {
+            plane = plane.applyMatrix(transform);
+            center = center.transform(transform);
+        }
+        this.setState('plane-center', center);
+        this.setState('plane', plane);
+        const face = FaceOps.planeToFace(plane, center);
+        face.markAsMetaShape();
+        this.addShape(face);
+    }
+    /**
+     * Resolves the second argument for a face/plane source. A bare number is a
+     * normal-offset distance; a string position is only meaningful for edges
+     * and is rejected here.
+     */
+    faceOptions() {
+        const value = this.optionsOrPosition;
+        if (value == null) {
+            return undefined;
+        }
+        if (typeof value === 'number') {
+            return { offset: value };
+        }
+        if (typeof value === 'string') {
+            throw new Error(`Plane: position '${value}' is only valid for an edge source`);
+        }
+        return value;
+    }
     getFromSceneObject(sceneObject) {
         const shapes = sceneObject.getShapes();
         console.log(`Plane: Retrieved ${shapes.length} shapes from selection`, shapes);
@@ -82,7 +144,7 @@ export class PlaneFromObject extends PlaneObjectBase {
         return [];
     }
     createCopy(remap) {
-        return new PlaneFromObject(this, this.options);
+        return new PlaneFromObject(this, this.optionsOrPosition);
     }
     compareTo(other) {
         if (!(other instanceof PlaneFromObject)) {
@@ -94,7 +156,7 @@ export class PlaneFromObject extends PlaneObjectBase {
         if (!this.sourceObject.compareTo(other.sourceObject)) {
             return false;
         }
-        if (JSON.stringify(this.options) !== JSON.stringify(other.options)) {
+        if (JSON.stringify(this.optionsOrPosition) !== JSON.stringify(other.optionsOrPosition)) {
             return false;
         }
         return true;
@@ -109,8 +171,39 @@ export class PlaneFromObject extends PlaneObjectBase {
             xDirection: plane.xDirection,
             yDirection: plane.yDirection,
             normal: plane.normal,
-            options: this.options,
+            options: this.optionsOrPosition,
             center: this.getState('plane-center') || plane.origin,
         };
     }
 }
+/**
+ * Evaluates the point and unit (forward) tangent on `edge` at a normalized
+ * position `t` (`0` = start, `1` = end), measured by arc length.
+ */
+function sampleEdgeFrame(edge, t) {
+    const wire = WireOps.makeWireFromEdges([edge]);
+    const sampler = new PathSampler(wire);
+    try {
+        return sampler.evalAt(t * sampler.length);
+    }
+    finally {
+        sampler.dispose();
+    }
+}
+function normalizeEdgePosition(position) {
+    if (position === undefined) {
+        return 0;
+    }
+    if (typeof position === 'number') {
+        return position;
+    }
+    switch (position) {
+        case 'start':
+            return 0;
+        case 'middle':
+            return 0.5;
+        case 'end':
+            return 1;
+    }
+    throw new Error("Plane: an edge plane takes a 0–1 position or 'start'/'middle'/'end', not transform options");
+}

package/lib/dist/features/rib.js

@@ -57,8 +57,18 @@ export class Rib extends ExtrudeBase {
         let direction;
         let distance;
         if (this._parallel) {
+            // The in-plane extrude direction is plane.normal × spineDir — a cross
+            // product, hence a pseudovector. Under a mirror clone (repeat("mirror",
+            // …)) both operands are already reflected, and for a reflection
+            // M(a) × M(b) = −M(a × b): the recomputed perpendicular points to the
+            // opposite side, sending the mirrored rib the wrong way. Flip it back
+            // when this instance's clone transform is a reflection. Proper
+            // transforms (linear/circular/rotate repeats, det > 0) need no fix, and
+            // normal-mode direction (±plane.normal) is linear so it is never
+            // affected.
+            const mirrorSign = context.getTransform()?.isMirroring() ? -1 : 1;
             const perpDir = RibOps.computeSpinePerpendicularDirection(spineWire, plane);
-            direction = perpDir.multiply(dirSign);
+            direction = perpDir.multiply(dirSign * mirrorSign);
             distance = p.record('Compute extrude distance', () => RibOps.computeExtrudeDistanceAlongDirection(direction, plane.origin, scopeShapes));
         }
         else {

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

@@ -23,6 +23,6 @@ export declare class Shell extends SceneObject implements IShell {
     getType(): string;
     serialize(): {
         thickness: number;
-        joinType: "intersection" | "tangent";
+        joinType: "tangent" | "intersection";
     };
 }