@design-core/core 0.0.1 → 0.0.3

package/core/tables/ucsManager.js

@@ -0,0 +1,44 @@
+import { DXFFile } from '../lib/dxf/dxfFile.js';
+import { TableManagerBase } from './tableManagerBase.js';
+import { UCS } from './ucs.js';
+
+/**
+ * UCSManager Class
+ * @extends TableManagerBase
+ */
+export class UCSManager extends TableManagerBase {
+  /** Create a UCSManager */
+  constructor() {
+    super();
+
+    this.itemProperty = 'ucs';
+  }
+
+  /** Get the item class */
+  get itemClass() {
+    return UCS;
+  }
+
+  /** Add standard items */
+  addStandardItems() {
+    // No standard UCS items
+  }
+
+  /**
+   * Write the table to file in the dxf format
+   * @param {DXFFile} file
+   */
+  dxf(file) {
+    file.writeGroupCode('0', 'TABLE', DXFFile.Version.R2000);
+    file.writeGroupCode('2', 'UCS', DXFFile.Version.R2000);
+    file.writeGroupCode('5', this.handle, DXFFile.Version.R2000);
+    file.writeGroupCode('100', 'AcDbSymbolTable', DXFFile.Version.R2000);
+    file.writeGroupCode('70', this.itemCount(), DXFFile.Version.R2000);
+
+    for (let i = 0; i < this.itemCount(); i++) {
+      this.getItemByIndex(i).dxf(file);
+    }
+
+    file.writeGroupCode('0', 'ENDTAB', DXFFile.Version.R2000);
+  }
+}

package/core/tables/view.js

@@ -0,0 +1,28 @@
+import { DXFFile } from '../lib/dxf/dxfFile.js';
+import { Property } from '../properties/property.js';
+
+/** View Class */
+export class View {
+  /**
+   * Create a View
+   * @param {Object} data
+   */
+  constructor(data) {
+    // DXF Groupcode 5 - Handle
+    this.handle = Property.loadValue([data?.handle, data?.[5]]);
+    // DXF Groupcode 2 - Name
+    this.name = Property.loadValue([data?.name, data?.[2]], '');
+  }
+
+  /**
+   * Write the item to file in the dxf format
+   * @param {DXFFile} file
+   */
+  dxf(file) {
+    file.writeGroupCode('0', 'VIEW', DXFFile.Version.R2000);
+    file.writeGroupCode('5', this.handle, DXFFile.Version.R2000);
+    file.writeGroupCode('100', 'AcDbSymbolTableRecord', DXFFile.Version.R2000);
+    file.writeGroupCode('100', 'AcDbViewTableRecord', DXFFile.Version.R2000);
+    file.writeGroupCode('2', this.name, DXFFile.Version.R2000);
+  }
+}

package/core/tables/viewManager.js

@@ -0,0 +1,44 @@
+import { DXFFile } from '../lib/dxf/dxfFile.js';
+import { TableManagerBase } from './tableManagerBase.js';
+import { View } from './view.js';
+
+/**
+ * ViewManager Class
+ * @extends TableManagerBase
+ */
+export class ViewManager extends TableManagerBase {
+  /** Create a ViewManager */
+  constructor() {
+    super();
+
+    this.itemProperty = 'view';
+  }
+
+  /** Get the item class */
+  get itemClass() {
+    return View;
+  }
+
+  /** Add standard items */
+  addStandardItems() {
+    // No standard view items
+  }
+
+  /**
+   * Write the table to file in the dxf format
+   * @param {DXFFile} file
+   */
+  dxf(file) {
+    file.writeGroupCode('0', 'TABLE', DXFFile.Version.R2000);
+    file.writeGroupCode('2', 'VIEW', DXFFile.Version.R2000);
+    file.writeGroupCode('5', this.handle, DXFFile.Version.R2000);
+    file.writeGroupCode('100', 'AcDbSymbolTable', DXFFile.Version.R2000);
+    file.writeGroupCode('70', this.itemCount(), DXFFile.Version.R2000);
+
+    for (let i = 0; i < this.itemCount(); i++) {
+      this.getItemByIndex(i).dxf(file);
+    }
+
+    file.writeGroupCode('0', 'ENDTAB', DXFFile.Version.R2000);
+  }
+}

package/core/tables/vport.js

@@ -0,0 +1,70 @@
+import { DXFFile } from '../lib/dxf/dxfFile.js';
+import { Property } from '../properties/property.js';
+
+/** VPort Class */
+export class VPort {
+  /**
+   * Create a VPort
+   * @param {Object} data
+   */
+  constructor(data) {
+    // DXF Groupcode 5 - Handle
+    this.handle = Property.loadValue([data?.handle, data?.[5]]);
+    // DXF Groupcode 2 - Name
+    this.name = Property.loadValue([data?.name, data?.[2]], '*ACTIVE');
+    // DXF Groupcode 12 - View center X
+    this.viewCenterX = Property.loadValue([data?.viewCenterX, data?.[12]], 0);
+    // DXF Groupcode 22 - View center Y
+    this.viewCenterY = Property.loadValue([data?.viewCenterY, data?.[22]], 0);
+    // DXF Groupcode 40 - VPort height
+    this.height = Property.loadValue([data?.height, data?.[40]], 0);
+    // DXF Groupcode 41 - VPort width/height ratio
+    this.ratio = Property.loadValue([data?.ratio, data?.[41]], 0);
+  }
+
+  /**
+   * Write the item to file in the dxf format
+   * @param {DXFFile} file
+   */
+  dxf(file) {
+    file.writeGroupCode('0', 'VPORT');
+    file.writeGroupCode('5', this.handle, DXFFile.Version.R2000);
+    file.writeGroupCode('100', 'AcDbSymbolTableRecord', DXFFile.Version.R2000);
+    file.writeGroupCode('100', 'AcDbViewportTableRecord', DXFFile.Version.R2000);
+    file.writeGroupCode('2', this.name);
+    file.writeGroupCode('70', '0'); // vport flags
+    file.writeGroupCode('10', '0.0'); // lower left corner x pos
+    file.writeGroupCode('20', '0.0'); // lower left corner y pos
+    file.writeGroupCode('11', '1.0'); // upper right corner x pos
+    file.writeGroupCode('21', '1.0'); // upper right corner y pos
+    file.writeGroupCode('12', this.viewCenterX); // view centre x pos
+    file.writeGroupCode('22', this.viewCenterY); // view centre y pos
+    file.writeGroupCode('13', '0.0'); // snap base point x
+    file.writeGroupCode('23', '0.0'); // snap base point y
+    file.writeGroupCode('14', '10.0'); // snap spacing x
+    file.writeGroupCode('24', '10.0'); // snap spacing y
+    file.writeGroupCode('15', '10.0'); // grid spacing x
+    file.writeGroupCode('25', '10.0'); // grid spacing y
+    file.writeGroupCode('16', '0.0'); // view direction (x) from target point
+    file.writeGroupCode('26', '0.0'); // view direction (y) from target point
+    file.writeGroupCode('36', '1.0'); // view direction (z) from target point
+    file.writeGroupCode('17', '0.0'); // view target point x
+    file.writeGroupCode('27', '0.0'); // view target point y
+    file.writeGroupCode('37', '0.0'); // view target point z
+    file.writeGroupCode('40', this.height); // VPort Height
+    file.writeGroupCode('41', this.ratio); // Vport height/width ratio
+    file.writeGroupCode('42', '50.0'); // Lens Length
+    file.writeGroupCode('43', '0.0'); // Front Clipping Plane
+    file.writeGroupCode('44', '0.0'); // Back Clipping Plane
+    file.writeGroupCode('50', '0.0'); // Snap Rotation Angle
+    file.writeGroupCode('51', '0.0'); // View Twist Angle
+    file.writeGroupCode('71', '0.0'); // Viewmode (System variable)
+    file.writeGroupCode('72', '1000'); // Circle sides
+    file.writeGroupCode('73', '1'); // fast zoom setting
+    file.writeGroupCode('74', '3'); // UCSICON Setting
+    file.writeGroupCode('75', '0'); // snap on/off
+    file.writeGroupCode('76', '1'); // grid on/off
+    file.writeGroupCode('77', '0'); // snap style
+    file.writeGroupCode('78', '0'); // snap isopair
+  }
+}

package/core/tables/vportManager.js

@@ -0,0 +1,65 @@
+import { DXFFile } from '../lib/dxf/dxfFile.js';
+import { TableManagerBase } from './tableManagerBase.js';
+import { VPort } from './vport.js';
+
+import { DesignCore } from '../designCore.js';
+
+/**
+ * VPortManager Class
+ * @extends TableManagerBase
+ */
+export class VPortManager extends TableManagerBase {
+  /** Create a VPortManager */
+  constructor() {
+    super();
+
+    this.itemProperty = 'vport';
+  }
+
+  /** Get the item class */
+  get itemClass() {
+    return VPort;
+  }
+
+  /** Add standard items */
+  addStandardItems() {
+    this.addItem({ name: '*ACTIVE' });
+  }
+
+  /**
+   * Update the active vport from the scene
+   */
+  updateFromScene() {
+    const extents = DesignCore.Scene.boundingBox();
+    const vport = this.getItemByName('*ACTIVE');
+
+    if (extents && vport) {
+      const width = extents.xLength;
+      const height = extents.yLength;
+      vport.viewCenterX = extents.xMin + width / 2;
+      vport.viewCenterY = extents.yMin + height / 2;
+      vport.height = height;
+      vport.ratio = height === 0 ? 1 : width / height;
+    }
+  }
+
+  /**
+   * Write the table to file in the dxf format
+   * @param {DXFFile} file
+   */
+  dxf(file) {
+    this.updateFromScene();
+
+    file.writeGroupCode('0', 'TABLE');
+    file.writeGroupCode('2', 'VPORT');
+    file.writeGroupCode('5', this.handle, DXFFile.Version.R2000);
+    file.writeGroupCode('100', 'AcDbSymbolTable', DXFFile.Version.R2000);
+    file.writeGroupCode('70', this.itemCount());
+
+    for (let i = 0; i < this.itemCount(); i++) {
+      this.getItemByIndex(i).dxf(file);
+    }
+
+    file.writeGroupCode('0', 'ENDTAB');
+  }
+}

package/core/tools/chamfer.js

@@ -0,0 +1,343 @@
+import { Strings } from '../lib/strings.js';
+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 { 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 { DesignCore } from '../designCore.js';
+
+/**
+ * Chamfer Command Class
+ * @extends ChamferFilletBase
+ */
+export class Chamfer extends ChamferFilletBase {
+  /**
+   * Register the command
+   * @return {Object}
+   * command = name of the command
+   * shortcut = shortcut for the command
+   * type = type to group command in toolbars (omitted if not shown)
+   */
+  static register() {
+    const command = { command: 'Chamfer', shortcut: 'CHA' };
+    return command;
+  }
+
+  /**
+   * Execute method
+   * executes the workflow, requesting input required to perform the command
+   */
+  async execute() {
+    try {
+      this.#notifySettings();
+
+      while (true) {
+        const op1 = new PromptOptions(Strings.Input.SELECT, [Input.Type.SINGLESELECTION], ['Distance', 'Angle', 'Trim', 'Method']);
+        const input1 = await DesignCore.Scene.inputManager.requestInput(op1);
+        if (input1 === undefined) return;
+
+        if (Input.getType(input1) === Input.Type.STRING) {
+          if (input1 === 'Distance') {
+            const dop1 = new PromptOptions('Specify first chamfer distance', [Input.Type.NUMBER]);
+            const d1 = await DesignCore.Scene.inputManager.requestInput(dop1);
+            if (d1 === undefined) return;
+            if (d1 < 0) {
+              DesignCore.Core.notify(`${this.type} - ${Strings.Error.INVALIDNUMBER}`);
+            } else {
+              DesignCore.Scene.headers.chamferDistanceA = d1;
+              const dop2 = new PromptOptions('Specify second chamfer distance', [Input.Type.NUMBER]);
+              const d2 = await DesignCore.Scene.inputManager.requestInput(dop2);
+              if (d2 === undefined) return;
+              if (d2 < 0) {
+                DesignCore.Core.notify(`${this.type} - ${Strings.Error.INVALIDNUMBER}`);
+              } else {
+                DesignCore.Scene.headers.chamferDistanceB = d2;
+              }
+            }
+            this.#notifySettings();
+          } else if (input1 === 'Angle') {
+            const lop = new PromptOptions('Specify chamfer length on first line', [Input.Type.NUMBER]);
+            const len = await DesignCore.Scene.inputManager.requestInput(lop);
+            if (len === undefined) return;
+            if (len < 0) {
+              DesignCore.Core.notify(`${this.type} - ${Strings.Error.INVALIDNUMBER}`);
+            } else {
+              DesignCore.Scene.headers.chamferLength = len;
+              const aop = new PromptOptions(Strings.Input.ANGLE, [Input.Type.NUMBER]);
+              const ang = await DesignCore.Scene.inputManager.requestInput(aop);
+              if (ang === undefined) return;
+              if (ang <= 0 || ang >= 180) {
+                DesignCore.Core.notify(`${this.type} - ${Strings.Error.INVALIDNUMBER}`);
+              } else {
+                DesignCore.Scene.headers.chamferAngle = ang;
+              }
+            }
+            this.#notifySettings();
+          } else if (input1 === 'Trim') {
+            const top = new PromptOptions(Strings.Input.OPTION, [], ['Trim', 'No trim']);
+            const trimInput = await DesignCore.Scene.inputManager.requestInput(top);
+            if (trimInput === undefined) return;
+            DesignCore.Scene.headers.trimMode = (trimInput === 'Trim');
+            this.#notifySettings();
+          } else if (input1 === 'Method') {
+            const mop = new PromptOptions(Strings.Input.OPTION, [], ['Distance', 'Angle']);
+            const methodInput = await DesignCore.Scene.inputManager.requestInput(mop);
+            if (methodInput === undefined) return;
+            DesignCore.Scene.headers.chamferMode = (methodInput === 'Angle');
+            this.#notifySettings();
+          }
+          continue;
+        }
+
+        // input1 is a selection — validate and store first entity
+        const firstEntity = DesignCore.Scene.entities.get(input1.selectedItemIndex);
+        DesignCore.Scene.selectionManager.removeLastSelection();
+        if (!(firstEntity instanceof Line) && !(firstEntity instanceof BasePolyline)) {
+          DesignCore.Core.notify(`${firstEntity.type} - ${Strings.Message.NOCHAMFER}`);
+          continue;
+        }
+        if (!this.firstPick.setPick(firstEntity, input1.selectedPoint, `${Strings.Strings.ARC} - ${Strings.Message.NOCHAMFER}`)) continue;
+
+        // Prompt for second object
+        const op2 = new PromptOptions(Strings.Input.SELECT, [Input.Type.SINGLESELECTION]);
+        while (true) {
+          const input2 = await DesignCore.Scene.inputManager.requestInput(op2);
+          if (input2 === undefined) return;
+
+          const candidate = DesignCore.Scene.entities.get(input2.selectedItemIndex);
+          DesignCore.Scene.selectionManager.removeLastSelection();
+          if (!(candidate instanceof Line) && !(candidate instanceof BasePolyline)) {
+            DesignCore.Core.notify(`${this.type} - ${candidate.type} ${Strings.Message.NOCHAMFER}`);
+            continue;
+          }
+          if (!this.secondPick.setPick(candidate, input2.selectedPoint, `${Strings.Strings.ARC} - ${Strings.Message.NOCHAMFER}`)) continue;
+          // If both selections are the same polyline, segments must be consecutive
+          // or they must be the open-end segments of an open polyline.
+          if (candidate === firstEntity && firstEntity instanceof BasePolyline) {
+            const isConsecutive = firstEntity.areConsecutiveSegments(this.firstPick.segmentIndex, this.secondPick.segmentIndex);
+            const lastIdx = firstEntity.points.length - 1;
+            const isOpenEnds = !firstEntity.flags.hasFlag(1) &&
+              ((this.firstPick.segmentIndex === 1 && this.secondPick.segmentIndex === lastIdx) ||
+               (this.secondPick.segmentIndex === 1 && this.firstPick.segmentIndex === lastIdx));
+            if (!isConsecutive && !isOpenEnds) {
+              DesignCore.Core.notify(`${this.type} - ${Strings.Message.NONCONSECUTIVESEGMENTS}`);
+              continue;
+            }
+          }
+          break;
+        }
+
+        // Apply chamfer then reset
+        DesignCore.Scene.inputManager.executeCommand();
+        return;
+      }
+    } catch (err) {
+      Logging.instance.error(`${this.type} - ${err}`);
+    }
+  }
+
+  /**
+   * Preview the command during execution
+   */
+  preview() {
+    // No preview
+  }
+
+  /**
+   * Perform the chamfer
+   */
+  action() {
+    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;
+
+    // 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);
+      }
+      return;
+    }
+
+    // Compute the two chamfer endpoints on each line
+    const firstUnit = this.firstPick.clickUnit(this.intersectionPoint);
+    const secondUnit = this.secondPick.clickUnit(this.intersectionPoint);
+    let firstChamferPoint;
+    let secondChamferPoint;
+
+    if (!chamferMode) {
+      // Distance method: measure distA along line1 and distB along line2 from intersection
+      const distB = DesignCore.Scene.headers.chamferDistanceB;
+      firstChamferPoint = this.intersectionPoint.add(firstUnit.scale(distA));
+      secondChamferPoint = this.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).
+      const chamferLength = DesignCore.Scene.headers.chamferLength;
+      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;
+      }
+
+      firstChamferPoint = this.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,
+          true, true,
+      );
+
+      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;
+      }
+    }
+
+    // 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 chamferLine = DesignCore.CommandManager.createNew('Line', {
+      points: [firstChamferPoint, secondChamferPoint],
+    });
+
+    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);
+  }
+
+  /**
+   * Display the current chamfer settings to the command line
+   */
+  #notifySettings() {
+    const trimMode = DesignCore.Scene.headers.trimMode;
+    const chamferMode = DesignCore.Scene.headers.chamferMode;
+    if (chamferMode) {
+      const length = DesignCore.Scene.headers.chamferLength;
+      const angle = DesignCore.Scene.headers.chamferAngle;
+      DesignCore.Core.notify(`Current settings: Mode = ${trimMode ? 'TRIM' : 'NOTRIM'}, Method = ANGLE, Length = ${length}, Angle = ${angle}`);
+    } else {
+      const distA = DesignCore.Scene.headers.chamferDistanceA;
+      const distB = DesignCore.Scene.headers.chamferDistanceB;
+      DesignCore.Core.notify(`Current settings: Mode = ${trimMode ? 'TRIM' : 'NOTRIM'}, Method = DIST, Dist1 = ${distA}, Dist2 = ${distB}`);
+    }
+  }
+}