fluidcad 0.0.30 → 0.0.32

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

@@ -1,5 +1,6 @@
 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";
 export class Intersect extends ExtrudableGeometryBase {
     sourceObjects;
@@ -11,19 +12,25 @@ export class Intersect extends ExtrudableGeometryBase {
         const plane = this.targetPlane?.getPlane() || this.sketch.getPlane();
         const shapes = this.sourceObjects.flatMap(obj => obj.getShapes());
         const transform = context?.getTransform() ?? null;
-        let lastEdge = null;
-        for (let shape of shapes) {
+        const allEdges = [];
+        for (const shape of shapes) {
             const edges = SectionOps.sectionShapeWithPlane(plane, shape);
-            for (const edge of edges) {
-                lastEdge = edge;
-            }
+            allEdges.push(...edges);
             this.addShapes(edges);
         }
-        if (lastEdge) {
-            const localStart = plane.worldToLocal(lastEdge.getFirstVertex().toPoint());
-            const localEnd = plane.worldToLocal(lastEdge.getLastVertex().toPoint());
-            this.setState('start', Vertex.fromPoint2D(localStart));
-            this.setState('end', Vertex.fromPoint2D(localEnd));
+        // Section across multiple source faces yields an unordered edge set that
+        // may form one connected chain, several disjoint chains, or closed loops.
+        // Take the first connected group and use its actual chain endpoints —
+        // not an arbitrary edge's vertices, which can land on interior junctions.
+        if (allEdges.length > 0) {
+            const groups = WireOps.groupConnectedEdges(allEdges);
+            const endpoints = WireOps.findChainEndpoints(groups[0]);
+            if (endpoints) {
+                const localStart = plane.worldToLocal(endpoints.start.toPoint());
+                const localEnd = plane.worldToLocal(endpoints.end.toPoint());
+                this.setState('start', Vertex.fromPoint2D(localStart));
+                this.setState('end', Vertex.fromPoint2D(localEnd));
+            }
         }
         for (const obj of this.sourceObjects) {
             obj.removeShapes(this);

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

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

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

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

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

@@ -1,9 +1,9 @@
 import { SceneObject } from "../../common/scene-object.js";
 import { GeometrySceneObject } from "./geometry.js";
 export declare class PolarMove extends GeometrySceneObject {
-    radius: number;
+    radiusOrTarget: number | SceneObject;
     angle: number;
-    constructor(radius: number, angle: number);
+    constructor(radiusOrTarget: number | SceneObject, angle: number);
     getType(): string;
     build(): void;
     getDependencies(): SceneObject[];

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

@@ -1,11 +1,13 @@
 import { Point2D } from "../../math/point.js";
+import { SceneObject } from "../../common/scene-object.js";
 import { GeometrySceneObject } from "./geometry.js";
+import { findNearestRayIntersection } from "../../oc/ray-intersect.js";
 export class PolarMove extends GeometrySceneObject {
-    radius;
+    radiusOrTarget;
     angle;
-    constructor(radius, angle) {
+    constructor(radiusOrTarget, angle) {
         super();
-        this.radius = radius;
+        this.radiusOrTarget = radiusOrTarget;
         this.angle = angle;
     }
     getType() {
@@ -13,14 +15,43 @@ export class PolarMove extends GeometrySceneObject {
     }
     build() {
         const pos = this.getCurrentPosition();
-        const newPos = new Point2D(pos.x + this.radius * Math.cos(this.angle), pos.y + this.radius * Math.sin(this.angle));
+        const tangent = (this.sketch?.getTangentAt(this) ?? new Point2D(1, 0)).normalize();
+        const cos = Math.cos(this.angle);
+        const sin = Math.sin(this.angle);
+        const direction = new Point2D(cos * tangent.x - sin * tangent.y, sin * tangent.x + cos * tangent.y);
+        let newPos;
+        if (typeof this.radiusOrTarget === 'number') {
+            newPos = new Point2D(pos.x + this.radiusOrTarget * direction.x, pos.y + this.radiusOrTarget * direction.y);
+        }
+        else {
+            const plane = this.sketch.getPlane();
+            const hit = findNearestRayIntersection(plane, pos, direction, this.radiusOrTarget);
+            if (!hit) {
+                throw new Error("Cannot move at the specified angle up to the geometry");
+            }
+            newPos = hit;
+        }
         this.setCurrentPosition(newPos);
+        const moveVec = newPos.subtract(pos);
+        const moveLen = Math.hypot(moveVec.x, moveVec.y);
+        if (moveLen > 1e-12) {
+            this.setTangent(new Point2D(moveVec.x / moveLen, moveVec.y / moveLen));
+        }
+        else {
+            this.setTangent(direction);
+        }
     }
     getDependencies() {
+        if (this.radiusOrTarget instanceof SceneObject) {
+            return [this.radiusOrTarget];
+        }
         return [];
     }
     createCopy(remap) {
-        return new PolarMove(this.radius, this.angle);
+        const radiusOrTarget = this.radiusOrTarget instanceof SceneObject
+            ? (remap.get(this.radiusOrTarget) || this.radiusOrTarget)
+            : this.radiusOrTarget;
+        return new PolarMove(radiusOrTarget, this.angle);
     }
     compareTo(other) {
         if (!(other instanceof PolarMove)) {
@@ -29,11 +60,20 @@ export class PolarMove extends GeometrySceneObject {
         if (!super.compareTo(other)) {
             return false;
         }
-        return this.radius === other.radius && this.angle === other.angle;
+        if (this.angle !== other.angle) {
+            return false;
+        }
+        if (typeof this.radiusOrTarget !== typeof other.radiusOrTarget) {
+            return false;
+        }
+        if (this.radiusOrTarget instanceof SceneObject && other.radiusOrTarget instanceof SceneObject) {
+            return this.radiusOrTarget.compareTo(other.radiusOrTarget);
+        }
+        return this.radiusOrTarget === other.radiusOrTarget;
     }
     serialize() {
         return {
-            radius: this.radius,
+            radius: typeof this.radiusOrTarget === 'number' ? this.radiusOrTarget : null,
             angle: this.angle
         };
     }

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

@@ -4,7 +4,7 @@ import { ExtrudableGeometryBase } from "./extrudable-base.js";
 export declare class Projection extends ExtrudableGeometryBase {
     private sourceObjects;
     constructor(sourceObjects: SceneObject[], targetPlane?: PlaneObjectBase);
-    build(context?: BuildSceneObjectContext): void;
+    build(_context?: BuildSceneObjectContext): void;
     getDependencies(): SceneObject[];
     createCopy(remap: Map<SceneObject, SceneObject>): SceneObject;
     compareTo(other: Projection): boolean;

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

@@ -1,6 +1,8 @@
 import { Face } from "../../common/face.js";
 import { Edge } from "../../common/edge.js";
 import { Vertex } from "../../common/vertex.js";
+import { EdgeOps } from "../../oc/edge-ops.js";
+import { WireOps } from "../../oc/wire-ops.js";
 import { ProjectionOps } from "../../oc/intersection.js";
 import { Wire } from "../../common/wire.js";
 import { ExtrudableGeometryBase } from "./extrudable-base.js";
@@ -10,16 +12,14 @@ export class Projection extends ExtrudableGeometryBase {
         super(targetPlane);
         this.sourceObjects = sourceObjects;
     }
-    build(context) {
+    build(_context) {
         const plane = this.targetPlane?.getPlane() || this.sketch.getPlane();
         const shapes = this.sourceObjects.flatMap(obj => obj.getShapes());
-        const transform = context?.getTransform() ?? null;
-        let lastWire = null;
-        console.log('Projection: building with shapes:', shapes.length);
-        for (let shape of shapes) {
-            // if (transform) {
-            //   shape = ShapeOps.transform(shape, transform);
-            // }
+        // Project every source first; collect all resulting wires before any dedup
+        // or scene-graph mutation. We need the full set up-front so the General Fuse
+        // in unifyCoincident can detect overlaps across sources, not just within one.
+        const allWires = [];
+        for (const shape of shapes) {
             let wires = [];
             if (shape instanceof Face) {
                 wires = ProjectionOps.projectFaceOntoPlane(plane, shape);
@@ -31,14 +31,24 @@ export class Projection extends ExtrudableGeometryBase {
             else if (shape instanceof Edge) {
                 wires = ProjectionOps.projectEdgeOntoPlane(plane, shape);
             }
-            for (const wire of wires) {
-                lastWire = wire;
-                this.addShapes(wire.getEdges());
-            }
+            allWires.push(...wires);
+        }
+        // Capture the sketch-cursor endpoints BEFORE dedup. unifyCoincident may
+        // split/drop edges and the wire structure is discarded anyway, but the
+        // chain endpoints of the first connected group are still the right anchor
+        // for the sketch's current position. When multiple disjoint pieces are
+        // projected, we use the first as a stable convention.
+        const allEdges = allWires.flatMap(w => w.getEdges());
+        let endpoints = null;
+        if (allEdges.length > 0) {
+            const groups = WireOps.groupConnectedEdges(allEdges);
+            endpoints = WireOps.findChainEndpoints(groups[0]);
         }
-        if (lastWire) {
-            const localStart = plane.worldToLocal(lastWire.getFirstVertex().toPoint());
-            const localEnd = plane.worldToLocal(lastWire.getLastVertex().toPoint());
+        const uniqueEdges = EdgeOps.unifyCoincident(allEdges);
+        this.addShapes(uniqueEdges);
+        if (endpoints) {
+            const localStart = plane.worldToLocal(endpoints.start.toPoint());
+            const localEnd = plane.worldToLocal(endpoints.end.toPoint());
             this.setState('start', Vertex.fromPoint2D(localStart));
             this.setState('end', Vertex.fromPoint2D(localEnd));
         }

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

@@ -12,7 +12,7 @@ export declare class Sketch extends SceneObject implements Extrudable {
     isExtrudable(): boolean;
     getPlane(): Plane;
     getStartPoint(): Point2D;
-    getTangentAt(currentObj: GeometrySceneObject): Point2D | null;
+    getTangentAt(currentObj: GeometrySceneObject): Point2D;
     getPositionAt(currentObj: GeometrySceneObject): Point2D;
     getPreviousPosition(currentObj: GeometrySceneObject, count?: number): Point2D;
     getLastPosition(scope?: Set<SceneObject>): Point2D;
@@ -24,7 +24,7 @@ export declare class Sketch extends SceneObject implements Extrudable {
     getDependencies(): SceneObject[];
     createCopy(remap: Map<SceneObject, SceneObject>): SceneObject;
     compareTo(other: Sketch): boolean;
-    getTangent(scope?: Set<SceneObject>): Point2D | null;
+    getTangent(scope?: Set<SceneObject>): Point2D;
     getType(): string;
     serialize(scope?: Set<SceneObject>): {
         currentPosition: import("../../math/point.js").Point;

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

@@ -32,6 +32,11 @@ export class Sketch extends SceneObject {
         const previous = children.slice(0, children.indexOf(currentObj));
         let last = previous[previous.length - 1];
         while (last) {
+            if (!(last instanceof GeometrySceneObject)) {
+                previous.pop();
+                last = previous[previous.length - 1];
+                continue;
+            }
             const tangent = last.getTangent();
             if (tangent) {
                 return tangent;
@@ -39,7 +44,7 @@ export class Sketch extends SceneObject {
             previous.pop();
             last = previous[previous.length - 1];
         }
-        return null;
+        return new Point2D(1, 0);
     }
     getPositionAt(currentObj) {
         const children = this.getChildren();
@@ -94,6 +99,7 @@ export class Sketch extends SceneObject {
         }
     }
     build(context) {
+        this.setState('tangent', new Point2D(1, 0));
         this.planeObj.removeShapes(this);
         const source = this.getCloneSource();
         const transform = context?.getTransform();
@@ -174,7 +180,7 @@ export class Sketch extends SceneObject {
             children = children.filter(c => scope.has(c));
         }
         if (children.length === 0) {
-            return null;
+            return new Point2D(1, 0);
         }
         let last = children[children.length - 1];
         while (last) {
@@ -190,7 +196,7 @@ export class Sketch extends SceneObject {
             children.pop();
             last = children[children.length - 1];
         }
-        return null;
+        return new Point2D(1, 0);
     }
     getType() {
         return "sketch";
@@ -200,7 +206,7 @@ export class Sketch extends SceneObject {
         const tangent = this.getTangent(scope);
         return {
             currentPosition: plane.localToWorld(this.getLastPosition(scope)),
-            currentTangent: tangent ? plane.localToWorld(tangent) : null,
+            currentTangent: plane.localToWorld(tangent),
             plane: this.planeObj.serialize(),
         };
     }

package/lib/dist/features/2d/tarc-to-point.js

@@ -10,9 +10,6 @@ export class TangentArcToPoint extends GeometrySceneObject {
     }
     build() {
         const tangent = this.sketch.getTangentAt(this);
-        if (!tangent) {
-            throw new Error('TangentArcToPoint requires a previous sibling with a tangent');
-        }
         const plane = this.sketch.getPlane();
         const startPoint = this.getCurrentPosition();
         const targetPoint = this.endPoint.asPoint2D();

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

@@ -13,9 +13,6 @@ export class TangentArc extends GeometrySceneObject {
     }
     build() {
         const tangent = this.sketch.getTangentAt(this);
-        if (!tangent) {
-            throw new Error('TangentArc requires a previous sibling with a tangent');
-        }
         const plane = this.sketch.getPlane();
         // Negative radius flips the sweep direction.
         const radius = Math.abs(this.radius);

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

@@ -9,9 +9,6 @@ export class TangentLine extends GeometrySceneObject {
     }
     build() {
         const tangent = this.sketch.getTangentAt(this);
-        if (!tangent) {
-            throw new Error('TangentLine requires a previous sibling with a tangent');
-        }
         const plane = this.sketch.getPlane();
         const startPoint = this.getCurrentPosition();
         const start = plane.localToWorld(startPoint);

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

@@ -38,7 +38,11 @@ export class VerticalLine extends GeometrySceneObject {
                 throw new Error('vLine: .centered() cannot be combined with a target geometry');
             }
             startPoint = currentPos;
-            endPoint = findNearestRayIntersection(plane, startPoint, new Point2D(0, 1), this.distanceOrTarget);
+            const hit = findNearestRayIntersection(plane, startPoint, new Point2D(0, 1), this.distanceOrTarget);
+            if (!hit) {
+                throw new Error("Line does not intersect target geometry");
+            }
+            endPoint = hit;
             signedLength = endPoint.y - startPoint.y;
         }
         const start = plane.localToWorld(startPoint);

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

@@ -1,8 +1,8 @@
 import { SceneObject } from "../../common/scene-object.js";
 import { GeometrySceneObject } from "./geometry.js";
 export declare class VMove extends GeometrySceneObject {
-    distance: number;
-    constructor(distance: number);
+    distanceOrTarget: number | SceneObject;
+    constructor(distanceOrTarget: number | SceneObject);
     getType(): string;
     build(): void;
     getDependencies(): SceneObject[];

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

@@ -1,24 +1,43 @@
 import { Point2D } from "../../math/point.js";
+import { SceneObject } from "../../common/scene-object.js";
 import { GeometrySceneObject } from "./geometry.js";
+import { findNearestRayIntersection } from "../../oc/ray-intersect.js";
 export class VMove extends GeometrySceneObject {
-    distance;
-    constructor(distance) {
+    distanceOrTarget;
+    constructor(distanceOrTarget) {
         super();
-        this.distance = distance;
+        this.distanceOrTarget = distanceOrTarget;
     }
     getType() {
         return 'vmove';
     }
     build() {
         const pos = this.getCurrentPosition();
-        const newPos = new Point2D(pos.x, pos.y + this.distance);
+        let newPos;
+        if (typeof this.distanceOrTarget === 'number') {
+            newPos = new Point2D(pos.x, pos.y + this.distanceOrTarget);
+        }
+        else {
+            const plane = this.sketch.getPlane();
+            const hit = findNearestRayIntersection(plane, pos, new Point2D(0, 1), this.distanceOrTarget);
+            if (!hit) {
+                throw new Error("Cannot move vertically up to the specified geometry");
+            }
+            newPos = hit;
+        }
         this.setCurrentPosition(newPos);
     }
     getDependencies() {
+        if (this.distanceOrTarget instanceof SceneObject) {
+            return [this.distanceOrTarget];
+        }
         return [];
     }
     createCopy(remap) {
-        return new VMove(this.distance);
+        const distanceOrTarget = this.distanceOrTarget instanceof SceneObject
+            ? (remap.get(this.distanceOrTarget) || this.distanceOrTarget)
+            : this.distanceOrTarget;
+        return new VMove(distanceOrTarget);
     }
     compareTo(other) {
         if (!(other instanceof VMove)) {
@@ -27,11 +46,17 @@ export class VMove extends GeometrySceneObject {
         if (!super.compareTo(other)) {
             return false;
         }
-        return this.distance === other.distance;
+        if (typeof this.distanceOrTarget !== typeof other.distanceOrTarget) {
+            return false;
+        }
+        if (this.distanceOrTarget instanceof SceneObject && other.distanceOrTarget instanceof SceneObject) {
+            return this.distanceOrTarget.compareTo(other.distanceOrTarget);
+        }
+        return this.distanceOrTarget === other.distanceOrTarget;
     }
     serialize() {
         return {
-            distance: this.distance
+            distance: typeof this.distanceOrTarget === 'number' ? this.distanceOrTarget : null
         };
     }
 }

package/lib/dist/features/axis-from-edge.d.ts

@@ -5,6 +5,7 @@ export declare class AxisFromEdge extends AxisObjectBase {
     private sourceObject;
     private options?;
     constructor(sourceObject: SceneObject, options?: AxisTransformOptions);
+    validate(): void;
     build(): void;
     compareTo(other: AxisFromEdge): boolean;
     getUniqueType(): string;

package/lib/dist/features/axis-from-edge.js

@@ -2,6 +2,7 @@ import { SelectSceneObject } from "./select.js";
 import { AxisObjectBase } from "./axis-renderable-base.js";
 import { EdgeOps } from "../oc/edge-ops.js";
 import { SceneObject } from "../common/scene-object.js";
+import { requireShapes } from "../common/operand-check.js";
 export class AxisFromEdge extends AxisObjectBase {
     sourceObject;
     options;
@@ -10,6 +11,13 @@ export class AxisFromEdge extends AxisObjectBase {
         this.sourceObject = sourceObject;
         this.options = options;
     }
+    validate() {
+        // AxisObjectBase sources expose the axis directly — no shapes required.
+        if (this.sourceObject instanceof AxisObjectBase) {
+            return;
+        }
+        requireShapes(this.sourceObject, "source", "axis");
+    }
     build() {
         let axis;
         if (this.sourceObject instanceof SelectSceneObject) {

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

@@ -6,6 +6,7 @@ export declare class Chamfer extends SceneObject {
     private _selections;
     constructor(distance: number, distance2: number, isAngle?: boolean, ...selections: SceneObject[]);
     get selections(): SceneObject[];
+    validate(): void;
     build(context: BuildSceneObjectContext): void;
     getDependencies(): SceneObject[];
     createCopy(remap: Map<SceneObject, SceneObject>): SceneObject;

package/lib/dist/features/chamfer.js

@@ -3,6 +3,7 @@ import { FilletOps } from "../oc/fillet-ops.js";
 import { Explorer } from "../oc/explorer.js";
 import { ShapeOps } from "../oc/shape-ops.js";
 import { ColorTransfer } from "../oc/color-transfer.js";
+import { requireShapes } from "../common/operand-check.js";
 export class Chamfer extends SceneObject {
     distance;
     distance2;
@@ -18,6 +19,11 @@ export class Chamfer extends SceneObject {
     get selections() {
         return this._selections;
     }
+    validate() {
+        for (let i = 0; i < this._selections.length; i++) {
+            requireShapes(this._selections[i], `edge selection ${i + 1}`, "chamfer");
+        }
+    }
     build(context) {
         let sceneObjects;
         sceneObjects = new Map();

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

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

package/lib/dist/features/color.js

@@ -1,5 +1,6 @@
 import { SceneObject } from "../common/scene-object.js";
 import { SelectSceneObject } from "./select.js";
+import { requireShapes } from "../common/operand-check.js";
 import cssColorNames from "color-name";
 function toHex(color) {
     if (color.startsWith('#')) {
@@ -23,6 +24,11 @@ export class Color extends SceneObject {
     get selection() {
         return this._selection;
     }
+    validate() {
+        if (this._selection) {
+            requireShapes(this._selection, "selection", "color");
+        }
+    }
     build(context) {
         const sceneObjects = context.getSceneObjects();
         const objShapeMap = new Map();

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

@@ -5,6 +5,7 @@ export declare class Common extends SceneObject {
     constructor(...objects: SceneObject[]);
     keepOriginal(value?: boolean): this;
     get sceneObjects(): SceneObject[];
+    validate(): void;
     build(context: BuildSceneObjectContext): void;
     compareTo(other: Common): boolean;
     getType(): string;

package/lib/dist/features/common.js

@@ -1,5 +1,6 @@
 import { SceneObject } from "../common/scene-object.js";
 import { BooleanOps } from "../oc/boolean-ops.js";
+import { requireShapes } from "../common/operand-check.js";
 export class Common extends SceneObject {
     _sceneObjects = [];
     _keepOriginal = false;
@@ -14,6 +15,14 @@ export class Common extends SceneObject {
     get sceneObjects() {
         return this._sceneObjects;
     }
+    validate() {
+        // Scene-wide mode (no explicit operands) has nothing to fault — let build
+        // pick up whatever is in the scene. Only validate when the user named
+        // specific operands.
+        for (let i = 0; i < this._sceneObjects.length; i++) {
+            requireShapes(this._sceneObjects[i], `operand ${i + 1}`, "common");
+        }
+    }
     build(context) {
         const p = context.getProfiler();
         let sceneObjects = this.sceneObjects;

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

@@ -6,6 +6,7 @@ export declare class Common2D extends GeometrySceneObject {
     constructor(...targets: GeometrySceneObject[]);
     keepOriginal(value?: boolean): this;
     get targetObjects(): GeometrySceneObject[] | null;
+    validate(): void;
     build(context: BuildSceneObjectContext): void;
     getDependencies(): SceneObject[];
     createCopy(remap: Map<SceneObject, SceneObject>): SceneObject;

package/lib/dist/features/common2d.js

@@ -3,6 +3,7 @@ import { Edge } from "../common/edge.js";
 import { GeometrySceneObject } from "./2d/geometry.js";
 import { BooleanOps } from "../oc/boolean-ops.js";
 import { FaceMaker2 } from "../oc/face-maker2.js";
+import { requireShapes } from "../common/operand-check.js";
 export class Common2D extends GeometrySceneObject {
     _targetObjects = null;
     _keepOriginal = false;
@@ -17,6 +18,14 @@ export class Common2D extends GeometrySceneObject {
     get targetObjects() {
         return this._targetObjects;
     }
+    validate() {
+        if (!this._targetObjects) {
+            return;
+        }
+        for (let i = 0; i < this._targetObjects.length; i++) {
+            requireShapes(this._targetObjects[i], `operand ${i + 1}`, "common2d");
+        }
+    }
     build(context) {
         let sourceEdges;
         if (this._targetObjects === null) {

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

@@ -4,6 +4,7 @@ export declare class Draft extends SceneObject implements IDraft {
     private angle;
     private _selections;
     constructor(angle: number, selections: SceneObject[]);
+    validate(): void;
     build(context: BuildSceneObjectContext): void;
     compareTo(other: SceneObject): boolean;
     getDependencies(): SceneObject[];

package/lib/dist/features/draft.js

@@ -1,5 +1,6 @@
 import { SceneObject } from "../common/scene-object.js";
 import { DraftOps } from "../oc/draft-ops.js";
+import { requireShapes } from "../common/operand-check.js";
 export class Draft extends SceneObject {
     angle;
     _selections = [];
@@ -8,6 +9,11 @@ export class Draft extends SceneObject {
         this.angle = angle;
         this._selections = selections;
     }
+    validate() {
+        for (let i = 0; i < this._selections.length; i++) {
+            requireShapes(this._selections[i], `selection ${i + 1}`, "draft");
+        }
+    }
     build(context) {
         const shapeObjMap = new Map();
         for (const obj of context.getSceneObjects()) {