fluidcad 0.0.24 → 0.0.26

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

@@ -1,8 +1,6 @@
 import { PlaneLike, PlaneTransformOptions } from "../math/plane.js";
 import { IPlane, ISceneObject } from "./interfaces.js";
-export type PlaneRenderableOptions = PlaneTransformOptions & {
-    sticky?: boolean;
-};
+export type PlaneRenderableOptions = PlaneTransformOptions;
 interface PlaneFunction {
     /**
      * Creates a plane from a standard plane or normal vector.
@@ -12,7 +10,7 @@ interface PlaneFunction {
     /**
      * Creates a plane with transform options.
      * @param plane - The standard plane or normal vector
-     * @param options - Transform options (offset, flip, sticky, etc.)
+     * @param options - Transform options (offset, rotate, etc.)
      */
     (plane: PlaneLike, options: PlaneRenderableOptions): IPlane;
     /**
@@ -29,7 +27,7 @@ interface PlaneFunction {
     /**
      * Creates a plane from a face selection with transform options.
      * @param selection - The selected face to create a plane from
-     * @param options - Transform options (offset, flip, sticky, etc.)
+     * @param options - Transform options (offset, rotate, etc.)
      */
     (selection: ISceneObject, options: PlaneRenderableOptions): IPlane;
     /**
@@ -41,14 +39,14 @@ interface PlaneFunction {
     /**
      * Transforms an existing plane with options.
      * @param plane - The existing plane to transform
-     * @param options - Transform options (offset, flip, sticky, etc.)
+     * @param options - Transform options (offset, rotate, etc.)
      */
     (plane: IPlane, options: PlaneRenderableOptions): IPlane;
     /**
      * Creates a plane midway between two standard planes or normal vectors.
      * @param p1 - The first standard plane or normal vector
      * @param p2 - The second standard plane or normal vector
-     * @param options - Transform options (offset, flip, sticky, etc.)
+     * @param options - Transform options (offset, rotate, etc.)
      */
     (p1: PlaneLike, p2: PlaneLike, options?: PlaneRenderableOptions): IPlane;
     /**

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

@@ -1,16 +1,16 @@
-import { ISceneObject } from "./interfaces.js";
+import { ITransformable } from "./interfaces.js";
 interface SphereFunction {
     /**
      * Creates a full sphere with the given radius.
      * @param radius - The sphere radius
      */
-    (radius: number): ISceneObject;
+    (radius: number): ITransformable;
     /**
      * Creates a partial sphere with the given radius and sweep angle.
      * @param radius - The sphere radius
      * @param angle - The sweep angle in degrees
      */
-    (radius: number, angle: number): ISceneObject;
+    (radius: number, angle: number): ITransformable;
 }
 declare const _default: SphereFunction;
 export default _default;

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

@@ -21,8 +21,9 @@ export class Circle extends ExtrudableGeometryBase {
         const circle = Geometry.makeCircle(plane.localToWorld(center), radius, plane.normal);
         let edge = Geometry.makeEdgeFromCircle(circle);
         this.addShape(edge);
-        if (this.sketch)
+        if (this.sketch) {
             this.setCurrentPosition(center);
+        }
         if (this.targetPlane) {
             this.targetPlane.removeShapes(this);
         }

package/lib/dist/features/2d/tarc-with-tangent.js

@@ -15,13 +15,15 @@ export class TangentArcWithTangent extends GeometrySceneObject {
     }
     build() {
         const plane = this.sketch.getPlane();
-        const radius = this.radius;
+        // Negative radius flips the sweep direction.
+        const radius = Math.abs(this.radius);
+        const signedEndAngle = this.radius < 0 ? -this.endAngle : this.endAngle;
         const tangent = this.startTangent.asPoint2D();
         // Derive the base angle from the provided tangent.
         // Tangent at angle θ on a circle is (-sin θ, cos θ),
         // so θ = atan2(-tx, ty).
         const baseAngle = Math.atan2(-tangent.x, tangent.y);
-        const clampedEndAngle = Math.max(this.endAngle, -359.9999);
+        const clampedEndAngle = Math.max(signedEndAngle, -359.9999);
         const cw = clampedEndAngle < 0;
         const startAngleRad = cw ? baseAngle + Math.PI : baseAngle;
         const endAngleRad = startAngleRad + rad(clampedEndAngle);

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

@@ -17,7 +17,9 @@ export class TangentArc extends GeometrySceneObject {
             throw new Error('TangentArc requires a previous sibling with a tangent');
         }
         const plane = this.sketch.getPlane();
-        const radius = this.radius;
+        // Negative radius flips the sweep direction.
+        const radius = Math.abs(this.radius);
+        const signedEndAngle = this.radius < 0 ? -this.endAngle : this.endAngle;
         // Derive the base angle from the previous sibling's tangent.
         // Tangent at angle θ on a circle is (-sin θ, cos θ),
         // so θ = atan2(-tx, ty).
@@ -25,7 +27,7 @@ export class TangentArc extends GeometrySceneObject {
         // For CW (negative endAngle), flip the center to the opposite side
         // and negate the normal so makeArc sweeps in reverse
         // Clamp to avoid coincident start/end points at exactly ±360°
-        const clampedEndAngle = Math.max(this.endAngle, -359.9999);
+        const clampedEndAngle = Math.max(signedEndAngle, -359.9999);
         const cw = clampedEndAngle < 0;
         const startAngleRad = cw ? baseAngle + Math.PI : baseAngle;
         const endAngleRad = startAngleRad + rad(clampedEndAngle);

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

@@ -13,7 +13,7 @@ export class AxisFromEdge extends AxisObjectBase {
     build() {
         let axis;
         if (this.sourceObject instanceof SelectSceneObject) {
-            const shapes = this.sourceObject.getShapes();
+            const shapes = this.sourceObject.getShapes({ excludeGuide: false });
             console.log(`Axis: Retrieved ${shapes.length} shapes from selection`);
             if (shapes.length === 0) {
                 throw new Error("Axis: Selected object has no shapes to extract axis from");
@@ -34,7 +34,7 @@ export class AxisFromEdge extends AxisObjectBase {
             axis = this.sourceObject.getAxis();
         }
         else if (this.sourceObject instanceof SceneObject) {
-            const shapes = this.sourceObject.getShapes();
+            const shapes = this.sourceObject.getShapes({ excludeGuide: false });
             console.log(`Axis: Retrieved ${shapes.length} shapes from source object`);
             if (shapes.length === 0) {
                 throw new Error("Axis: Source object has no shapes to extract axis from");

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

@@ -0,0 +1,18 @@
+import { AxisTransformOptions, StandardAxis } from "../math/axis.js";
+import { AxisObjectBase } from "./axis-renderable-base.js";
+import { SceneObject } from "../common/scene-object.js";
+import { Sketch } from "./2d/sketch.js";
+export declare class AxisFromSketch extends AxisObjectBase {
+    private sketch;
+    private direction;
+    private options?;
+    constructor(sketch: Sketch, direction: StandardAxis, options?: AxisTransformOptions);
+    build(): void;
+    createCopy(remap: Map<SceneObject, SceneObject>): SceneObject;
+    compareTo(other: AxisFromSketch): boolean;
+    getUniqueType(): string;
+    serialize(): {
+        direction: StandardAxis;
+        options: AxisTransformOptions;
+    };
+}

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

@@ -0,0 +1,58 @@
+import { AxisObjectBase } from "./axis-renderable-base.js";
+import { EdgeOps } from "../oc/edge-ops.js";
+export class AxisFromSketch extends AxisObjectBase {
+    sketch;
+    direction;
+    options;
+    constructor(sketch, direction, options) {
+        super();
+        this.sketch = sketch;
+        this.direction = direction;
+        this.options = options;
+    }
+    build() {
+        const plane = this.sketch.getPlane();
+        let axis = plane.normalizeAxis(this.direction);
+        if (!axis) {
+            throw new Error(`AxisFromSketch: invalid direction '${this.direction}'`);
+        }
+        if (this.options) {
+            axis = axis.transform(this.options);
+        }
+        this.setState('axis', axis);
+        const edge = EdgeOps.axisToEdge(axis);
+        edge.markAsMetaShape();
+        this.addShape(edge);
+    }
+    createCopy(remap) {
+        const sketch = remap.get(this.sketch) || this.sketch;
+        return new AxisFromSketch(sketch, this.direction, this.options);
+    }
+    compareTo(other) {
+        if (!(other instanceof AxisFromSketch)) {
+            return false;
+        }
+        if (!super.compareTo(other)) {
+            return false;
+        }
+        if (!this.sketch.compareTo(other.sketch)) {
+            return false;
+        }
+        if (this.direction !== other.direction) {
+            return false;
+        }
+        if (JSON.stringify(this.options) !== JSON.stringify(other.options)) {
+            return false;
+        }
+        return true;
+    }
+    getUniqueType() {
+        return 'axis-from-sketch';
+    }
+    serialize() {
+        return {
+            direction: this.direction,
+            options: this.options,
+        };
+    }
+}

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

@@ -2,11 +2,13 @@ import { BuildSceneObjectContext, SceneObject } from "../common/scene-object.js"
 import { Axis } from "../math/axis.js";
 import { GeometrySceneObject } from "./2d/geometry.js";
 import { LinearCopyOptions } from "./copy-linear.js";
+import { AxisObjectBase } from "./axis-renderable-base.js";
+export type CopyLinear2DAxis = Axis | AxisObjectBase;
 export declare class CopyLinear2D extends GeometrySceneObject {
-    axes: Axis[];
+    axes: CopyLinear2DAxis[];
     options: LinearCopyOptions;
     targetObjects: SceneObject[] | null;
-    constructor(axes: Axis[], options: LinearCopyOptions, targetObjects?: SceneObject[] | null);
+    constructor(axes: CopyLinear2DAxis[], options: LinearCopyOptions, targetObjects?: SceneObject[] | null);
     build(context: BuildSceneObjectContext): void;
     compareTo(other: CopyLinear2D): boolean;
     getType(): string;

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

@@ -1,6 +1,7 @@
 import { Matrix4 } from "../math/matrix4.js";
 import { ShapeOps } from "../oc/shape-ops.js";
 import { GeometrySceneObject } from "./2d/geometry.js";
+import { AxisObjectBase } from "./axis-renderable-base.js";
 export class CopyLinear2D extends GeometrySceneObject {
     axes;
     options;
@@ -20,17 +21,18 @@ export class CopyLinear2D extends GeometrySceneObject {
         else {
             objects = allSiblings;
         }
+        const resolvedAxes = this.axes.map(a => a instanceof AxisObjectBase ? a.getAxis() : a);
         const { count, centered, skip } = this.options;
         const counts = Array.isArray(count)
             ? count
-            : this.axes.map(() => count);
+            : resolvedAxes.map(() => count);
         const offsets = 'offset' in this.options && this.options.offset !== undefined
-            ? (Array.isArray(this.options.offset) ? this.options.offset : this.axes.map(() => this.options.offset))
+            ? (Array.isArray(this.options.offset) ? this.options.offset : resolvedAxes.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))
+            ? (Array.isArray(this.options.length) ? this.options.length : resolvedAxes.map(() => this.options.length))
             : null;
-        const axisOffsets = this.axes.map((_, a) => {
+        const axisOffsets = resolvedAxes.map((_, a) => {
             if (offsets) {
                 return offsets[a] ?? offsets[0];
             }
@@ -38,10 +40,10 @@ export class CopyLinear2D extends GeometrySceneObject {
             const axisCount = counts[a];
             return axisCount > 1 ? len / (axisCount - 1) : 0;
         });
-        const centerIndices = this.axes.map((_, a) => centered ? Math.floor(counts[a] / 2) : 0);
+        const centerIndices = resolvedAxes.map((_, a) => centered ? Math.floor(counts[a] / 2) : 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++) {
+        for (let a = 0; a < resolvedAxes.length; a++) {
             const next = [];
             for (const pos of positions) {
                 for (let i = 0; i < counts[a]; i++) {
@@ -57,9 +59,9 @@ export class CopyLinear2D extends GeometrySceneObject {
                 continue;
             }
             let matrix = Matrix4.identity();
-            for (let a = 0; a < this.axes.length; a++) {
+            for (let a = 0; a < resolvedAxes.length; a++) {
                 const distance = (pos[a] - centerIndices[a]) * axisOffsets[a];
-                const translation = this.axes[a].direction.multiply(distance);
+                const translation = resolvedAxes[a].direction.multiply(distance);
                 matrix = matrix.multiply(Matrix4.fromTranslationVector(translation));
             }
             for (const obj of objects) {
@@ -82,7 +84,19 @@ export class CopyLinear2D extends GeometrySceneObject {
             return false;
         }
         for (let i = 0; i < this.axes.length; i++) {
-            if (!this.axes[i].equals(other.axes[i])) {
+            const a = this.axes[i];
+            const b = other.axes[i];
+            const aIsObj = a instanceof AxisObjectBase;
+            const bIsObj = b instanceof AxisObjectBase;
+            if (aIsObj !== bIsObj) {
+                return false;
+            }
+            if (aIsObj) {
+                if (!a.compareTo(b)) {
+                    return false;
+                }
+            }
+            else if (!a.equals(b)) {
                 return false;
             }
         }

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

@@ -1,5 +1,5 @@
-import { SceneObject } from "../common/scene-object.js";
-export declare class Cylinder extends SceneObject {
+import { TransformablePrimitive } from "../common/transformable-primitive.js";
+export declare class Cylinder extends TransformablePrimitive {
     radius: number;
     height: number;
     constructor(radius: number, height: number);

package/lib/dist/features/cylinder.js

@@ -1,6 +1,6 @@
-import { SceneObject } from "../common/scene-object.js";
+import { TransformablePrimitive } from "../common/transformable-primitive.js";
 import { Primitives } from "../oc/primitives.js";
-export class Cylinder extends SceneObject {
+export class Cylinder extends TransformablePrimitive {
     radius;
     height;
     constructor(radius, height) {

package/lib/dist/features/mirror-shape.js

@@ -70,6 +70,16 @@ export class MirrorShape extends SceneObject {
         if (!this.plane.compareTo(other.plane)) {
             return false;
         }
+        const thisTargetObjects = this.targetObjects || [];
+        const otherTargetObjects = other.targetObjects || [];
+        if (thisTargetObjects.length !== otherTargetObjects.length) {
+            return false;
+        }
+        for (let i = 0; i < thisTargetObjects.length; i++) {
+            if (!thisTargetObjects[i].compareTo(otherTargetObjects[i])) {
+                return false;
+            }
+        }
         return true;
     }
     getType() {

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

@@ -23,7 +23,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: PlaneRenderableOptions;
+        options: import("../math/plane.js").PlaneTransformOptions;
         center: any;
     };
 }

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

@@ -24,24 +24,29 @@ export class PlaneFromObject extends PlaneObjectBase {
             sourceFace = extract.sourceFace;
         }
         this.sourceObject.removeShapes(this);
-        if (this.options) {
-            plane = plane.transform(this.options);
-        }
         if (sourceFace) {
             const bbox = ShapeOps.getBoundingBox(sourceFace.getShape());
             center = new Point(bbox.centerX, bbox.centerY, bbox.centerZ);
         }
-        if (center) {
-            this.setState('plane-center', center);
+        if (this.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);
+            plane = plane.applyMatrix(matrix);
+            if (center) {
+                center = center.transform(matrix);
+            }
         }
         const transform = context?.getTransform() ?? null;
         if (transform) {
             plane = plane.applyMatrix(transform);
             if (center) {
                 center = center.transform(transform);
-                this.setState('plane-center', center);
             }
         }
+        if (center) {
+            this.setState('plane-center', center);
+        }
         this.setState('plane', plane);
         const face = FaceOps.planeToFace(plane, center);
         face.markAsMetaShape();

package/lib/dist/features/plane-mid.d.ts

@@ -13,6 +13,6 @@ export declare class PlaneMiddleRenderable extends PlaneObjectBase {
         yDirection: import("../math/vector3d.js").Vector3d;
         normal: import("../math/vector3d.js").Vector3d;
         center: import("../math/point.js").Point;
-        options: PlaneRenderableOptions;
+        options: import("../math/plane.js").PlaneTransformOptions;
     };
 }

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

@@ -16,6 +16,6 @@ export declare class PlaneObject extends PlaneObjectBase {
         yDirection: import("../math/vector3d.js").Vector3d;
         normal: import("../math/vector3d.js").Vector3d;
         center: import("../math/point.js").Point;
-        options: PlaneRenderableOptions;
+        options: import("../math/plane.js").PlaneTransformOptions;
     };
 }

package/lib/dist/features/select.js

@@ -65,7 +65,6 @@ export class SelectSceneObject extends SceneObject {
     }
     transform(matrix) {
         const mirroredFilters = this.filters.map(f => f.transform(matrix));
-        console.log('SelectSceneObject: transform applied to selection filters.', mirroredFilters);
         return new SelectSceneObject(mirroredFilters, this.constraintObject);
     }
     injectScopeFaces(filters, sceneObjects) {

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

@@ -1,5 +1,5 @@
-import { SceneObject } from "../common/scene-object.js";
-export declare class Sphere extends SceneObject {
+import { TransformablePrimitive } from "../common/transformable-primitive.js";
+export declare class Sphere extends TransformablePrimitive {
     radius: number;
     angle: number;
     constructor(radius: number, angle: number);

package/lib/dist/features/sphere.js

@@ -1,6 +1,6 @@
-import { SceneObject } from "../common/scene-object.js";
+import { TransformablePrimitive } from "../common/transformable-primitive.js";
 import { Primitives } from "../oc/primitives.js";
-export class Sphere extends SceneObject {
+export class Sphere extends TransformablePrimitive {
     radius;
     angle;
     constructor(radius, angle) {

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

@@ -69,4 +69,5 @@ export declare class Axis {
 export type StandardAxis = "x" | "y" | "z";
 export type AxisLike = StandardAxis | Axis | IAxis | AxisObjectBase;
 export declare function isAxisLike(value: unknown): value is AxisLike;
+export declare function isStandardAxis(value: unknown): value is StandardAxis;
 export declare function toAxis(value: AxisLike): Axis;

package/lib/dist/math/axis.js

@@ -140,7 +140,10 @@ export class Axis {
     }
 }
 export function isAxisLike(value) {
-    return value instanceof AxisObjectBase || value instanceof Axis || value === "x" || value === "y" || value === "z";
+    return value instanceof AxisObjectBase || value instanceof Axis || isStandardAxis(value);
+}
+export function isStandardAxis(value) {
+    return value === "x" || value === "y" || value === "z";
 }
 export function toAxis(value) {
     if (value instanceof Axis) {

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

@@ -2,7 +2,7 @@ export { Vector3d, Vector3dLike, normalizeVector as toVector3d } from "./vector3
 export { Point, Point2D, PointLike, Point2DLike, isPointLike, isPoint2DLike } from "./point.js";
 export { Quaternion } from "./quaternion.js";
 export { Matrix4 } from "./matrix4.js";
-export { Axis, AxisLike, StandardAxis, AxisTransformOptions, isAxisLike, toAxis } from "./axis.js";
-export { Plane, PlaneLike, StandardPlane, PlaneTransformOptions, RotationSpace, isPlaneLike, toPlane } from "./plane.js";
+export { Axis, AxisLike, StandardAxis, AxisTransformOptions, isAxisLike, isStandardAxis, toAxis } from "./axis.js";
+export { Plane, PlaneLike, StandardPlane, PlaneTransformOptions, isPlaneLike, toPlane } from "./plane.js";
 export { CoordinateSystem } from "./coordinate-system.js";
 export { Convert } from "./convert.js";

package/lib/dist/math/index.js

@@ -2,7 +2,7 @@ export { Vector3d, normalizeVector as toVector3d } from "./vector3d.js";
 export { Point, Point2D, isPointLike, isPoint2DLike } from "./point.js";
 export { Quaternion } from "./quaternion.js";
 export { Matrix4 } from "./matrix4.js";
-export { Axis, isAxisLike, toAxis } from "./axis.js";
+export { Axis, isAxisLike, isStandardAxis, toAxis } from "./axis.js";
 export { Plane, isPlaneLike, toPlane } from "./plane.js";
 export { CoordinateSystem } from "./coordinate-system.js";
 export { Convert } from "./convert.js";

package/lib/dist/math/plane.d.ts

@@ -4,13 +4,11 @@ import { Axis, AxisLike } from "./axis.js";
 import { Matrix4 } from "./matrix4.js";
 import { PlaneObjectBase } from "../features/plane-renderable-base.js";
 import { IPlane } from "../core/interfaces.js";
-export type RotationSpace = 'local' | 'global';
 export interface PlaneTransformOptions {
     offset?: number;
     rotateX?: number;
     rotateY?: number;
     rotateZ?: number;
-    rotationSpace?: RotationSpace;
 }
 export declare class Plane {
     readonly origin: Point;
@@ -25,6 +23,7 @@ export declare class Plane {
     localToWorld(point: Point2D): Point;
     offset(distance: number): Plane;
     transform(options: PlaneTransformOptions): Plane;
+    getTransformMatrix(options: PlaneTransformOptions): Matrix4;
     applyMatrix(matrix: Matrix4): Plane;
     translateAlongNormal(distance: number): Plane;
     translate(dx: number, dy: number, dz: number): Plane;

package/lib/dist/math/plane.js

@@ -36,36 +36,37 @@ export class Plane {
         return new Plane(newOrigin, this.xDirection, this.normal);
     }
     transform(options) {
-        let result = this;
-        if (options.offset) {
-            result = result.offset(options.offset);
-        }
+        return this.applyMatrix(this.getTransformMatrix(options));
+    }
+    getTransformMatrix(options) {
+        const offset = options.offset || 0;
+        const offsetVec = this.normal.multiply(offset);
+        const offsetMatrix = offset
+            ? Matrix4.fromTranslation(offsetVec.x, offsetVec.y, offsetVec.z)
+            : Matrix4.identity();
         const hasRotation = options.rotateX || options.rotateY || options.rotateZ;
         if (!hasRotation) {
-            return result;
+            return offsetMatrix;
         }
-        const useGlobal = options.rotationSpace === 'global';
-        // Determine rotation axes based on rotation space
-        const xAxis = useGlobal ? Vector3d.unitX() : result.xDirection;
-        const yAxis = useGlobal ? Vector3d.unitY() : result.yDirection;
-        const zAxis = useGlobal ? Vector3d.unitZ() : result.normal;
-        // Compose all rotations into a single quaternion to avoid gimbal lock
+        // Compose all rotations into a single quaternion to avoid gimbal lock.
+        // Axes are taken from the current plane (offset doesn't change orientation).
         let q = Quaternion.identity();
         if (options.rotateX) {
-            q = q.multiply(Quaternion.fromAxisAngle(xAxis, rad(options.rotateX)));
+            q = q.multiply(Quaternion.fromAxisAngle(this.xDirection, rad(options.rotateX)));
         }
         if (options.rotateY) {
-            q = q.multiply(Quaternion.fromAxisAngle(yAxis, rad(options.rotateY)));
+            q = q.multiply(Quaternion.fromAxisAngle(this.yDirection, rad(options.rotateY)));
         }
         if (options.rotateZ) {
-            q = q.multiply(Quaternion.fromAxisAngle(zAxis, rad(options.rotateZ)));
+            q = q.multiply(Quaternion.fromAxisAngle(this.normal, rad(options.rotateZ)));
         }
-        // Apply the composed rotation around the plane's origin
-        const toOrigin = Matrix4.fromTranslation(-result.origin.x, -result.origin.y, -result.origin.z);
+        // Rotate around the offset-applied origin (the plane's origin after offset).
+        const pivot = this.origin.add(offsetVec);
+        const toOrigin = Matrix4.fromTranslation(-pivot.x, -pivot.y, -pivot.z);
         const rotation = Matrix4.fromQuaternion(q);
-        const fromOrigin = Matrix4.fromTranslation(result.origin.x, result.origin.y, result.origin.z);
-        const matrix = fromOrigin.multiply(rotation).multiply(toOrigin);
-        return result.applyMatrix(matrix);
+        const fromOrigin = Matrix4.fromTranslation(pivot.x, pivot.y, pivot.z);
+        const rotationMatrix = fromOrigin.multiply(rotation).multiply(toOrigin);
+        return rotationMatrix.multiply(offsetMatrix);
     }
     applyMatrix(matrix) {
         return new Plane(matrix.transformPoint(this.origin), matrix.transformDirection(this.xDirection), matrix.transformDirection(this.normal), matrix.transformDirection(this.yDirection));

package/lib/dist/rendering/render.js

@@ -3,6 +3,7 @@ import { PlaneObjectBase } from "../features/plane-renderable-base.js";
 import { AxisObjectBase } from "../features/axis-renderable-base.js";
 import { Sketch } from "../features/2d/sketch.js";
 import { transformMeshes } from "./mesh-transform.js";
+import { ShapeOps } from "../oc/shape-ops.js";
 const meshBuilder = new MeshBuilder();
 function renderSceneObject(obj, scene, buildDurationMs) {
     const hasError = !!obj.getError();
@@ -199,6 +200,13 @@ export function renderScene(scene) {
                         return null;
                     },
                 });
+                const appliedTransform = object.getAppliedTransform();
+                if (appliedTransform && !object.isContainer()) {
+                    const shapes = object.getAddedShapes();
+                    for (let i = 0; i < shapes.length; i++) {
+                        shapes[i] = ShapeOps.transform(shapes[i], appliedTransform);
+                    }
+                }
             }
             catch (error) {
                 const message = error instanceof Error ? error.message : String(error);

package/lib/dist/tests/features/cut-two-distances.test.js

@@ -97,7 +97,7 @@ describe("cut two distances", () => {
                 move([25, 25]);
                 rect(50, 50);
             });
-            cut(20, 10).remove(e1);
+            cut(20, 10).scope(e1);
             const scene = render();
             // First box is cut, second box is untouched — 2 shapes
             expect(countShapes(scene)).toBe(2);

package/lib/dist/tests/features/cut.test.js

@@ -154,7 +154,7 @@ describe("cut", () => {
                 move([25, 25]);
                 rect(50, 50);
             });
-            cut(20).remove(e1);
+            cut(20).scope(e1);
             const scene = render();
             // First box is cut (modified), second box is untouched — 2 shapes
             expect(countShapes(scene)).toBe(2);