fluidcad 0.0.38 → 0.0.39

package/lib/dist/core/2d/polygon.js

@@ -1,11 +1,7 @@
-import { isPoint2DLike } from "../../math/point.js";
 import { Polygon } from "../../features/2d/polygon.js";
 import { Move } from "../../features/2d/move.js";
 import { normalizePoint2D } from "../../helpers/normalize.js";
 import { registerBuilder } from "../../index.js";
-import { isPlaneLike } from "../../math/plane.js";
-import { SceneObject } from "../../common/scene-object.js";
-import { resolvePlane } from "../../helpers/resolve.js";
 import { isNumberParam, resolveParam } from "../param.js";
 function build(context) {
     return function polygon() {
@@ -14,52 +10,37 @@ function build(context) {
         let mode;
         let center;
         let poly;
-        let planeObj = null;
-        let argOffset = 0;
-        // Detect plane as first argument (only valid outside a sketch)
-        // PolygonMode strings ('inscribed'/'circumscribed') don't overlap with StandardPlane strings
-        if (arguments.length > 0) {
-            const firstArg = arguments[0];
-            if (isPlaneLike(firstArg) || (firstArg instanceof SceneObject && !isPoint2DLike(firstArg))) {
-                if (context.getActiveSketch() !== null) {
-                    throw new Error("polygon(plane, ...) cannot be used inside a sketch. Use polygon(...) instead.");
-                }
-                planeObj = resolvePlane(firstArg, context);
-                context.addSceneObject(planeObj);
-                argOffset = 1;
-            }
-        }
-        const argCount = arguments.length - argOffset;
+        const argCount = arguments.length;
         if (argCount === 2) {
-            numberOfSides = resolveParam(arguments[argOffset]);
-            diameter = resolveParam(arguments[argOffset + 1]);
+            numberOfSides = resolveParam(arguments[0]);
+            diameter = resolveParam(arguments[1]);
             mode = 'inscribed';
-            poly = new Polygon(numberOfSides, diameter, mode, planeObj);
+            poly = new Polygon(numberOfSides, diameter, mode, null);
             context.addSceneObject(poly);
         }
         else if (argCount === 3) {
-            if (isNumberParam(arguments[argOffset])) {
-                numberOfSides = resolveParam(arguments[argOffset]);
-                diameter = resolveParam(arguments[argOffset + 1]);
-                mode = arguments[argOffset + 2];
-                poly = new Polygon(numberOfSides, diameter, mode, planeObj);
+            if (isNumberParam(arguments[0])) {
+                numberOfSides = resolveParam(arguments[0]);
+                diameter = resolveParam(arguments[1]);
+                mode = arguments[2];
+                poly = new Polygon(numberOfSides, diameter, mode, null);
                 context.addSceneObject(poly);
             }
             else {
-                center = normalizePoint2D(arguments[argOffset]);
-                numberOfSides = resolveParam(arguments[argOffset + 1]);
-                diameter = resolveParam(arguments[argOffset + 2]);
+                center = normalizePoint2D(arguments[0]);
+                numberOfSides = resolveParam(arguments[1]);
+                diameter = resolveParam(arguments[2]);
                 mode = 'inscribed';
-                poly = new Polygon(numberOfSides, diameter, mode, planeObj);
+                poly = new Polygon(numberOfSides, diameter, mode, null);
                 context.addSceneObjects([new Move(center), poly]);
             }
         }
         else if (argCount === 4) {
-            center = normalizePoint2D(arguments[argOffset]);
-            numberOfSides = resolveParam(arguments[argOffset + 1]);
-            diameter = resolveParam(arguments[argOffset + 2]);
-            mode = arguments[argOffset + 3];
-            poly = new Polygon(numberOfSides, diameter, mode, planeObj);
+            center = normalizePoint2D(arguments[0]);
+            numberOfSides = resolveParam(arguments[1]);
+            diameter = resolveParam(arguments[2]);
+            mode = arguments[3];
+            poly = new Polygon(numberOfSides, diameter, mode, null);
             context.addSceneObjects([new Move(center), poly]);
         }
         return poly;

package/lib/dist/core/2d/project.d.ts

@@ -1,4 +1,3 @@
-import { PlaneLike } from "../../math/plane.js";
 import { IExtrudableGeometry, ISceneObject } from "../interfaces.js";
 interface ProjectFunction {
     /**
@@ -6,12 +5,6 @@ interface ProjectFunction {
      * @param sourceObjects - The 3D objects to project
      */
     (...sourceObjects: ISceneObject[]): IExtrudableGeometry;
-    /**
-     * Projects 3D objects onto a target plane.
-     * @param targetPlane - The plane to project onto
-     * @param sourceObjects - The 3D objects to project
-     */
-    (targetPlane: PlaneLike | ISceneObject, sourceObjects: ISceneObject[]): IExtrudableGeometry;
 }
 declare const _default: ProjectFunction;
 export default _default;

package/lib/dist/core/2d/project.js

@@ -1,20 +1,7 @@
 import { Projection } from "../../features/2d/projection.js";
-import { resolvePlane } from "../../helpers/resolve.js";
 import { registerBuilder } from "../../index.js";
 function build(context) {
     return function project(...args) {
-        // Plane-first mode: project(plane, sources[])
-        if (args.length === 2 && Array.isArray(args[1])) {
-            if (context.getActiveSketch() !== null) {
-                throw new Error("project(plane, sources[]) cannot be used inside a sketch. Use project(...sources) instead.");
-            }
-            const planeObj = resolvePlane(args[0], context);
-            const sourceObjects = args[1];
-            context.addSceneObjects(sourceObjects);
-            const projection = new Projection(sourceObjects, planeObj);
-            context.addSceneObject(projection);
-            return projection;
-        }
         const projection = new Projection(args);
         context.addSceneObjects(args);
         context.addSceneObject(projection);

package/lib/dist/core/2d/rect.d.ts

@@ -1,6 +1,5 @@
 import { Point2DLike } from "../../math/point.js";
-import { PlaneLike } from "../../math/plane.js";
-import { IRect, ISceneObject } from "../interfaces.js";
+import { IRect } from "../interfaces.js";
 import { type NumberParam } from "../param.js";
 interface RectFunction {
     /**
@@ -16,13 +15,6 @@ interface RectFunction {
      * @param height - The rectangle height (defaults to width)
      */
     (start: Point2DLike, width: NumberParam, height?: NumberParam): IRect;
-    /**
-     * Draws a rectangle with given dimensions on a specific plane.
-     * @param targetPlane - The plane to draw on
-     * @param width - The rectangle width
-     * @param height - The rectangle height
-     */
-    (targetPlane: PlaneLike | ISceneObject, width: NumberParam, height: NumberParam): IRect;
 }
 declare const _default: RectFunction;
 export default _default;

package/lib/dist/core/2d/rect.js

@@ -1,29 +1,10 @@
-import { isPoint2DLike } from "../../math/point.js";
 import { Move } from "../../features/2d/move.js";
 import { Rect } from "../../features/2d/rect.js";
 import { normalizePoint2D } from "../../helpers/normalize.js";
 import { registerBuilder } from "../../index.js";
-import { isPlaneLike } from "../../math/plane.js";
-import { SceneObject } from "../../common/scene-object.js";
-import { resolvePlane } from "../../helpers/resolve.js";
 import { isNumberParam, resolveParam } from "../param.js";
 function build(context) {
     return function cRect() {
-        // Detect plane as first argument (only valid outside a sketch)
-        if (arguments.length > 0) {
-            const firstArg = arguments[0];
-            if (isPlaneLike(firstArg) || (firstArg instanceof SceneObject && !isPoint2DLike(firstArg))) {
-                if (context.getActiveSketch() !== null) {
-                    throw new Error("rect(plane, ...) cannot be used inside a sketch. Use rect(...) instead.");
-                }
-                const planeObj = resolvePlane(firstArg, context);
-                const width = resolveParam(arguments[1]);
-                const height = resolveParam(arguments[2]);
-                const rect = new Rect(width, height, planeObj);
-                context.addSceneObject(rect);
-                return rect;
-            }
-        }
         const argCount = arguments.length;
         if (argCount === 1) {
             const width = resolveParam(arguments[0]);

package/lib/dist/core/2d/slot.d.ts

@@ -1,5 +1,4 @@
 import { Point2DLike } from "../../math/point.js";
-import { PlaneLike } from "../../math/plane.js";
 import { ISlot, ISceneObject } from "../interfaces.js";
 import { type NumberParam, type BooleanParam } from "../param.js";
 interface SlotFunction {
@@ -9,13 +8,6 @@ interface SlotFunction {
      * @param radius - The end cap radius
      */
     (distance: NumberParam, radius: NumberParam): ISlot;
-    /**
-     * Draws a slot on a specific plane.
-     * @param targetPlane - The plane to draw on
-     * @param distance - The slot length
-     * @param radius - The end cap radius
-     */
-    (targetPlane: PlaneLike | ISceneObject, distance: NumberParam, radius: NumberParam): ISlot;
     /**
      * Draws a slot from a start point with the given length and end radius.
      * @param start - The start point
@@ -37,21 +29,6 @@ interface SlotFunction {
      * @param deleteSource - Whether to delete the source geometry (defaults to true)
      */
     (geometry: ISceneObject, radius: NumberParam, deleteSource?: BooleanParam): ISlot;
-    /**
-     * Creates a slot from a geometry edge on a specific plane.
-     * @param targetPlane - The plane to draw on
-     * @param geometry - The source geometry edge
-     * @param radius - The end cap radius
-     */
-    (targetPlane: PlaneLike | ISceneObject, geometry: ISceneObject, radius: NumberParam): ISlot;
-    /**
-     * Creates a slot from a geometry edge, optionally keeping the source, on a specific plane.
-     * @param targetPlane - The plane to draw on
-     * @param geometry - The source geometry edge
-     * @param radius - The end cap radius
-     * @param deleteSource - Whether to delete the source geometry
-     */
-    (targetPlane: PlaneLike | ISceneObject, geometry: ISceneObject, radius: NumberParam, deleteSource: BooleanParam): ISlot;
 }
 declare const _default: SlotFunction;
 export default _default;

package/lib/dist/core/2d/slot.js

@@ -5,65 +5,46 @@ import { SlotFromEdge } from "../../features/2d/slot-from-edge.js";
 import { normalizePoint2D } from "../../helpers/normalize.js";
 import { registerBuilder } from "../../index.js";
 import { SceneObject } from "../../common/scene-object.js";
-import { isPlaneLike } from "../../math/plane.js";
-import { resolvePlane } from "../../helpers/resolve.js";
 import { isNumberParam, isBooleanParam, resolveParam } from "../param.js";
 function build(context) {
     return function slot() {
-        const inSketch = context.getActiveSketch() !== null;
-        // Detect plane as first argument (only valid outside a sketch).
-        // Inside a sketch, a SceneObject at position 0 means SlotFromEdge geometry, not plane.
-        let planeObj = null;
-        let argOffset = 0;
-        if (arguments.length > 0) {
-            const firstArg = arguments[0];
-            const looksLikePlane = isPlaneLike(firstArg) ||
-                (firstArg instanceof SceneObject && !isPoint2DLike(firstArg) && !inSketch);
-            if (looksLikePlane) {
-                if (inSketch) {
-                    throw new Error("slot(plane, ...) cannot be used inside a sketch. Use slot(...) instead.");
-                }
-                planeObj = resolvePlane(firstArg, context);
-                argOffset = 1;
-            }
-        }
-        // SlotFromEdge path: first non-plane arg is a SceneObject (geometry)
-        if (arguments[argOffset] instanceof SceneObject && !isPoint2DLike(arguments[argOffset])) {
-            const geometry = arguments[argOffset];
-            const radius = resolveParam(arguments[argOffset + 1]);
+        // SlotFromEdge path: first arg is a SceneObject (geometry)
+        if (arguments[0] instanceof SceneObject && !isPoint2DLike(arguments[0])) {
+            const geometry = arguments[0];
+            const radius = resolveParam(arguments[1]);
             let deleteSource = true;
-            if (arguments.length > argOffset + 2 && isBooleanParam(arguments[argOffset + 2])) {
-                deleteSource = resolveParam(arguments[argOffset + 2]);
+            if (arguments.length > 2 && isBooleanParam(arguments[2])) {
+                deleteSource = resolveParam(arguments[2]);
             }
-            const slotFromEdge = new SlotFromEdge(geometry, radius, deleteSource, planeObj);
+            const slotFromEdge = new SlotFromEdge(geometry, radius, deleteSource, null);
             context.addSceneObject(slotFromEdge);
             return slotFromEdge;
         }
-        const argCount = arguments.length - argOffset;
+        const argCount = arguments.length;
         // slot(distance, radius)
-        if (argCount === 2 && isNumberParam(arguments[argOffset])) {
-            const distance = resolveParam(arguments[argOffset]);
-            const radius = resolveParam(arguments[argOffset + 1]);
-            const s = new Slot(distance, radius, planeObj);
+        if (argCount === 2 && isNumberParam(arguments[0])) {
+            const distance = resolveParam(arguments[0]);
+            const radius = resolveParam(arguments[1]);
+            const s = new Slot(distance, radius, null);
             context.addSceneObject(s);
             return s;
         }
-        // slot(start, end, radius) — in-sketch only
-        if (argCount === 3 && argOffset === 0
+        // slot(start, end, radius)
+        if (argCount === 3
             && isPoint2DLike(arguments[0]) && isPoint2DLike(arguments[1])) {
             const start = normalizePoint2D(arguments[0]);
             const end = normalizePoint2D(arguments[1]);
             const radius = arguments[2];
-            const s = Slot.fromTwoPoints(start, end, radius, planeObj);
+            const s = Slot.fromTwoPoints(start, end, radius, null);
             context.addSceneObjects([new Move(start), s]);
             return s;
         }
-        // slot(start, distance, radius) — in-sketch only
-        if (argCount === 3 && argOffset === 0) {
+        // slot(start, distance, radius)
+        if (argCount === 3) {
             const start = normalizePoint2D(arguments[0]);
             const distance = resolveParam(arguments[1]);
             const radius = resolveParam(arguments[2]);
-            const s = new Slot(distance, radius, planeObj);
+            const s = new Slot(distance, radius, null);
             context.addSceneObjects([new Move(start), s]);
             return s;
         }

package/lib/dist/core/2d/text.d.ts

@@ -1,4 +1,3 @@
-import { PlaneLike } from "../../math/plane.js";
 import { IText, ISceneObject } from "../interfaces.js";
 interface TextFunction {
     /**
@@ -7,12 +6,6 @@ interface TextFunction {
      * @param text - The string to render.
      */
     (text: string): IText;
-    /**
-     * Renders a text string on a specific plane (standalone, outside a sketch).
-     * @param plane - The plane (e.g. "xy") or face to render the text on.
-     * @param text - The string to render.
-     */
-    (plane: PlaneLike | ISceneObject, text: string): IText;
     /**
      * Renders a text string following a planar curve. Each glyph is placed
      * upright along the path's arc length; the text plane is the path's plane.

package/lib/dist/core/2d/text.js

@@ -1,8 +1,6 @@
 import { Text } from "../../features/2d/text.js";
 import { registerBuilder } from "../../index.js";
-import { isPlaneLike } from "../../math/plane.js";
 import { SceneObject } from "../../common/scene-object.js";
-import { resolvePlane } from "../../helpers/resolve.js";
 function build(context) {
     return function text() {
         const first = arguments[0];
@@ -17,18 +15,6 @@ function build(context) {
             context.addSceneObject(obj);
             return obj;
         }
-        // A leading plane/face is only valid standalone and only when a string
-        // follows it; `text("xy")` (one arg) renders the literal string "xy".
-        const standalone = arguments.length >= 2 && (isPlaneLike(first) || first instanceof SceneObject);
-        if (standalone) {
-            if (context.getActiveSketch() !== null) {
-                throw new Error("text(plane, ...) cannot be used inside a sketch. Use text(...) instead.");
-            }
-            const planeObj = resolvePlane(first, context);
-            const obj = new Text(String(arguments[1] ?? ""), planeObj);
-            context.addSceneObject(obj);
-            return obj;
-        }
         const obj = new Text(String(first ?? ""));
         context.addSceneObject(obj);
         return obj;

package/lib/dist/core/2d/vline.d.ts

@@ -1,5 +1,4 @@
 import { Point2DLike } from "../../math/point.js";
-import { PlaneLike } from "../../math/plane.js";
 import { IVLine, ISceneObject } from "../interfaces.js";
 import { type NumberParam } from "../param.js";
 interface VLineFunction {
@@ -30,12 +29,6 @@ interface VLineFunction {
      * @param target - The geometry to intersect with
      */
     (start: Point2DLike, target: ISceneObject): IVLine;
-    /**
-     * Draws a vertical line on a specific plane.
-     * @param targetPlane - The plane to draw on
-     * @param distance - The line length
-     */
-    (targetPlane: PlaneLike | ISceneObject, distance: NumberParam): IVLine;
 }
 declare const _default: VLineFunction;
 export default _default;

package/lib/dist/core/2d/vline.js

@@ -3,49 +3,31 @@ import { Move } from "../../features/2d/move.js";
 import { VerticalLine } from "../../features/2d/vline.js";
 import { normalizePoint2D } from "../../helpers/normalize.js";
 import { registerBuilder } from "../../index.js";
-import { isPlaneLike } from "../../math/plane.js";
 import { SceneObject } from "../../common/scene-object.js";
-import { resolvePlane } from "../../helpers/resolve.js";
 import { isNumberParam, resolveParam } from "../param.js";
 function build(context) {
     return function line() {
-        let planeObj = null;
-        let argOffset = 0;
         const inSketch = context.getActiveSketch() !== null;
-        if (arguments.length > 0) {
-            const firstArg = arguments[0];
-            if (isPlaneLike(firstArg)) {
-                if (inSketch) {
-                    throw new Error("vLine(plane, ...) cannot be used inside a sketch. Use vLine(...) instead.");
-                }
-                planeObj = resolvePlane(firstArg, context);
-                argOffset = 1;
-            }
-            else if (!inSketch && firstArg instanceof SceneObject && !isPoint2DLike(firstArg)) {
-                planeObj = resolvePlane(firstArg, context);
-                argOffset = 1;
-            }
-        }
-        if (argOffset === 0 && inSketch && arguments[0] instanceof SceneObject && !isPoint2DLike(arguments[0])) {
+        if (inSketch && arguments[0] instanceof SceneObject && !isPoint2DLike(arguments[0])) {
             // vLine(target)
             const vline = new VerticalLine(arguments[0], null);
             context.addSceneObject(vline);
             return vline;
         }
-        if (argOffset === 0 && !isNumberParam(arguments[0])) {
+        if (!isNumberParam(arguments[0])) {
             // vLine(start, distance) or vLine(start, target)
             const start = normalizePoint2D(arguments[0]);
             const second = arguments[1];
             const distanceOrTarget = second instanceof SceneObject
                 ? second
                 : resolveParam(second);
-            const vline = new VerticalLine(distanceOrTarget, planeObj);
+            const vline = new VerticalLine(distanceOrTarget, null);
             vline.setHasExplicitStart();
             context.addSceneObjects([new Move(start), vline]);
             return vline;
         }
-        const distance = resolveParam(arguments[argOffset]);
-        const vline = new VerticalLine(distance, planeObj);
+        const distance = resolveParam(arguments[0]);
+        const vline = new VerticalLine(distance, null);
         context.addSceneObject(vline);
         return vline;
     };

package/lib/dist/core/fillet.js

@@ -33,6 +33,13 @@ function build(context) {
                 context.addSceneObject(fillet);
                 return fillet;
             }
+            if (arguments.length >= 2 && isNumberParam(arguments[0])) {
+                const radius = resolveParam(arguments[0]);
+                const objects = Array.from(arguments).slice(1);
+                const fillet = new Fillet2D(radius, ...objects);
+                context.addSceneObject(fillet);
+                return fillet;
+            }
         }
         else {
             const args = Array.from(arguments);

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

@@ -1,4 +1,4 @@
-export type { ISceneObject, ITransformable, IBooleanOperation, IPlane, IAxis, ISelect, IGeometry, IExtrudableGeometry, IText, IRect, ISlot, IPolygon, ITwoObjectsTangentLine, ITangentArcTwoObjects, IExtrude, ICut, ICommon, ISweep, ILoft, IRevolve, IDraft, IRib, IHelix, IWrap } from "./interfaces.js";
+export type { ISceneObject, ITransformable, IBooleanOperation, IPlane, IAxis, ISelect, IGeometry, IExtrudableGeometry, IText, IRect, ISlot, IPolygon, ITwoObjectsTangentLine, ITangentArcTwoObjects, IExtrude, ICut, ICommon, ISweep, ILoft, LoftConditionType, IRevolve, IDraft, IRib, IHelix, IWrap } from "./interfaces.js";
 export { default as axis } from "./axis.js";
 export { default as local } from "./local.js";
 export { default as plane } from "./plane.js";

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

@@ -618,7 +618,40 @@ export interface IRevolve extends IBooleanOperation {
      */
     capEdges(...args: (number | EdgeFilterBuilder)[]): ISceneObject;
 }
+/**
+ * How a loft leaves (or arrives at) an end profile:
+ * - `'none'` — no constraint (default).
+ * - `'normal'` — the surface takes off perpendicular to the profile plane.
+ * - `'tangent'` — the surface takes off inside the profile plane, directed
+ *   outward, so the profile plane becomes a tangency plane.
+ */
+export type LoftConditionType = 'none' | 'normal' | 'tangent';
 export interface ILoft extends IBooleanOperation {
+    /**
+     * Adds side guide curves (rails) the loft surface must follow. Supports one
+     * or two guides in total; a single argument may carry several separate
+     * curves (e.g. a sketch holding a curve and its mirror) — each connected
+     * chain counts as one guide. Every guide must pass through every profile.
+     * Composes with start/end conditions (the condition fades out around each
+     * guide's contact point — rails win locally, the condition shapes the
+     * rest). Cannot be combined with thin mode.
+     * @param guides - Sketches or edges forming the guide curves.
+     */
+    guides(...guides: ISceneObject[]): this;
+    /**
+     * Constrains how the surface leaves the first profile.
+     * @param type - `'none'`, `'normal'` or `'tangent'` — see {@link LoftConditionType}.
+     * @param magnitude - Scales the takeoff strength; defaults to 1. Negative
+     * values flip the direction (e.g. inward instead of outward for `'tangent'`).
+     */
+    startCondition(type: LoftConditionType, magnitude?: NumberParam): this;
+    /**
+     * Constrains how the surface arrives at the last profile.
+     * @param type - `'none'`, `'normal'` or `'tangent'` — see {@link LoftConditionType}.
+     * @param magnitude - Scales the arrival strength; defaults to 1. Negative
+     * values flip the direction (e.g. inward instead of outward for `'tangent'`).
+     */
+    endCondition(type: LoftConditionType, magnitude?: NumberParam): this;
     /**
      * Selects faces on the first profile plane of the loft.
      * @param args - Numeric indices or {@link FaceFilterBuilder} instances to filter the selection.
@@ -687,6 +720,8 @@ export interface ILoft extends IBooleanOperation {
      */
     capEdges(...args: (number | EdgeFilterBuilder)[]): ISceneObject;
 }
+/** Which end of a sweep path to extend. */
+export type SweepSide = "start" | "end";
 export interface ISweep extends IBooleanOperation {
     /**
      * Selects faces at the start (profile plane) of the sweep.
@@ -738,6 +773,14 @@ export interface ISweep extends IBooleanOperation {
      * @param value - The offset distance.
      */
     endOffset(value: NumberParam): this;
+    /**
+     * Extends the swept solid beyond the path at the given end by `amount`,
+     * continuing straight along the path's tangent direction there. Chain twice to
+     * extend both ends, e.g. `.extend('start', 10).extend('end', 5)`.
+     * @param side - Which end of the path to extend: `'start'` or `'end'`.
+     * @param amount - Distance to extend, in mm (positive; non-positive is a no-op).
+     */
+    extend(side: SweepSide, amount: NumberParam): this;
     /**
      * Enables or disables drill mode.
      * @param value - `true` to enable (default), `false` to disable.

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/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 {};
+    }
+}