@design-core/core 0.0.5 → 0.0.7

package/core/tools/chamfer.js

@@ -3,10 +3,12 @@ import { ChamferFilletBase } from './chamferFilletBase.js';
 import { Intersection } from '../lib/intersect.js';
 import { Input, PromptOptions } from '../lib/inputManager.js';
 import { Logging } from '../lib/logging.js';
+import { Utils } from '../lib/utils.js';
 import { Point } from '../entities/point.js';
 import { Line } from '../entities/line.js';
 import { BasePolyline } from '../entities/basePolyline.js';
-import { AddState, RemoveState, UpdateState } from '../lib/stateManager.js';
+import { AddState } from '../lib/stateManager.js';
+import { Colour } from '../lib/colour.js';
 
 import { DesignCore } from '../designCore.js';
 
@@ -146,7 +148,46 @@ export class Chamfer extends ChamferFilletBase {
    * Preview the command during execution
    */
   preview() {
-    // No preview
+    const selection = this.validateSelection();
+    if (!selection) return;
+
+    const chamferMode = DesignCore.Scene.headers.chamferMode;
+    const trimMode = DesignCore.Scene.headers.trimMode;
+    const geo = this.#computeChamfer(this.firstPick, selection.tempSecond, selection.intersectionPoint);
+    if (!geo) return;
+    if (trimMode && !geo.chamferInBounds) return;
+
+    const isSharpCorner = !chamferMode &&
+      DesignCore.Scene.headers.chamferDistanceA === 0 &&
+      DesignCore.Scene.headers.chamferDistanceB === 0;
+
+    if (!trimMode) {
+      if (!isSharpCorner) DesignCore.Scene.previewEntities.add(geo.chamferLine);
+      return;
+    }
+
+    // trimMode: dull the original segments then show the shortened versions + chamfer line
+    const firstSeg = Utils.cloneObject(this.firstPick.activeSeg);
+    firstSeg.setProperty('colour', Colour.blend(this.firstPick.entity.getDrawColour(), DesignCore.Settings.canvasbackgroundcolour, DesignCore.Settings.previewBlendFactor));
+    DesignCore.Scene.previewEntities.add(firstSeg);
+
+    const secondSeg = Utils.cloneObject(selection.tempSecond.activeSeg);
+    secondSeg.setProperty('colour', Colour.blend(selection.tempSecond.entity.getDrawColour(), DesignCore.Settings.canvasbackgroundcolour, DesignCore.Settings.previewBlendFactor));
+    DesignCore.Scene.previewEntities.add(secondSeg);
+
+    const firstTrimLine = DesignCore.CommandManager.createNew('Line', {
+      points: [this.firstPick.lineKeptEnd(selection.intersectionPoint), geo.firstChamferPoint],
+      ...Utils.cloneProperties(this.firstPick.entity),
+    });
+    DesignCore.Scene.previewEntities.add(firstTrimLine);
+
+    const secondTrimLine = DesignCore.CommandManager.createNew('Line', {
+      points: [selection.tempSecond.lineKeptEnd(selection.intersectionPoint), geo.secondChamferPoint],
+      ...Utils.cloneProperties(selection.candidate),
+    });
+    DesignCore.Scene.previewEntities.add(secondTrimLine);
+
+    DesignCore.Scene.previewEntities.add(geo.chamferLine);
   }
 
   /**
@@ -156,174 +197,107 @@ export class Chamfer extends ChamferFilletBase {
     if (!this.firstPick.entity || !this.secondPick.entity) return;
     if (!this.resolveCornerGeometry(Strings.Message.NOCHAMFER)) return;
 
-    const trimMode = DesignCore.Scene.headers.trimMode;
     const chamferMode = DesignCore.Scene.headers.chamferMode;
-    const distA = DesignCore.Scene.headers.chamferDistanceA;
+    const trimMode = DesignCore.Scene.headers.trimMode;
 
-    // distA = distB = 0: trim/extend both lines to the sharp intersection with no chamfer line
-    if (!chamferMode && distA === 0 && DesignCore.Scene.headers.chamferDistanceB === 0) {
-      if (trimMode) {
-        const stateChanges = this.applySharpTrim();
-        DesignCore.Scene.commit(stateChanges);
+    // Validate angle before computing — parallel-lines error would be misleading
+    if (chamferMode) {
+      const alpha = DesignCore.Scene.headers.chamferAngle * (Math.PI / 180);
+      if (alpha <= 0 || alpha >= Math.PI) {
+        DesignCore.Core.notify(`${this.type} - ${Strings.Error.ERROR}:${Strings.Error.INVALIDNUMBER}`);
+        return;
       }
+    }
+
+    const geo = this.#computeChamfer(this.firstPick, this.secondPick, this.intersectionPoint);
+    if (!geo) {
+      DesignCore.Core.notify(`${this.type} - ${Strings.Error.ERROR}:${Strings.Error.PARALLELLINES}`);
+      return;
+    }
+
+    // dist=0 in distance mode: sharp corner trim with no chamfer line (mirrors fillet radius=0)
+    const isSharpCorner = !chamferMode &&
+      DesignCore.Scene.headers.chamferDistanceA === 0 &&
+      DesignCore.Scene.headers.chamferDistanceB === 0;
+
+    if (trimMode && !geo.chamferInBounds) {
+      DesignCore.Core.notify(`${this.type} - ${Strings.Error.MAXVALUE}`);
+      return;
+    }
+
+    if (!trimMode) {
+      if (!isSharpCorner) DesignCore.Scene.commit([new AddState(geo.chamferLine)]);
       return;
     }
 
-    // Compute the two chamfer endpoints on each line
-    const firstUnit = this.firstPick.clickUnit(this.intersectionPoint);
-    const secondUnit = this.secondPick.clickUnit(this.intersectionPoint);
+    const stateChanges = this.applyCornerTrim(
+        geo.firstChamferPoint, geo.secondChamferPoint,
+        isSharpCorner ? null : geo.chamferLine,
+    );
+    DesignCore.Scene.commit(stateChanges);
+  }
+
+  /**
+   * Compute the chamfer geometry for two picks meeting at intersectionPoint.
+   * Returns null if the lines are parallel/collinear or the chamfer direction is parallel to line2 (angle mode).
+   * @param {CornerEntity} firstPick
+   * @param {CornerEntity} secondPick
+   * @param {Point} intersectionPoint
+   * @return {{chamferLine, firstChamferPoint, secondChamferPoint, chamferInBounds}|null}
+   */
+  #computeChamfer(firstPick, secondPick, intersectionPoint) {
+    const chamferMode = DesignCore.Scene.headers.chamferMode;
+    const distA = DesignCore.Scene.headers.chamferDistanceA;
+    const firstUnit = firstPick.clickUnit(intersectionPoint);
+    const secondUnit = secondPick.clickUnit(intersectionPoint);
+
     let firstChamferPoint;
     let secondChamferPoint;
 
     if (!chamferMode) {
-      // Distance method: measure distA along line1 and distB along line2 from intersection
+      // Distance method: distA = distB = 0 means sharp corner trim with no chamfer line
       const distB = DesignCore.Scene.headers.chamferDistanceB;
-      firstChamferPoint = this.intersectionPoint.add(firstUnit.scale(distA));
-      secondChamferPoint = this.intersectionPoint.add(secondUnit.scale(distB));
+      firstChamferPoint = intersectionPoint.add(firstUnit.scale(distA));
+      secondChamferPoint = intersectionPoint.add(secondUnit.scale(distB));
     } else {
-      // Angle method: measure chamferLength along line1, then project using chamferAngle to find
-      // where the chamfer line meets line2.
-      // chamferAngle is stored in degrees (as entered by the user).
+      // Angle method
       const chamferLength = DesignCore.Scene.headers.chamferLength;
       const alpha = DesignCore.Scene.headers.chamferAngle * (Math.PI / 180);
+      if (alpha <= 0 || alpha >= Math.PI) return null;
 
-      if (alpha <= 0 || alpha >= Math.PI) {
-        DesignCore.Core.notify(`${this.type} - ${Strings.Error.ERROR}:${Strings.Error.INVALIDNUMBER}`);
-        return;
-      }
-
-      firstChamferPoint = this.intersectionPoint.add(firstUnit.scale(chamferLength));
+      firstChamferPoint = intersectionPoint.add(firstUnit.scale(chamferLength));
 
-      // Rotate firstUnit by ±(π - alpha) to get the chamfer direction from
-      // firstChamferPoint. Choose the rotation that points toward line2 (positive
-      // dot product with secondUnit).
       const rotAngle = Math.PI - alpha;
       const origin = new Point(0, 0);
       const candidate1 = firstUnit.rotate(origin, rotAngle);
       const chamferDir = candidate1.dot(secondUnit) >= 0 ? candidate1 : firstUnit.rotate(origin, -rotAngle);
 
-      // Intersect chamfer ray from firstChamferPoint with the infinite line2
       const chamferResult = Intersection.intersectSegmentSegment(
           firstChamferPoint, firstChamferPoint.add(chamferDir),
-          this.secondPick.lineStart, this.secondPick.lineEnd,
+          secondPick.lineStart, secondPick.lineEnd,
           true, true,
       );
+      if (chamferResult.status === Intersection.Status.PARALLEL ||
+          chamferResult.status === Intersection.Status.OVERLAPPING ||
+          chamferResult.status === Intersection.Status.COINCIDENT) return null;
 
-      const chamferStatus = chamferResult.status;
-      if (chamferStatus === Intersection.Status.PARALLEL ||
-          chamferStatus === Intersection.Status.OVERLAPPING ||
-          chamferStatus === Intersection.Status.COINCIDENT) {
-        DesignCore.Core.notify(`${this.type} - ${Strings.Error.ERROR}:${Strings.Error.PARALLELLINES}`);
-        return;
-      }
-
-      secondChamferPoint = chamferResult.points[0] || null;
-      if (!secondChamferPoint) {
-        // Chamfer direction is parallel to line2 — no intersection
-        DesignCore.Core.notify(`${this.type} - ${Strings.Error.ERROR}:${Strings.Error.PARALLELLINES}`);
-        return;
-      }
+      secondChamferPoint = chamferResult.points[0];
+      if (!secondChamferPoint) return null;
     }
 
-    // Verify both chamfer endpoints lie on the correct side of the intersection and
-    // not beyond the kept endpoints.  Uses the same dot-product approach as Fillet so
-    // that segments are treated as infinite lines (extensions are allowed).
-    if (trimMode) {
-      const firstKeptDir = this.firstPick.lineKeptEnd(this.intersectionPoint).subtract(this.intersectionPoint);
-      const secondKeptDir = this.secondPick.lineKeptEnd(this.intersectionPoint).subtract(this.intersectionPoint);
-      const firstChamferDot = firstChamferPoint.subtract(this.intersectionPoint).dot(firstKeptDir);
-      const secondChamferDot = secondChamferPoint.subtract(this.intersectionPoint).dot(secondKeptDir);
-      if (firstChamferDot < 0 || firstChamferDot > firstKeptDir.dot(firstKeptDir) ||
-          secondChamferDot < 0 || secondChamferDot > secondKeptDir.dot(secondKeptDir)) {
-        DesignCore.Core.notify(`${this.type} - ${Strings.Error.MAXVALUE}`);
-        return;
-      }
-    }
+    const firstKeptDir = firstPick.lineKeptEnd(intersectionPoint).subtract(intersectionPoint);
+    const secondKeptDir = secondPick.lineKeptEnd(intersectionPoint).subtract(intersectionPoint);
+    const firstDot = firstChamferPoint.subtract(intersectionPoint).dot(firstKeptDir);
+    const secondDot = secondChamferPoint.subtract(intersectionPoint).dot(secondKeptDir);
+    const chamferInBounds = firstDot >= 0 && firstDot <= firstKeptDir.dot(firstKeptDir) &&
+                            secondDot >= 0 && secondDot <= secondKeptDir.dot(secondKeptDir);
 
     const chamferLine = DesignCore.CommandManager.createNew('Line', {
       points: [firstChamferPoint, secondChamferPoint],
+      ...Utils.cloneProperties(firstPick.entity),
     });
 
-    const firstIsPolyline = this.firstPick.entity instanceof BasePolyline;
-    const secondIsPolyline = this.secondPick.entity instanceof BasePolyline;
-
-    // The standalone chamfer Line entity is added when no polyline trimming is involved.
-    // For polyline trim cases the chamfer segment is encoded as a straight polyline segment,
-    // except for the open-ends case where the chamfer line fills the gap between the two
-    // open ends and is added separately there.
-    const stateChanges = (!trimMode || (!firstIsPolyline && !secondIsPolyline)) ?
-      [new AddState(chamferLine)] :
-      [];
-
-    if (trimMode) {
-      if (!firstIsPolyline && !secondIsPolyline) {
-        // Line + Line: trim both lines
-        stateChanges.push(new UpdateState(this.firstPick.entity, { points: [this.firstPick.lineKeptEnd(this.intersectionPoint), firstChamferPoint] }));
-        stateChanges.push(new UpdateState(this.secondPick.entity, { points: [this.secondPick.lineKeptEnd(this.intersectionPoint), secondChamferPoint] }));
-      } else if (firstIsPolyline && secondIsPolyline && this.firstPick.entity === this.secondPick.entity) {
-        const closeSegIdx = this.firstPick.entity.points.length;
-        const lastIdx = closeSegIdx - 1;
-        const segDiff = Math.abs(this.firstPick.segmentIndex - this.secondPick.segmentIndex);
-        const isOpenEnds = !this.firstPick.entity.flags.hasFlag(1) && segDiff !== 1 && (
-          (this.firstPick.segmentIndex === 1 && this.secondPick.segmentIndex === lastIdx) ||
-          (this.firstPick.segmentIndex === lastIdx && this.secondPick.segmentIndex === 1)
-        );
-        const newPoints = this.firstPick.entity.points.map((p) => p.clone());
-        if (isOpenEnds) {
-          // Open ends: trim both endpoints to their chamfer points; chamfer line fills the gap.
-          stateChanges.push(new AddState(chamferLine));
-          if (this.firstPick.segmentIndex === 1) {
-            newPoints[0] = firstChamferPoint.clone();
-            newPoints[lastIdx] = secondChamferPoint.clone();
-          } else {
-            newPoints[0] = secondChamferPoint.clone();
-            newPoints[lastIdx] = firstChamferPoint.clone();
-          }
-        } else {
-          // Consecutive segments: replace the shared corner vertex with the two chamfer points
-          // as a straight polyline segment — no separate chamfer Line entity needed.
-          const seg1 = this.firstPick.segmentIndex;
-          const seg2 = this.secondPick.segmentIndex;
-          const isClosingWrap = (seg1 === closeSegIdx && seg2 === 1) || (seg2 === closeSegIdx && seg1 === 1);
-          const isFirstLower = seg1 < seg2;
-          const cornerIdx = isClosingWrap ? 0 : Math.min(seg1, seg2);
-          const lowerChamfer = (isClosingWrap ? seg1 === closeSegIdx : !isFirstLower) ? secondChamferPoint : firstChamferPoint;
-          const upperChamfer = (isClosingWrap ? seg1 === closeSegIdx : !isFirstLower) ? firstChamferPoint : secondChamferPoint;
-          newPoints.splice(cornerIdx, 1, lowerChamfer.clone(), upperChamfer.clone());
-        }
-        stateChanges.push(new UpdateState(this.firstPick.entity, { points: newPoints }));
-      } else {
-        // Line + Polyline or Polyline + Line: consume the line into the polyline.
-        const [poly, line] = firstIsPolyline ? [this.firstPick, this.secondPick] : [this.secondPick, this.firstPick];
-        const polyChamferPoint = poly === this.firstPick ? firstChamferPoint : secondChamferPoint;
-        const lineChamferPoint = line === this.firstPick ? firstChamferPoint : secondChamferPoint;
-        const polySegIdx = poly.segmentIndex;
-        const keepStart = poly.keepStart(this.intersectionPoint);
-        let newPoints;
-        if (keepStart) {
-          // Keep start portion: points[0..polySegIdx-1], then chamfer, then line end
-          newPoints = [
-            ...poly.entity.points.slice(0, polySegIdx).map((p) => p.clone()),
-            polyChamferPoint.clone(),
-            lineChamferPoint.clone(),
-            line.lineKeptEnd(this.intersectionPoint).clone(),
-          ];
-        } else {
-          // Keep end portion: line end, then chamfer, then points[polySegIdx..end]
-          newPoints = [
-            line.lineKeptEnd(this.intersectionPoint).clone(),
-            lineChamferPoint.clone(),
-            polyChamferPoint.clone(),
-            ...poly.entity.points.slice(polySegIdx).map((p) => p.clone()),
-          ];
-        }
-
-        stateChanges.push(new RemoveState(line.entity));
-        stateChanges.push(new UpdateState(poly.entity, { points: newPoints }));
-      }
-    }
-
-    DesignCore.Scene.commit(stateChanges);
+    return { chamferLine, firstChamferPoint, secondChamferPoint, chamferInBounds };
   }
 
   /**

package/core/tools/chamferFilletBase.js

@@ -1,8 +1,9 @@
 import { Tool } from './tool.js';
 import { Strings } from '../lib/strings.js';
 import { Constants } from '../lib/constants.js';
+import { Line } from '../entities/line.js';
 import { BasePolyline } from '../entities/basePolyline.js';
-import { RemoveState, UpdateState } from '../lib/stateManager.js';
+import { AddState, RemoveState, UpdateState } from '../lib/stateManager.js';
 import { CornerEntity } from './cornerEntity.js';
 import { Intersection } from '../lib/intersect.js';
 
@@ -11,7 +12,7 @@ import { DesignCore } from '../designCore.js';
 /**
  * ChamferFilletBase Class
  * Base class for Chamfer and Fillet commands, providing shared entity selection
- * state, segment resolution, and sharp-trim logic.
+ * state, segment resolution, and shared corner-trim logic.
  * @extends Tool
  */
 export class ChamferFilletBase extends Tool {
@@ -90,74 +91,174 @@ export class ChamferFilletBase extends Tool {
   }
 
   /**
-   * Trim both entities to the sharp intersection point with no arc or chamfer line.
-   * Handles Line+Line, Polyline+Polyline (same entity), and Line+Polyline cases.
-   * Reads geometry from instance fields set by resolveCornerGeometry().
-   * @return {Array} - array of state changes to be committed by the caller
+   * Resolves the preview second-pick and virtual intersection for the mouse position.
+   * Returns { candidate, tempSecond, intersectionPoint } or null if no valid preview exists.
+   * @return {{candidate, tempSecond, intersectionPoint}|null}
    */
-  applySharpTrim() {
+  validateSelection() {
+    if (!this.firstPick.entity) return null;
+    if (!this.firstPick.resolveEndpoints()) return null;
+
+    const mousePoint = DesignCore.Mouse.pointOnScene();
+    const index = DesignCore.Scene.selectionManager.findClosestItem(mousePoint);
+    if (index === undefined) return null;
+
+    const candidate = DesignCore.Scene.entities.get(index);
+    if (!(candidate instanceof Line) && !(candidate instanceof BasePolyline)) return null;
+
+    const tempSecond = new CornerEntity();
+    if (!tempSecond.setPick(candidate, mousePoint, '')) return null;
+    if (!tempSecond.resolveEndpoints()) return null;
+
+    const result = Intersection.intersectSegmentSegment(
+        this.firstPick.lineStart, this.firstPick.lineEnd,
+        tempSecond.lineStart, tempSecond.lineEnd,
+        true, true,
+    );
+    if (result.status === Intersection.Status.PARALLEL ||
+        result.status === Intersection.Status.OVERLAPPING ||
+        result.status === Intersection.Status.COINCIDENT) return null;
+
+    const intersectionPoint = result.points[0];
+    if (!intersectionPoint) return null;
+
+    return { candidate, tempSecond, intersectionPoint };
+  }
+
+  /**
+   * Unified corner-trim method for sharp trims, chamfer, and fillet.
+   * Computes and applies state changes based on entity types.
+   *
+   * For sharp trims (newEntity === null), both corner points are the intersection
+   * point and a single point is spliced/assigned (not two copies).
+   *
+   * For fillet, firstCornerPoint carries the arc bulge from arc.toPolylinePoints().
+   * This method transfers the bulge to whichever point comes first in the polyline
+   * traversal order, ensuring correct arc encoding.
+   *
+   * @param {Point} firstCornerPoint - trim/chamfer/tangent point on the first entity
+   * @param {Point} secondCornerPoint - trim/chamfer/tangent point on the second entity
+   * @param {Entity|null} newEntity - entity to add (Arc for fillet, Line for chamfer, null for sharp trim)
+   * @return {Array} - array of state changes
+   */
+  applyCornerTrim(firstCornerPoint, secondCornerPoint, newEntity) {
+    const isSharpTrim = newEntity === null;
     const firstIsPolyline = this.firstPick.entity instanceof BasePolyline;
     const secondIsPolyline = this.secondPick.entity instanceof BasePolyline;
 
-    // Line + Line: trim both lines to the intersection point.
+    // Two standalone entities: update both, optionally add the new entity.
     if (!firstIsPolyline && !secondIsPolyline) {
-      return [
-        new UpdateState(this.firstPick.entity, { points: [this.firstPick.lineKeptEnd(this.intersectionPoint), this.intersectionPoint] }),
-        new UpdateState(this.secondPick.entity, { points: [this.secondPick.lineKeptEnd(this.intersectionPoint), this.intersectionPoint] }),
-      ];
+      const stateChanges = isSharpTrim ? [] : [new AddState(newEntity)];
+      // Corner points may carry a bulge value from arc.toPolylinePoints() — a Line
+      // endpoint must never have a non-zero bulge or it renders as an arc.
+      // toPolylinePoints() returns fresh Point objects so direct mutation is safe.
+      firstCornerPoint.bulge = 0;
+      secondCornerPoint.bulge = 0;
+      stateChanges.push(
+          new UpdateState(this.firstPick.entity, { points: [this.firstPick.lineKeptEnd(this.intersectionPoint), firstCornerPoint] }),
+          new UpdateState(this.secondPick.entity, { points: [this.secondPick.lineKeptEnd(this.intersectionPoint), secondCornerPoint] }),
+      );
+      return stateChanges;
     }
 
-    // Polyline + Polyline (same entity): replace the shared corner vertex (or open endpoints)
-    // with the intersection point.
+    // Same polyline: splice the corner points into the point array.
     if (firstIsPolyline && secondIsPolyline && this.firstPick.entity === this.secondPick.entity) {
-      const lastIdx = this.firstPick.entity.points.length - 1;
+      const closeSegIdx = this.firstPick.entity.points.length;
+      const lastIdx = closeSegIdx - 1;
       const segDiff = Math.abs(this.firstPick.segmentIndex - this.secondPick.segmentIndex);
       const isOpenEnds = !this.firstPick.entity.flags.hasFlag(1) && segDiff !== 1 && (
         (this.firstPick.segmentIndex === 1 && this.secondPick.segmentIndex === lastIdx) ||
         (this.firstPick.segmentIndex === lastIdx && this.secondPick.segmentIndex === 1)
       );
-
       const newPoints = this.firstPick.entity.points.map((p) => p.clone());
+      const stateChanges = [];
 
       if (isOpenEnds) {
-        newPoints[0] = this.intersectionPoint.clone();
-        newPoints[lastIdx] = this.intersectionPoint.clone();
+        if (!isSharpTrim) stateChanges.push(new AddState(newEntity));
+        if (this.firstPick.segmentIndex === 1) {
+          newPoints[0] = firstCornerPoint.clone();
+          newPoints[lastIdx] = secondCornerPoint.clone();
+        } else {
+          newPoints[0] = secondCornerPoint.clone();
+          newPoints[lastIdx] = firstCornerPoint.clone();
+        }
       } else {
-        const closeSegIdx = this.firstPick.entity.points.length;
         const seg1 = this.firstPick.segmentIndex;
         const seg2 = this.secondPick.segmentIndex;
         const isClosingWrap = (seg1 === closeSegIdx && seg2 === 1) || (seg2 === closeSegIdx && seg1 === 1);
+        const isFirstLower = seg1 < seg2;
         const cornerIdx = isClosingWrap ? 0 : Math.min(seg1, seg2);
-        newPoints.splice(cornerIdx, 1, this.intersectionPoint.clone());
+
+        if (isSharpTrim) {
+          // Sharp trim: splice in a single copy of the intersection point.
+          newPoints.splice(cornerIdx, 1, firstCornerPoint.clone());
+        } else {
+          // Chamfer/fillet: splice in two points. Ensure the bulge (if any) is on
+          // the lower point (the one that comes first in polyline traversal).
+          const swapped = isClosingWrap ? seg1 !== closeSegIdx : !isFirstLower;
+          const lowerSrc = swapped ? secondCornerPoint : firstCornerPoint;
+          const upperSrc = swapped ? firstCornerPoint : secondCornerPoint;
+          const arcBulge = firstCornerPoint.bulge || 0;
+          const lowerClone = lowerSrc.clone();
+          const upperClone = upperSrc.clone();
+          lowerClone.bulge = swapped ? -arcBulge : arcBulge;
+          upperClone.bulge = 0;
+          newPoints.splice(cornerIdx, 1, lowerClone, upperClone);
+        }
       }
-      return [new UpdateState(this.firstPick.entity, { points: newPoints })];
+
+      stateChanges.push(new UpdateState(this.firstPick.entity, { points: newPoints }));
+      return stateChanges;
     }
 
-    // Line + Polyline (or Polyline + Line): consume the line into the polyline.
-    const poly = firstIsPolyline ? this.firstPick : this.secondPick;
-    const line = firstIsPolyline ? this.secondPick : this.firstPick;
+    // Standalone + Polyline: consume the standalone entity into the polyline.
+    const [poly, standalone] = firstIsPolyline ? [this.firstPick, this.secondPick] : [this.secondPick, this.firstPick];
+    const polyCornerPoint = poly === this.firstPick ? firstCornerPoint : secondCornerPoint;
+    const standaloneCornerPoint = poly === this.firstPick ? secondCornerPoint : firstCornerPoint;
+    const arcBulge = firstCornerPoint.bulge || 0;
     const polySegIdx = poly.segmentIndex;
     const keepStart = poly.keepStart(this.intersectionPoint);
     let newPoints;
-    if (keepStart) {
-      // Keep the polyline points up to (not including) the selected segment start,
-      // trim to the intersection and append the kept end of the line.
+    if (isSharpTrim) {
+      // Sharp trim: single intersection point between poly and standalone kept ends.
+      if (keepStart) {
+        newPoints = [
+          ...poly.entity.points.slice(0, polySegIdx).map((p) => p.clone()),
+          polyCornerPoint.clone(),
+          standalone.lineKeptEnd(this.intersectionPoint).clone(),
+        ];
+      } else {
+        newPoints = [
+          standalone.lineKeptEnd(this.intersectionPoint).clone(),
+          polyCornerPoint.clone(),
+          ...poly.entity.points.slice(polySegIdx).map((p) => p.clone()),
+        ];
+      }
+    } else if (keepStart) {
+      // Keep start: [...polyBefore, polyCorner(with bulge), standaloneCorner, lineKeptEnd]
+      // The arc runs from polyCorner to standaloneCorner in polyline traversal order.
+      const polyClone = polyCornerPoint.clone();
+      polyClone.bulge = poly === this.firstPick ? arcBulge : -arcBulge;
       newPoints = [
         ...poly.entity.points.slice(0, polySegIdx).map((p) => p.clone()),
-        this.intersectionPoint.clone(),
-        line.lineKeptEnd(this.intersectionPoint).clone(),
+        polyClone,
+        standaloneCornerPoint.clone(),
+        standalone.lineKeptEnd(this.intersectionPoint).clone(),
       ];
     } else {
-      // Keep the polyline points from the selected segment start onwards,
-      // prepending the kept end of the line and the intersection.
+      // Keep end: [lineKeptEnd, standaloneCorner(with negated bulge), polyCorner, ...polyAfter]
+      // The arc runs from standaloneCorner to polyCorner in reversed traversal.
+      const standaloneClone = standaloneCornerPoint.clone();
+      standaloneClone.bulge = poly === this.firstPick ? -arcBulge : arcBulge;
       newPoints = [
-        line.lineKeptEnd(this.intersectionPoint).clone(),
-        this.intersectionPoint.clone(),
+        standalone.lineKeptEnd(this.intersectionPoint).clone(),
+        standaloneClone,
+        polyCornerPoint.clone(),
         ...poly.entity.points.slice(polySegIdx).map((p) => p.clone()),
       ];
     }
     return [
-      new RemoveState(line.entity),
+      new RemoveState(standalone.entity),
       new UpdateState(poly.entity, { points: newPoints }),
     ];
   }

package/core/tools/copy.js

@@ -7,6 +7,7 @@ import { Point } from '../entities/point.js';
 import { AddState } from '../lib/stateManager.js';
 
 import { DesignCore } from '../designCore.js';
+import { RubberBand } from '../lib/auxiliary/rubberBand.js';
 
 /**
  * Copy Command Class
@@ -77,9 +78,8 @@ export class Copy extends Tool {
     if (this.points.length >= 1) {
       const mousePoint = DesignCore.Mouse.pointOnScene();
 
-      // Draw a line
-      const points = [this.points.at(-1), mousePoint];
-      DesignCore.Scene.tempEntities.create('Line', { points: points });
+      // Draw a rubber-band line from base point to mouse
+      DesignCore.Scene.auxiliaryEntities.add(new RubberBand([this.points.at(-1), mousePoint]));
 
       const delta = mousePoint.subtract(this.lastMousePoint || this.points[0]);
       this.lastMousePoint = mousePoint;

package/core/tools/explode.js

@@ -92,13 +92,13 @@ export class Explode extends Tool {
       const block = insert.block;
       const blockItems = block.items;
 
-      const rotation = Utils.degrees2radians(insert.rotation);
+      const rotation = Utils.degrees2radians(insert.getProperty('rotation'));
       const origin = new Point(0, 0);
 
       blockItems.forEach((blockItem) => {
         const copyofitem = Utils.cloneObject(blockItem);
         const points = copyofitem.points.map((p) => new Point(p.x, p.y, p.bulge, p.sequence).rotate(origin, rotation).add(insertPoint));
-        copyofitem.setProperty('points', points);
+        copyofitem.points = points;
         const stateChange = new AddState(copyofitem);
         stateChanges.push(stateChange);
       });