@design-core/core 0.0.6 → 0.0.7

package/test/tools/chamferFilletBase.test.js

@@ -167,7 +167,7 @@ test('ChamferFilletBase.applySharpTrim trims two Lines to the intersection point
   chamfer.secondPick.clickPoint = new Point(8, -7); // projects to (10,-7) → lineKeptEnd = (10,-10)
   chamfer.intersectionPoint = new Point(10, 0);
 
-  const stateChanges = chamfer.applySharpTrim();
+  const stateChanges = chamfer.applyCornerTrim(chamfer.intersectionPoint, chamfer.intersectionPoint, null);
   DesignCore.Scene.commit(stateChanges);
 
   const updatedA = core.scene.entities.get(0);
@@ -198,7 +198,7 @@ test('ChamferFilletBase.applySharpTrim poly+poly consecutive segments: replaces
   chamfer.secondPick.segmentIndex = 2;
   chamfer.intersectionPoint = new Point(0, 0);
 
-  const stateChanges = chamfer.applySharpTrim();
+  const stateChanges = chamfer.applyCornerTrim(chamfer.intersectionPoint, chamfer.intersectionPoint, null);
   DesignCore.Scene.commit(stateChanges);
 
   const poly = core.scene.entities.get(0);
@@ -222,7 +222,7 @@ test('ChamferFilletBase.applySharpTrim poly+poly open ends: moves both endpoints
   chamfer.secondPick.segmentIndex = 3; // open end (lastIdx = 3)
   chamfer.intersectionPoint = new Point(3, 2);
 
-  const stateChanges = chamfer.applySharpTrim();
+  const stateChanges = chamfer.applyCornerTrim(chamfer.intersectionPoint, chamfer.intersectionPoint, null);
   DesignCore.Scene.commit(stateChanges);
 
   const poly = core.scene.entities.get(0);
@@ -258,7 +258,7 @@ test('ChamferFilletBase.applySharpTrim poly+poly closed polyline seg1+lastIdx: c
   chamfer.secondPick.segmentIndex = polyEntity.points.length - 1; // lastIdx
   chamfer.intersectionPoint = new Point(0, 0);
 
-  const stateChanges = chamfer.applySharpTrim();
+  const stateChanges = chamfer.applyCornerTrim(chamfer.intersectionPoint, chamfer.intersectionPoint, null);
   DesignCore.Scene.commit(stateChanges);
 
   // Corner-splice: replaces vertex at cornerIdx=1 with intersectionPoint — point count unchanged
@@ -286,7 +286,7 @@ test('ChamferFilletBase.applySharpTrim closed poly last-regular-seg + closing-se
   chamfer.secondPick.segmentIndex = 4; // closing segment (points.length)
   chamfer.intersectionPoint = new Point(0, 10);
 
-  const stateChanges = chamfer.applySharpTrim();
+  const stateChanges = chamfer.applyCornerTrim(chamfer.intersectionPoint, chamfer.intersectionPoint, null);
   DesignCore.Scene.commit(stateChanges);
 
   const poly = core.scene.entities.get(0);
@@ -314,7 +314,7 @@ test('ChamferFilletBase.applySharpTrim closed poly closing-seg + seg-1: replaces
   chamfer.secondPick.segmentIndex = 1;
   chamfer.intersectionPoint = new Point(0, 0);
 
-  const stateChanges = chamfer.applySharpTrim();
+  const stateChanges = chamfer.applyCornerTrim(chamfer.intersectionPoint, chamfer.intersectionPoint, null);
   DesignCore.Scene.commit(stateChanges);
 
   const poly = core.scene.entities.get(0);
@@ -354,7 +354,7 @@ test('ChamferFilletBase.applySharpTrim first=Line second=Poly keepStart: line co
   chamfer.intersectionPoint = new Point(0, 0);
 
 
-  const stateChanges = chamfer.applySharpTrim();
+  const stateChanges = chamfer.applyCornerTrim(chamfer.intersectionPoint, chamfer.intersectionPoint, null);
   DesignCore.Scene.commit(stateChanges);
 
   expect(core.scene.entities.count()).toBe(1);
@@ -392,7 +392,7 @@ test('ChamferFilletBase.applySharpTrim first=Line second=Poly keepEnd: line cons
   chamfer.intersectionPoint = new Point(0, 0);
 
 
-  const stateChanges = chamfer.applySharpTrim();
+  const stateChanges = chamfer.applyCornerTrim(chamfer.intersectionPoint, chamfer.intersectionPoint, null);
   DesignCore.Scene.commit(stateChanges);
 
   expect(core.scene.entities.count()).toBe(1);
@@ -431,7 +431,7 @@ test('ChamferFilletBase.applySharpTrim first=Poly second=Line: poly/line orderin
   chamfer.intersectionPoint = new Point(0, 0);
 
 
-  const stateChanges = chamfer.applySharpTrim();
+  const stateChanges = chamfer.applyCornerTrim(chamfer.intersectionPoint, chamfer.intersectionPoint, null);
   DesignCore.Scene.commit(stateChanges);
 
   expect(core.scene.entities.count()).toBe(1);
@@ -444,3 +444,92 @@ test('ChamferFilletBase.applySharpTrim first=Poly second=Line: poly/line orderin
   expect(poly.points[3].x).toBeCloseTo(0);
   expect(poly.points[3].y).toBeCloseTo(10);
 });
+
+// ─── validateSelection ────────────────────────────────────────────────────────
+
+test('ChamferFilletBase.validateSelection returns null when firstPick has no entity', () => {
+  const chamfer = new Chamfer();
+  expect(chamfer.validateSelection()).toBeNull();
+});
+
+test('ChamferFilletBase.validateSelection returns null when firstPick entity is not a Line', () => {
+  core.scene.clear();
+  core.scene.addItem('Circle', { points: [new Point(0, 0), new Point(5, 0)] });
+
+  const chamfer = new Chamfer();
+  chamfer.firstPick.entity = core.scene.entities.get(0); // Circle — resolveEndpoints fails
+
+  DesignCore.Mouse.pointOnScene = () => new Point(5, 5);
+  expect(chamfer.validateSelection()).toBeNull();
+});
+
+test('ChamferFilletBase.validateSelection returns null when findClosestItem returns undefined', () => {
+  core.scene.clear();
+  core.scene.addItem('Line', { points: [new Point(-10, 0), new Point(0, 0)] });
+
+  const chamfer = new Chamfer();
+  chamfer.firstPick.entity = core.scene.entities.get(0);
+  chamfer.firstPick.clickPoint = new Point(-5, 0);
+
+  const findSpy = jest.spyOn(core.scene.selectionManager, 'findClosestItem').mockReturnValue(undefined);
+  DesignCore.Mouse.pointOnScene = () => new Point(5, 5);
+  const result = chamfer.validateSelection();
+  findSpy.mockRestore();
+
+  expect(result).toBeNull();
+});
+
+test('ChamferFilletBase.validateSelection returns null when hovered entity is not a Line or BasePolyline', () => {
+  core.scene.clear();
+  core.scene.addItem('Line', { points: [new Point(-10, 0), new Point(0, 0)] });
+  core.scene.addItem('Circle', { points: [new Point(5, 5), new Point(10, 5)] });
+
+  const chamfer = new Chamfer();
+  chamfer.firstPick.entity = core.scene.entities.get(0);
+  chamfer.firstPick.clickPoint = new Point(-5, 0);
+
+  const findSpy = jest.spyOn(core.scene.selectionManager, 'findClosestItem').mockReturnValue(1);
+  DesignCore.Mouse.pointOnScene = () => new Point(5, 5);
+  const result = chamfer.validateSelection();
+  findSpy.mockRestore();
+
+  expect(result).toBeNull();
+});
+
+test('ChamferFilletBase.validateSelection returns null when first and second segments are parallel', () => {
+  core.scene.clear();
+  core.scene.addItem('Line', { points: [new Point(-10, 0), new Point(0, 0)] });
+  core.scene.addItem('Line', { points: [new Point(0, 2), new Point(10, 2)] }); // parallel horizontal
+
+  const chamfer = new Chamfer();
+  chamfer.firstPick.entity = core.scene.entities.get(0);
+  chamfer.firstPick.clickPoint = new Point(-5, 0);
+
+  const findSpy = jest.spyOn(core.scene.selectionManager, 'findClosestItem').mockReturnValue(1);
+  DesignCore.Mouse.pointOnScene = () => new Point(5, 2);
+  const result = chamfer.validateSelection();
+  findSpy.mockRestore();
+
+  expect(result).toBeNull();
+});
+
+test('ChamferFilletBase.validateSelection returns selection object for valid perpendicular lines', () => {
+  core.scene.clear();
+  core.scene.addItem('Line', { points: [new Point(-10, 0), new Point(0, 0)] }); // horizontal
+  core.scene.addItem('Line', { points: [new Point(5, -5), new Point(5, 5)] }); // vertical at x=5
+
+  const chamfer = new Chamfer();
+  chamfer.firstPick.entity = core.scene.entities.get(0);
+  chamfer.firstPick.clickPoint = new Point(-5, 0);
+
+  const findSpy = jest.spyOn(core.scene.selectionManager, 'findClosestItem').mockReturnValue(1);
+  DesignCore.Mouse.pointOnScene = () => new Point(5, 2);
+  const result = chamfer.validateSelection();
+  findSpy.mockRestore();
+
+  expect(result).not.toBeNull();
+  expect(result.candidate).toBe(core.scene.entities.get(1));
+  expect(result.intersectionPoint.x).toBeCloseTo(5);
+  expect(result.intersectionPoint.y).toBeCloseTo(0);
+  expect(result.tempSecond).toBeDefined();
+});

package/test/tools/copy.test.js

@@ -44,7 +44,7 @@ test('Test Copy.action', () => {
   for (let i = 0; i < 6; i++) {
     const original = core.scene.entities.get(i);
     const copy = core.scene.entities.get(i + 6);
-    expect(copy.handle).toBeDefined();
-    expect(copy.handle).not.toBe(original.handle);
+    expect(copy.getProperty('handle')).toBeDefined();
+    expect(copy.getProperty('handle')).not.toBe(original.getProperty('handle'));
   }
 });

package/test/tools/explode.test.js

@@ -38,8 +38,8 @@ test('Test Explode.action', () => {
     expect(item.points[0].y).toBe(i * 10 + insertPoint.y);
 
     // Verify each exploded entity has a unique handle
-    expect(item.handle).toBeDefined();
-    expect(handles.has(item.handle)).toBe(false);
-    handles.add(item.handle);
+    expect(item.getProperty('handle')).toBeDefined();
+    expect(handles.has(item.getProperty('handle'))).toBe(false);
+    handles.add(item.getProperty('handle'));
   }
 });

package/test/tools/extend.test.js

@@ -2,6 +2,8 @@ import { Core } from '../../core/core/core.js';
 import { Point } from '../../core/entities/point.js';
 import { Extend } from '../../core/tools/extend.js';
 import { SingleSelection } from '../../core/lib/selectionManager.js';
+import { Strings } from '../../core/lib/strings.js';
+import { DesignCore } from '../../core/designCore.js';
 import { expect, jest } from '@jest/globals';
 import { withMockInput } from '../test-helpers/test-helpers.js';
 
@@ -393,3 +395,332 @@ test('Test Extend.action polyline - no intersections', () => {
   expect(polyline.points[0].x).toBe(0);
   expect(polyline.points[1].x).toBe(50);
 });
+
+test('Extend.register returns correct metadata', () => {
+  const reg = Extend.register();
+  expect(reg.command).toBe('Extend');
+  expect(reg.shortcut).toBe('EX');
+  expect(reg.type).toBe('Tool');
+});
+
+test('Extend.preview does not throw', () => {
+  const extend = new Extend();
+  expect(() => extend.preview()).not.toThrow();
+});
+
+test('Extend.preview returns early when no boundary items set', () => {
+  core.scene.clear();
+  core.scene.addItem('Line', { points: [new Point(100, -10), new Point(100, 10)] });
+  DesignCore.Scene.previewEntities.clear();
+
+  const extend = new Extend();
+  // selectedBoundaryItems is empty by default
+  extend.preview();
+
+  expect(DesignCore.Scene.previewEntities.count()).toBe(0);
+});
+
+test('Extend.preview returns early when findClosestItem returns undefined', () => {
+  core.scene.clear();
+  core.scene.addItem('Line', { points: [new Point(100, -10), new Point(100, 10)] });
+  core.scene.addItem('Line', { points: [new Point(0, 0), new Point(50, 0)] });
+  DesignCore.Scene.previewEntities.clear();
+
+  const extend = new Extend();
+  extend.selectedBoundaryItems = [core.scene.entities.get(0)];
+
+  const findSpy = jest.spyOn(core.scene.selectionManager, 'findClosestItem').mockReturnValue(undefined);
+  extend.preview();
+  findSpy.mockRestore();
+
+  expect(DesignCore.Scene.previewEntities.count()).toBe(0);
+});
+
+test('Extend.preview returns early when hovered entity does not implement extend', () => {
+  // Circle does not override Entity.extend() — preview must not emit a notification.
+  core.scene.clear();
+  core.scene.addItem('Line', { points: [new Point(100, -10), new Point(100, 10)] }); // boundary
+  core.scene.addItem('Circle', { points: [new Point(0, 0), new Point(5, 0)] }); // unsupported
+  DesignCore.Scene.previewEntities.clear();
+
+  const notifySpy = jest.spyOn(core, 'notify');
+  const extend = new Extend();
+  extend.selectedBoundaryItems = [core.scene.entities.get(0)];
+
+  const findSpy = jest.spyOn(core.scene.selectionManager, 'findClosestItem').mockReturnValue(1);
+  DesignCore.Mouse.pointOnScene = () => new Point(5, 0);
+  extend.preview();
+  findSpy.mockRestore();
+  notifySpy.mockRestore();
+
+  expect(DesignCore.Scene.previewEntities.count()).toBe(0);
+  expect(notifySpy).not.toHaveBeenCalled();
+});
+
+test('Extend.preview returns early when hovered entity has no valid extension', () => {
+  // Hovered line is parallel to the boundary — no intersection ahead of its endpoint.
+  core.scene.clear();
+  core.scene.addItem('Line', { points: [new Point(0, 50), new Point(100, 50)] }); // boundary (horizontal)
+  core.scene.addItem('Line', { points: [new Point(0, 0), new Point(50, 0)] }); // hovered (parallel, y=0)
+  DesignCore.Scene.previewEntities.clear();
+
+  const extend = new Extend();
+  extend.selectedBoundaryItems = [core.scene.entities.get(0)];
+
+  const findSpy = jest.spyOn(core.scene.selectionManager, 'findClosestItem').mockReturnValue(1);
+  DesignCore.Mouse.pointOnScene = () => new Point(45, 0);
+  extend.preview();
+  findSpy.mockRestore();
+
+  expect(DesignCore.Scene.previewEntities.count()).toBe(0);
+});
+
+test('Extend.preview populates previewEntities when entity can be extended', () => {
+  // Vertical boundary at x=100; short horizontal line from (0,0) to (50,0).
+  // Mouse near end (45,0) → end extends to (100,0).
+  core.scene.clear();
+  core.scene.addItem('Line', { points: [new Point(100, -10), new Point(100, 10)] }); // boundary
+  core.scene.addItem('Line', { points: [new Point(0, 0), new Point(50, 0)] }); // hovered
+  DesignCore.Scene.previewEntities.clear();
+
+  const extend = new Extend();
+  extend.selectedBoundaryItems = [core.scene.entities.get(0)];
+
+  const findSpy = jest.spyOn(core.scene.selectionManager, 'findClosestItem').mockReturnValue(1);
+  DesignCore.Mouse.pointOnScene = () => new Point(45, 0);
+  extend.preview();
+  findSpy.mockRestore();
+
+  // Preview of the extended line should be added
+  expect(DesignCore.Scene.previewEntities.count()).toBeGreaterThanOrEqual(1);
+  // The previewed line should reach the boundary
+  const preview = DesignCore.Scene.previewEntities.get(DesignCore.Scene.previewEntities.count() - 1);
+  expect(preview.points[1].x).toBeCloseTo(100);
+  expect(preview.points[1].y).toBeCloseTo(0);
+});
+
+test('Extend.execute returns early when boundary input is undefined', async () => {
+  core.scene.clear();
+  core.scene.selectionManager.reset();
+  core.scene.addItem('Line', { points: [new Point(), new Point(10, 0)] });
+
+  await withMockInput(core.scene, [undefined], async () => {
+    const extend = new Extend();
+    await extend.execute();
+    expect(extend.selectedBoundaryItems).toHaveLength(0);
+  });
+});
+
+test('Extend.execute exits selection loop when selection input is undefined', async () => {
+  core.scene.clear();
+  core.scene.selectionManager.reset();
+  core.scene.addItem('Line', { points: [new Point(100, -10), new Point(100, 10)] });
+  core.scene.addItem('Line', { points: [new Point(0, 0), new Point(50, 0)] });
+  core.scene.selectionManager.selectionSet.selectionSet.push(0);
+
+  const executeCommandSpy = jest.fn();
+  await withMockInput(core.scene, [undefined], async () => {
+    const extend = new Extend();
+    await extend.execute();
+    expect(extend.selectedBoundaryItems).toHaveLength(1);
+    expect(executeCommandSpy).toHaveBeenCalled();
+  }, { extraMethods: { executeCommand: () => executeCommandSpy() } });
+});
+
+test('Extend.execute calls actionCommand once per extend selection', async () => {
+  core.scene.clear();
+  core.scene.selectionManager.reset();
+  core.scene.addItem('Line', { points: [new Point(100, -10), new Point(100, 10)] });
+  core.scene.addItem('Line', { points: [new Point(0, 0), new Point(50, 0)] });
+  core.scene.addItem('Line', { points: [new Point(0, 5), new Point(50, 5)] });
+  core.scene.selectionManager.selectionSet.selectionSet.push(0);
+
+  const actionSpy = jest.fn();
+  await withMockInput(
+      core.scene,
+      [new SingleSelection(1, new Point(45, 0)), new SingleSelection(2, new Point(45, 5)), undefined],
+      async () => {
+        const extend = new Extend();
+        await extend.execute();
+        expect(actionSpy).toHaveBeenCalledTimes(2);
+      },
+      { extraMethods: { actionCommand: () => actionSpy() } },
+  );
+});
+
+test('Extend.action does nothing when selectedItem is null', () => {
+  core.scene.clear();
+  core.scene.addItem('Line', { points: [new Point(), new Point(10, 0)] });
+  const extend = new Extend();
+  extend.selectedItem = null;
+  extend.selectedBoundaryItems = [core.scene.entities.get(0)];
+
+  expect(() => extend.action()).not.toThrow();
+});
+
+test('Extend.action does nothing when selectedBoundaryItems is empty', () => {
+  core.scene.clear();
+  core.scene.addItem('Line', { points: [new Point(), new Point(10, 0)] });
+  const extend = new Extend();
+  extend.selectedItem = core.scene.entities.get(0);
+  extend.selectedBoundaryItems = [];
+
+  expect(() => extend.action()).not.toThrow();
+  expect(extend.selectedItem).toBeNull();
+});
+
+test('Extend.action notifies NOEXTEND when selected entity lacks fromPolylinePoints', () => {
+  // Use a stub entity that has toPolylinePoints but no fromPolylinePoints.
+  // action() must notify and not throw.
+  core.scene.clear();
+  core.scene.addItem('Line', { points: [new Point(100, -10), new Point(100, 10)] }); // boundary
+
+  const extend = new Extend();
+  extend.selectedBoundaryItems = [core.scene.entities.get(0)];
+  extend.selectedItem = {
+    type: 'FakeEntity',
+    toPolylinePoints: () => [new Point(0, 0), new Point(50, 0)],
+    // deliberately no fromPolylinePoints
+  };
+  core.mouse.setPosFromScenePoint(new Point(45, 0));
+
+  const notifySpy = jest.spyOn(core, 'notify').mockImplementation(() => {});
+  extend.action();
+
+  expect(notifySpy).toHaveBeenCalledWith(expect.stringContaining(Strings.Message.NOEXTEND));
+  expect(extend.selectedItem).toBeNull();
+  notifySpy.mockRestore();
+});
+
+test('Extend.action notifies NOEXTEND when selected entity is a closed polyline', () => {
+  // Closed polylines have no open endpoints — extend must notify and leave the entity unchanged.
+  core.scene.clear();
+  core.scene.addItem('Line', { points: [new Point(200, -10), new Point(200, 10)] }); // boundary
+  // Closed square: flag bit 1 set
+  core.scene.addItem('Lwpolyline', {
+    points: [new Point(0, 0), new Point(100, 0), new Point(100, 100), new Point(0, 100)],
+    flags: 1,
+  });
+
+  const extend = new Extend();
+  extend.selectedBoundaryItems = [core.scene.entities.get(0)];
+  extend.selectedItem = core.scene.entities.get(1);
+  core.mouse.setPosFromScenePoint(new Point(95, 0));
+
+  const notifySpy = jest.spyOn(core, 'notify').mockImplementation(() => {});
+  extend.action();
+
+  expect(notifySpy).toHaveBeenCalledWith(expect.stringContaining(Strings.Message.NOEXTEND));
+  expect(extend.selectedItem).toBeNull();
+  notifySpy.mockRestore();
+});
+
+test('Extend.preview silently skips entity that lacks fromPolylinePoints', () => {
+  // Stub entity implements toPolylinePoints but not fromPolylinePoints.
+  // preview() must return early without calling notify.
+  core.scene.clear();
+  core.scene.addItem('Line', { points: [new Point(100, -10), new Point(100, 10)] }); // boundary
+  DesignCore.Scene.previewEntities.clear();
+
+  const stubEntity = {
+    type: 'FakeEntity',
+    toPolylinePoints: () => [new Point(0, 0), new Point(50, 0)],
+    // deliberately no fromPolylinePoints
+  };
+
+  const notifySpy = jest.spyOn(core, 'notify');
+  const extend = new Extend();
+  extend.selectedBoundaryItems = [core.scene.entities.get(0)];
+
+  const savedPointOnScene = DesignCore.Mouse.pointOnScene;
+  const findSpy = jest.spyOn(core.scene.selectionManager, 'findClosestItem').mockReturnValue(0);
+  jest.spyOn(core.scene.entities, 'get').mockReturnValue(stubEntity);
+  DesignCore.Mouse.pointOnScene = () => new Point(45, 0);
+  extend.preview();
+  findSpy.mockRestore();
+  jest.restoreAllMocks();
+  DesignCore.Mouse.pointOnScene = savedPointOnScene;
+
+  expect(DesignCore.Scene.previewEntities.count()).toBe(0);
+  expect(notifySpy).not.toHaveBeenCalled();
+});
+
+test('Extend.action notifies when no intersection found (parallel lines)', () => {
+  core.scene.clear();
+  // Two parallel horizontal lines — no intersection possible
+  core.scene.addItem('Line', { points: [new Point(0, 0), new Point(100, 0)] });
+  core.scene.addItem('Line', { points: [new Point(0, 50), new Point(50, 50)] });
+
+  const extend = new Extend();
+  extend.selectedBoundaryItems = [core.scene.entities.get(0)];
+  extend.selectedItem = core.scene.entities.get(1);
+  core.mouse.setPosFromScenePoint(new Point(40, 50));
+
+  const notifySpy = jest.spyOn(core, 'notify').mockImplementation(() => {});
+  extend.action();
+
+  expect(notifySpy).toHaveBeenCalledWith(expect.stringContaining(Strings.Message.NOEXTEND));
+  expect(extend.selectedItem).toBeNull();
+  notifySpy.mockRestore();
+});
+
+test('Extend.action notifies when boundary item equals selected item', () => {
+  core.scene.clear();
+  core.scene.addItem('Line', { points: [new Point(0, 0), new Point(50, 0)] });
+  const entity = core.scene.entities.get(0);
+
+  const extend = new Extend();
+  extend.selectedBoundaryItems = [entity];
+  extend.selectedItem = entity;
+  core.mouse.setPosFromScenePoint(new Point(40, 0));
+
+  const notifySpy = jest.spyOn(core, 'notify').mockImplementation(() => {});
+  extend.action();
+
+  expect(notifySpy).toHaveBeenCalledWith(expect.stringContaining(Strings.Message.NOEXTEND));
+  notifySpy.mockRestore();
+});
+
+test('Extend.action extends the start of a line', () => {
+  // Line from (50,50) to (100,50) — horizontal
+  // Boundary: vertical line at x=0
+  // Mouse near the start (50,50) → extend start back to x=0
+  core.scene.clear();
+  core.scene.addItem('Line', { points: [new Point(0, 0), new Point(0, 100)] });
+  core.scene.addItem('Line', { points: [new Point(50, 50), new Point(100, 50)] });
+
+  const extend = new Extend();
+  extend.selectedBoundaryItems = [core.scene.entities.get(0)];
+  extend.selectedItem = core.scene.entities.get(1);
+  core.mouse.setPosFromScenePoint(new Point(55, 50));
+  extend.action();
+
+  expect(core.scene.entities.get(1).points[0].x).toBeCloseTo(0);
+  expect(core.scene.entities.get(1).points[0].y).toBeCloseTo(50);
+  expect(core.scene.entities.get(1).points[1].x).toBe(100);
+  expect(core.scene.entities.get(1).points[1].y).toBe(50);
+});
+
+test('Extend.action notifies NOEXTEND when end segment of an Arc is curved', () => {
+  // A standalone Arc always has a non-zero bulge on its single segment.
+  // #extendEntity must reject the extension and notify because endSegmentBulge !== 0.
+  core.scene.clear();
+  core.scene.addItem('Arc', {
+    points: [new Point(0, 0), new Point(10, 0), new Point(0, 10)],
+    direction: 1,
+  });
+  // Vertical boundary at x=5 — intersects the CCW quarter-arc
+  core.scene.addItem('Line', { points: [new Point(5, -20), new Point(5, 20)] });
+
+  const extend = new Extend();
+  extend.selectedBoundaryItems = [core.scene.entities.get(1)];
+  extend.selectedItem = core.scene.entities.get(0);
+  core.mouse.setPosFromScenePoint(new Point(9, 1)); // near arc start (10,0)
+
+  const notifySpy = jest.spyOn(core, 'notify').mockImplementation(() => {});
+  extend.action();
+
+  expect(notifySpy).toHaveBeenCalledWith(expect.stringContaining(Strings.Message.NOEXTEND));
+  expect(extend.selectedItem).toBeNull();
+  notifySpy.mockRestore();
+});