@design-core/core 0.0.6 → 50.1.0

package/test/tools/offset.test.js

@@ -4,6 +4,7 @@ import { Offset } from '../../core/tools/offset.js';
 import { Line } from '../../core/entities/line.js';
 import { Arc } from '../../core/entities/arc.js';
 import { Circle } from '../../core/entities/circle.js';
+import { DesignCore } from '../../core/designCore.js';
 import { expect, jest } from '@jest/globals';
 
 const core = new Core();
@@ -13,7 +14,7 @@ const inputScenarios = [
     desc: 'offset line to the left by distance 5',
     entityType: 'Line',
     entityData: { points: [new Point(0, 0), new Point(10, 0)] },
-    inputs: [5, { selectedItemIndex: 0 }, new Point(5, 5)],
+    inputs: [5, { selectedEntityIndex: 0 }, new Point(5, 5)],
     checkIndex: 1,
     expectedPoints: [new Point(0, 5), new Point(10, 5)],
   },
@@ -21,7 +22,7 @@ const inputScenarios = [
     desc: 'offset line to the right by distance 5',
     entityType: 'Line',
     entityData: { points: [new Point(0, 0), new Point(10, 0)] },
-    inputs: [5, { selectedItemIndex: 0 }, new Point(5, -5)],
+    inputs: [5, { selectedEntityIndex: 0 }, new Point(5, -5)],
     checkIndex: 1,
     expectedPoints: [new Point(0, -5), new Point(10, -5)],
   },
@@ -29,7 +30,7 @@ const inputScenarios = [
     desc: 'offset circle outward by distance 5',
     entityType: 'Circle',
     entityData: { points: [new Point(0, 0), new Point(10, 0)] },
-    inputs: [5, { selectedItemIndex: 0 }, new Point(20, 0)],
+    inputs: [5, { selectedEntityIndex: 0 }, new Point(20, 0)],
     checkIndex: 1,
     checkRadius: 15,
   },
@@ -37,7 +38,7 @@ const inputScenarios = [
     desc: 'offset circle inward by distance 3',
     entityType: 'Circle',
     entityData: { points: [new Point(0, 0), new Point(10, 0)] },
-    inputs: [3, { selectedItemIndex: 0 }, new Point(5, 0)],
+    inputs: [3, { selectedEntityIndex: 0 }, new Point(5, 0)],
     checkIndex: 1,
     checkRadius: 7,
   },
@@ -45,7 +46,7 @@ const inputScenarios = [
     desc: 'offset arc outward by distance 5',
     entityType: 'Arc',
     entityData: { points: [new Point(0, 0), new Point(10, 0), new Point(0, 10)] },
-    inputs: [5, { selectedItemIndex: 0 }, new Point(20, 0)],
+    inputs: [5, { selectedEntityIndex: 0 }, new Point(20, 0)],
     checkIndex: 1,
     checkRadius: 15,
   },
@@ -57,7 +58,7 @@ test.each(inputScenarios)('Offset.execute handles $desc', async (scenario) => {
   core.scene.clear();
   core.scene.selectionManager.reset();
 
-  core.scene.addItem(entityType, entityData);
+  core.scene.addEntity(entityType, entityData);
 
   const origInputManager = core.scene.inputManager;
   let callCount = 0;
@@ -99,7 +100,7 @@ test('Offset.execute - cancel at distance prompt does not offset', async () => {
   core.scene.clear();
   core.scene.selectionManager.reset();
 
-  core.scene.addItem('Line', { points: [new Point(0, 0), new Point(10, 0)] });
+  core.scene.addEntity('Line', { points: [new Point(0, 0), new Point(10, 0)] });
 
   const origInputManager = core.scene.inputManager;
   core.scene.inputManager = {
@@ -120,7 +121,7 @@ test('Offset.execute - cancel at entity selection does not offset', async () =>
   core.scene.clear();
   core.scene.selectionManager.reset();
 
-  core.scene.addItem('Line', { points: [new Point(0, 0), new Point(10, 0)] });
+  core.scene.addEntity('Line', { points: [new Point(0, 0), new Point(10, 0)] });
 
   const origInputManager = core.scene.inputManager;
   let callCount = 0;
@@ -147,11 +148,11 @@ test('Offset.execute - cancel at side point does not offset', async () => {
   core.scene.clear();
   core.scene.selectionManager.reset();
 
-  core.scene.addItem('Line', { points: [new Point(0, 0), new Point(10, 0)] });
+  core.scene.addEntity('Line', { points: [new Point(0, 0), new Point(10, 0)] });
 
   const origInputManager = core.scene.inputManager;
   let callCount = 0;
-  const inputs = [5, { selectedItemIndex: 0 }]; // distance + selection, then undefined
+  const inputs = [5, { selectedEntityIndex: 0 }]; // distance + selection, then undefined
   core.scene.inputManager = {
     requestInput: async () => {
       if (callCount < inputs.length) {
@@ -166,8 +167,8 @@ test('Offset.execute - cancel at side point does not offset', async () => {
   await offset.execute();
 
   expect(core.scene.entities.count()).toBe(1);
-  // selectedItem must be cleared so a stale action() call cannot create an unintended entity
-  expect(offset.selectedItem).toBeNull();
+  // selectedEntity must be cleared so a stale action() call cannot create an unintended entity
+  expect(offset.selectedEntity).toBeNull();
 
   core.scene.inputManager = origInputManager;
 });
@@ -176,14 +177,14 @@ test('Offset.execute - entity count increases by one per offset', async () => {
   core.scene.clear();
   core.scene.selectionManager.reset();
 
-  core.scene.addItem('Line', { points: [new Point(0, 0), new Point(10, 0)] });
-  core.scene.addItem('Circle', { points: [new Point(0, 0), new Point(10, 0)] });
+  core.scene.addEntity('Line', { points: [new Point(0, 0), new Point(10, 0)] });
+  core.scene.addEntity('Circle', { points: [new Point(0, 0), new Point(10, 0)] });
 
   const entityCount = core.scene.entities.count();
 
   const origInputManager = core.scene.inputManager;
   let callCount = 0;
-  const inputs = [5, { selectedItemIndex: 0 }, new Point(5, 5)];
+  const inputs = [5, { selectedEntityIndex: 0 }, new Point(5, 5)];
   core.scene.inputManager = {
     requestInput: async () => {
       if (callCount < inputs.length) {
@@ -209,10 +210,10 @@ test('Test Offset.action - offset line perpendicular', () => {
   core.scene.clear();
   core.scene.selectionManager.reset();
 
-  core.scene.addItem('Line', { points: [new Point(0, 0), new Point(10, 0)] });
+  core.scene.addEntity('Line', { points: [new Point(0, 0), new Point(10, 0)] });
 
   const offset = new Offset();
-  offset.selectedItem = core.scene.entities.get(0);
+  offset.selectedEntity = core.scene.entities.get(0);
   core.scene.headers.offsetDistance = 5;
   offset.points = [new Point(5, 5)]; // side point above line
 
@@ -231,10 +232,10 @@ test('Test Offset.action - offset vertical line', () => {
   core.scene.clear();
   core.scene.selectionManager.reset();
 
-  core.scene.addItem('Line', { points: [new Point(0, 0), new Point(0, 10)] });
+  core.scene.addEntity('Line', { points: [new Point(0, 0), new Point(0, 10)] });
 
   const offset = new Offset();
-  offset.selectedItem = core.scene.entities.get(0);
+  offset.selectedEntity = core.scene.entities.get(0);
   core.scene.headers.offsetDistance = 3;
   offset.points = [new Point(5, 5)]; // side point to the right
 
@@ -251,10 +252,10 @@ test('Test Offset.action - offset circle outward', () => {
   core.scene.clear();
   core.scene.selectionManager.reset();
 
-  core.scene.addItem('Circle', { points: [new Point(0, 0), new Point(10, 0)] });
+  core.scene.addEntity('Circle', { points: [new Point(0, 0), new Point(10, 0)] });
 
   const offset = new Offset();
-  offset.selectedItem = core.scene.entities.get(0);
+  offset.selectedEntity = core.scene.entities.get(0);
   core.scene.headers.offsetDistance = 5;
   offset.points = [new Point(20, 0)]; // outside the circle
 
@@ -267,17 +268,17 @@ test('Test Offset.action - offset circle outward', () => {
   expect(newCircle.points[0].x).toBeCloseTo(0);
   expect(newCircle.points[0].y).toBeCloseTo(0);
   // New radius should be 15
-  expect(newCircle.radius).toBeCloseTo(15);
+  expect(newCircle.getProperty('radius')).toBeCloseTo(15);
 });
 
 test('Test Offset.action - offset circle inward', () => {
   core.scene.clear();
   core.scene.selectionManager.reset();
 
-  core.scene.addItem('Circle', { points: [new Point(0, 0), new Point(10, 0)] });
+  core.scene.addEntity('Circle', { points: [new Point(0, 0), new Point(10, 0)] });
 
   const offset = new Offset();
-  offset.selectedItem = core.scene.entities.get(0);
+  offset.selectedEntity = core.scene.entities.get(0);
   core.scene.headers.offsetDistance = 3;
   offset.points = [new Point(5, 0)]; // inside the circle
 
@@ -286,17 +287,17 @@ test('Test Offset.action - offset circle inward', () => {
   const newCircle = core.scene.entities.get(1);
   expect(newCircle.points[0].x).toBeCloseTo(0);
   expect(newCircle.points[0].y).toBeCloseTo(0);
-  expect(newCircle.radius).toBeCloseTo(7);
+  expect(newCircle.getProperty('radius')).toBeCloseTo(7);
 });
 
 test('Test Offset.action - offset circle inward returns null when radius would be zero', () => {
   core.scene.clear();
   core.scene.selectionManager.reset();
 
-  core.scene.addItem('Circle', { points: [new Point(0, 0), new Point(10, 0)] });
+  core.scene.addEntity('Circle', { points: [new Point(0, 0), new Point(10, 0)] });
 
   const offset = new Offset();
-  offset.selectedItem = core.scene.entities.get(0);
+  offset.selectedEntity = core.scene.entities.get(0);
   core.scene.headers.offsetDistance = 15; // larger than radius
   offset.points = [new Point(5, 0)]; // inside
 
@@ -310,14 +311,14 @@ test('Test Offset.action - offset arc outward preserves angles', () => {
   core.scene.clear();
   core.scene.selectionManager.reset();
 
-  const center = new Point(0, 0);
-  const start = center.project(0, 10); // radius 10
-  const end = center.project(Math.PI / 2, 10);
+  const centre = new Point(0, 0);
+  const start = centre.project(0, 10); // radius 10
+  const end = centre.project(Math.PI / 2, 10);
 
-  core.scene.addItem('Arc', { points: [center, start, end] });
+  core.scene.addEntity('Arc', { points: [centre, start, end] });
 
   const offset = new Offset();
-  offset.selectedItem = core.scene.entities.get(0);
+  offset.selectedEntity = core.scene.entities.get(0);
   core.scene.headers.offsetDistance = 5;
   offset.points = [new Point(20, 0)]; // outside
 
@@ -329,8 +330,8 @@ test('Test Offset.action - offset arc outward preserves angles', () => {
   expect(newRadius).toBeCloseTo(15);
 
   // Start and end angles should be preserved
-  const originalStartAngle = center.angle(start);
-  const originalEndAngle = center.angle(end);
+  const originalStartAngle = centre.angle(start);
+  const originalEndAngle = centre.angle(end);
   const newStartAngle = newArc.points[0].angle(newArc.points[1]);
   const newEndAngle = newArc.points[0].angle(newArc.points[2]);
   expect(newStartAngle).toBeCloseTo(originalStartAngle);
@@ -341,10 +342,10 @@ test('Test Offset.action - unsupported entity type does not create new entity',
   core.scene.clear();
   core.scene.selectionManager.reset();
 
-  core.scene.addItem('Rectangle', { points: [new Point(0, 0), new Point(10, 10)] });
+  core.scene.addEntity('Rectangle', { points: [new Point(0, 0), new Point(10, 10)] });
 
   const offset = new Offset();
-  offset.selectedItem = core.scene.entities.get(0);
+  offset.selectedEntity = core.scene.entities.get(0);
   core.scene.headers.offsetDistance = 5;
   offset.points = [new Point(20, 20)];
 
@@ -396,7 +397,7 @@ test('Test Offset.getThroughDistance - circle', () => {
 
 test('Test Offset.getThroughDistance - arc uses same radial distance as circle', () => {
   const offset = new Offset();
-  // Arc: center (0,0), radius 10
+  // Arc: centre (0,0), radius 10
   const entity = new Arc({ points: [new Point(0, 0), new Point(10, 0), new Point(0, 10)] });
 
   // Point inside the arc radius
@@ -408,7 +409,7 @@ test('Test Offset.getThroughDistance - arc uses same radial distance as circle',
 test('Test Offset.getThroughDistance - polyline uses closestPoint distance', () => {
   core.scene.clear();
   core.scene.selectionManager.reset();
-  core.scene.addItem('Polyline', { points: [new Point(0, 0), new Point(10, 0)] });
+  core.scene.addEntity('Polyline', { points: [new Point(0, 0), new Point(10, 0)] });
   const entity = core.scene.entities.get(0);
 
   const offset = new Offset();
@@ -425,13 +426,13 @@ test('Test Offset.getThroughDistance - unsupported entity returns 0', () => {
 
 // ─── action edge cases ────────────────────────────────────────────────────────
 
-test('Test Offset.action - returns early when selectedItem is null', () => {
+test('Test Offset.action - returns early when selectedEntity is null', () => {
   core.scene.clear();
   core.scene.selectionManager.reset();
-  core.scene.addItem('Line', { points: [new Point(0, 0), new Point(10, 0)] });
+  core.scene.addEntity('Line', { points: [new Point(0, 0), new Point(10, 0)] });
 
   const offset = new Offset();
-  offset.selectedItem = null;
+  offset.selectedEntity = null;
   core.scene.headers.offsetDistance = 5;
   offset.action();
 
@@ -441,10 +442,10 @@ test('Test Offset.action - returns early when selectedItem is null', () => {
 test('Test Offset.action - returns early when offsetDistance is 0', () => {
   core.scene.clear();
   core.scene.selectionManager.reset();
-  core.scene.addItem('Line', { points: [new Point(0, 0), new Point(10, 0)] });
+  core.scene.addEntity('Line', { points: [new Point(0, 0), new Point(10, 0)] });
 
   const offset = new Offset();
-  offset.selectedItem = core.scene.entities.get(0);
+  offset.selectedEntity = core.scene.entities.get(0);
   core.scene.headers.offsetDistance = 0;
   offset.points = [new Point(5, 5)];
   offset.action();
@@ -458,13 +459,13 @@ test('Test Offset.getOffsetPoints - arc inward offset shrinks radius', () => {
   const offset = new Offset();
   const entity = new Arc({ points: [new Point(0, 0), new Point(10, 0), new Point(0, 10)] });
 
-  // sidePoint inside the arc (between center and circumference)
+  // sidePoint inside the arc (between centre and circumference)
   const result = offset.getOffsetPoints(entity, new Point(5, 0), 3);
 
   expect(result).not.toBeNull();
   const rebuilt = new Arc({});
   rebuilt.fromPolylinePoints(result);
-  expect(rebuilt.radius).toBeCloseTo(7);
+  expect(rebuilt.getProperty('radius')).toBeCloseTo(7);
 });
 
 test('Test Offset.getOffsetPoints - arc returns null when inward offset collapses radius', () => {
@@ -537,7 +538,7 @@ test('Test Offset.getOffsetPolylinePoints - closed rectangle offset outward', ()
 test('Test Offset.getOffsetPolylinePoints - arc segment (bulge) offset outward grows radius', () => {
   const offset = new Offset();
   // CW semicircle (bulge=-1) from (0,0) to (10,0): traces the TOP half through (5,5)
-  // center=(5,0), radius=5
+  // centre=(5,0), radius=5
   const start = new Point(0, 0, -1); // bulge=-1 → CW, arc goes upward
   const end = new Point(10, 0);
   const points = [start, end];
@@ -576,7 +577,7 @@ test('Offset.findJunction - parallel line/line falls back to midpoint', () => {
 
 test('Offset.findJunction - arc/line returns circle-line intersection', () => {
   const offset = new Offset();
-  // Arc: A=(-5,0) B=(5,0) bulge=1 → center (0,0), radius 5 via bulgeCentrePoint
+  // Arc: A=(-5,0) B=(5,0) bulge=1 → centre (0,0), radius 5 via bulgeCentrePoint
   // Line: vertical at x=3 → circle intersects at (3,4) and (3,-4)
   const seg = { A: new Point(-5, 0), B: new Point(5, 0), bulge: 1 };
   const nextSeg = { A: new Point(3, 5), B: new Point(3, 10), bulge: 0 };
@@ -600,7 +601,7 @@ test('Offset.findJunction - line/arc returns line-circle intersection', () => {
 
 test('Offset.findJunction - arc/arc returns circle-circle intersection', () => {
   const offset = new Offset();
-  // Circle 1: A=(-4,0) B=(4,0) bulge=1 → center (0,0), radius 4 via bulgeCentrePoint
+  // Circle 1: A=(-4,0) B=(4,0) bulge=1 → centre (0,0), radius 4 via bulgeCentrePoint
   // Circle 2: A=(0,4) B=(6,4) bulge=1 → center (3,4), radius 3 via bulgeCentrePoint
   // Intersections: (0,4) and (96/25, 28/25)
   const seg = { A: new Point(-4, 0), B: new Point(4, 0), bulge: 1 };
@@ -628,7 +629,7 @@ test('Offset.findJunction - non-intersecting arc/arc falls back to midpoint', ()
 test('Offset.execute - single preselection skips entity selection prompt', async () => {
   core.scene.clear();
   core.scene.selectionManager.reset();
-  core.scene.addItem('Line', { points: [new Point(0, 0), new Point(10, 0)] });
+  core.scene.addEntity('Line', { points: [new Point(0, 0), new Point(10, 0)] });
   // Preselect the entity
   core.scene.selectionManager.addToSelectionSet(0);
 
@@ -657,8 +658,8 @@ test('Offset.execute - single preselection skips entity selection prompt', async
 test('Offset.execute - multi-preselection clears selection and prompts', async () => {
   core.scene.clear();
   core.scene.selectionManager.reset();
-  core.scene.addItem('Line', { points: [new Point(0, 0), new Point(10, 0)] });
-  core.scene.addItem('Line', { points: [new Point(0, 5), new Point(10, 5)] });
+  core.scene.addEntity('Line', { points: [new Point(0, 0), new Point(10, 0)] });
+  core.scene.addEntity('Line', { points: [new Point(0, 5), new Point(10, 5)] });
   // Preselect two entities
   core.scene.selectionManager.addToSelectionSet(0);
   core.scene.selectionManager.addToSelectionSet(1);
@@ -666,7 +667,7 @@ test('Offset.execute - multi-preselection clears selection and prompts', async (
   const origInputManager = core.scene.inputManager;
   let callCount = 0;
   // After clearing, distance + selection + side-point
-  const inputs = [5, { selectedItemIndex: 0 }, new Point(5, 5)];
+  const inputs = [5, { selectedEntityIndex: 0 }, new Point(5, 5)];
   const offset = new Offset();
   core.scene.inputManager = {
     requestInput: async () => {
@@ -690,7 +691,7 @@ test('Offset.execute - multi-preselection clears selection and prompts', async (
 test('Offset.execute - distance <= 0 notifies and does not offset', async () => {
   core.scene.clear();
   core.scene.selectionManager.reset();
-  core.scene.addItem('Line', { points: [new Point(0, 0), new Point(10, 0)] });
+  core.scene.addEntity('Line', { points: [new Point(0, 0), new Point(10, 0)] });
 
   const notifySpy = jest.spyOn(core, 'notify').mockImplementation(() => {});
 
@@ -714,12 +715,12 @@ test('Offset.execute - distance <= 0 notifies and does not offset', async () =>
 test('Offset.execute - Through mode offsets entity to the through point distance', async () => {
   core.scene.clear();
   core.scene.selectionManager.reset();
-  core.scene.addItem('Line', { points: [new Point(0, 0), new Point(10, 0)] });
+  core.scene.addEntity('Line', { points: [new Point(0, 0), new Point(10, 0)] });
 
   const origInputManager = core.scene.inputManager;
   let callCount = 0;
   // 'Through' → select entity at index 0 → through point at (5, 7) → undefined exits loop
-  const inputs = ['Through', { selectedItemIndex: 0 }, new Point(5, 7)];
+  const inputs = ['Through', { selectedEntityIndex: 0 }, new Point(5, 7)];
 
   const offset = new Offset();
   core.scene.inputManager = {
@@ -746,3 +747,169 @@ test('Offset.execute - Through mode offsets entity to the through point distance
 
   core.scene.inputManager = origInputManager;
 });
+
+// ─── register ─────────────────────────────────────────────────────────────────
+
+test('Offset.register returns correct metadata', () => {
+  const reg = Offset.register();
+  expect(reg.command).toBe('Offset');
+  expect(reg.shortcut).toBe('O');
+});
+
+// ─── preview ──────────────────────────────────────────────────────────────────
+
+test('Offset.preview does not add preview entity when selectedEntity is null', () => {
+  core.scene.clear();
+  DesignCore.Scene.previewEntities.clear();
+  core.scene.headers.offsetDistance = 5;
+
+  const offset = new Offset();
+  offset.selectedEntity = null;
+  expect(() => offset.preview()).not.toThrow();
+  expect(DesignCore.Scene.previewEntities.count()).toBe(0);
+});
+
+test('Offset.preview does not add preview entity when offsetDistance is 0', () => {
+  core.scene.clear();
+  core.scene.addEntity('Line', { points: [new Point(0, 0), new Point(10, 0)] });
+  DesignCore.Scene.previewEntities.clear();
+  core.scene.headers.offsetDistance = 0;
+
+  const savedPointOnScene = DesignCore.Mouse.pointOnScene;
+  DesignCore.Mouse.pointOnScene = () => new Point(5, 5);
+
+  const offset = new Offset();
+  offset.selectedEntity = core.scene.entities.get(0);
+  offset.preview();
+
+  DesignCore.Mouse.pointOnScene = savedPointOnScene;
+  expect(DesignCore.Scene.previewEntities.count()).toBe(0);
+});
+
+test('Offset.preview adds entity to previewEntities for a valid line', () => {
+  core.scene.clear();
+  core.scene.addEntity('Line', { points: [new Point(0, 0), new Point(10, 0)] });
+  DesignCore.Scene.previewEntities.clear();
+  core.scene.headers.offsetDistance = 5;
+
+  const savedPointOnScene = DesignCore.Mouse.pointOnScene;
+  DesignCore.Mouse.pointOnScene = () => new Point(5, 5);
+
+  const offset = new Offset();
+  offset.selectedEntity = core.scene.entities.get(0);
+  offset.preview();
+
+  DesignCore.Mouse.pointOnScene = savedPointOnScene;
+  expect(DesignCore.Scene.previewEntities.count()).toBe(1);
+  expect(DesignCore.Scene.previewEntities.get(0).points[0].y).toBeCloseTo(5);
+});
+
+// ─── Lwpolyline action ─────────────────────────────────────────────────────────
+
+test('Test Offset.action - offset open Lwpolyline', () => {
+  core.scene.clear();
+  core.scene.selectionManager.reset();
+
+  // L-shape: (0,0) → (10,0) → (10,10)
+  core.scene.addEntity('Lwpolyline', { points: [new Point(0, 0), new Point(10, 0), new Point(10, 10)] });
+
+  const offset = new Offset();
+  offset.selectedEntity = core.scene.entities.get(0);
+  core.scene.headers.offsetDistance = 1;
+  offset.points = [new Point(5, 2)]; // above the bottom segment → offset upward/left
+
+  offset.action();
+
+  expect(core.scene.entities.count()).toBe(2);
+  const newPoly = core.scene.entities.get(1);
+  expect(newPoly.points[0].x).toBeCloseTo(0);
+  expect(newPoly.points[0].y).toBeCloseTo(1);
+  expect(newPoly.points[2].x).toBeCloseTo(9);
+  expect(newPoly.points[2].y).toBeCloseTo(10);
+});
+
+test('Test Offset.action - offset closed Lwpolyline outward', () => {
+  core.scene.clear();
+  core.scene.selectionManager.reset();
+
+  // Closed square: 5 points where first === last → constructor sets flag=1
+  core.scene.addEntity('Lwpolyline', {
+    points: [new Point(0, 0), new Point(10, 0), new Point(10, 10), new Point(0, 10), new Point(0, 0)],
+  });
+
+  const polyline = core.scene.entities.get(0);
+  expect(polyline.flags.hasFlag(1)).toBe(true); // confirm closed
+
+  const offset = new Offset();
+  offset.selectedEntity = polyline;
+  core.scene.headers.offsetDistance = 1;
+  offset.points = [new Point(-5, 5)]; // outside the left edge
+
+  offset.action();
+
+  expect(core.scene.entities.count()).toBe(2);
+  const newPoly = core.scene.entities.get(1);
+  expect(newPoly.flags.hasFlag(1)).toBe(true); // closed flag preserved
+  const xs = newPoly.points.map((p) => p.x);
+  const ys = newPoly.points.map((p) => p.y);
+  expect(Math.min(...xs)).toBeCloseTo(-1);
+  expect(Math.max(...xs)).toBeCloseTo(11);
+  expect(Math.min(...ys)).toBeCloseTo(-1);
+  expect(Math.max(...ys)).toBeCloseTo(11);
+});
+
+// ─── closed inward offset ──────────────────────────────────────────────────────
+
+test('Test Offset.getOffsetPolylinePoints - closed rectangle offset inward', () => {
+  const offset = new Offset();
+  const points = [new Point(0, 0), new Point(10, 0), new Point(10, 10), new Point(0, 10)];
+
+  // sidePoint inside the rectangle
+  const result = offset.getOffsetPolylinePoints(points, true, new Point(5, 5), 1);
+
+  expect(result).not.toBeNull();
+  expect(result.length).toBe(4);
+  const xs = result.map((p) => p.x);
+  const ys = result.map((p) => p.y);
+  expect(Math.min(...xs)).toBeCloseTo(1);
+  expect(Math.max(...xs)).toBeCloseTo(9);
+  expect(Math.min(...ys)).toBeCloseTo(1);
+  expect(Math.max(...ys)).toBeCloseTo(9);
+});
+
+// ─── Through mode with circle ──────────────────────────────────────────────────
+
+test('Offset.execute - Through mode offsets circle to the through point', async () => {
+  core.scene.clear();
+  core.scene.selectionManager.reset();
+
+  // Circle: centre (0,0), radius 10
+  core.scene.addEntity('Circle', { points: [new Point(0, 0), new Point(10, 0)] });
+
+  const origInputManager = core.scene.inputManager;
+  let callCount = 0;
+  // Through → select circle → through point at (15,0) → undefined exits loop
+  const inputs = ['Through', { selectedEntityIndex: 0 }, new Point(15, 0)];
+
+  const offset = new Offset();
+  core.scene.inputManager = {
+    requestInput: async () => {
+      if (callCount < inputs.length) return inputs[callCount++];
+    },
+    actionCommand: () => {
+      offset.action();
+    },
+    executeCommand: () => {},
+    reset: () => {},
+  };
+
+  await offset.execute();
+
+  // getThroughDistance(circle at radius 10, throughPoint at r=15) = |15 - 10| = 5
+  expect(core.scene.headers.offsetDistance).toBeCloseTo(5);
+  expect(core.scene.entities.count()).toBe(2);
+  const newCircle = core.scene.entities.get(1);
+  expect(newCircle.getProperty('radius')).toBeCloseTo(15); // original 10 + outward 5
+
+  core.scene.inputManager = origInputManager;
+});

package/test/tools/pasteclip.test.js

@@ -12,7 +12,7 @@ describe('Pasteclip Tool', () => {
   beforeEach(() => {
     DesignCore.Scene.entities.clear();
     DesignCore.Scene.selectionManager.reset();
-    DesignCore.Scene.tempEntities.clear();
+    DesignCore.Scene.previewEntities.clear();
     DesignCore.Clipboard.Entities = []; // also resets basePoint
   });
 
@@ -57,8 +57,8 @@ describe('Pasteclip Tool', () => {
 
     const tool = new Pasteclip();
     tool.preview();
-    expect(DesignCore.Scene.tempEntities.count()).toBeGreaterThan(0);
-    const tempLine = DesignCore.Scene.tempEntities.get(0);
+    expect(DesignCore.Scene.previewEntities.count()).toBeGreaterThan(0);
+    const tempLine = DesignCore.Scene.previewEntities.get(0);
     const deltaX = targetPoint.x - basePoint.x;
     const deltaY = targetPoint.y - basePoint.y;
     expect(tempLine.points[0].x).toBe(line.points[0].x + deltaX);
@@ -94,7 +94,7 @@ describe('Pasteclip Tool', () => {
     expect(pasted.points[0].y).toBe(0);
 
     // Verify pasted entity has a unique handle
-    expect(newEntity.handle).toBeDefined();
-    expect(newEntity.handle).not.toBe(line.handle);
+    expect(newEntity.getProperty('handle')).toBeDefined();
+    expect(newEntity.getProperty('handle')).not.toBe(line.getProperty('handle'));
   });
 });

package/test/tools/purge.test.js

@@ -29,10 +29,10 @@ beforeEach(() => {
 
   const data = { points: [point1, point2], layer: 'layerWithItems', lineType: 'ltypeWithItems' };
 
-  DesignCore.Scene.addItem('Insert', { blockName: 'blockWithItems' });
-  DesignCore.Scene.addItem('Line', data);
-  DesignCore.Scene.addItem('Circle', data);
-  DesignCore.Scene.addItem('Text', data);
+  DesignCore.Scene.addEntity('Insert', { blockName: 'blockWithItems' });
+  DesignCore.Scene.addEntity('Line', data);
+  DesignCore.Scene.addEntity('Circle', data);
+  DesignCore.Scene.addEntity('Text', data);
 });
 
 test('Test purge.action', () => {

package/test/tools/rotate.test.js

@@ -49,7 +49,7 @@ test.each(inputScenarios)('Rotate.execute handles $desc', async (scenario) => {
   // create line
   const pointOne = new Point(10, 0);
   const pointTwo = new Point(20, 0);
-  core.scene.addItem('Line', { points: [pointOne, pointTwo] });
+  core.scene.addEntity('Line', { points: [pointOne, pointTwo] });
 
   // select line
   core.scene.selectionManager.addToSelectionSet(0);
@@ -57,9 +57,9 @@ test.each(inputScenarios)('Rotate.execute handles $desc', async (scenario) => {
   const rotate = new Rotate();
   await rotate.execute();
 
-  expect(core.scene.tempEntities.count()).toBe(0); // no temp entities before preview
+  expect(core.scene.previewEntities.count()).toBe(0); // no temp entities before preview
   rotate.preview(); // to set up any preview state if needed
-  expect(core.scene.tempEntities.count()).toBe(1); // preview should create temp entity
+  expect(core.scene.auxiliaryEntities.count()).toBeGreaterThanOrEqual(1); // preview should create rubber-band
 
   rotate.action();
 
@@ -78,12 +78,12 @@ test.each(inputScenarios)('Rotate.execute handles $desc', async (scenario) => {
 
 test('Test Rotate.action', () => {
   // Add items to scene
-  core.scene.addItem('Line', { points: [new Point(10, 0), new Point(20, 0)] });
-  core.scene.addItem('Circle', { points: [new Point(10, 0), new Point(20, 0)] });
-  core.scene.addItem('Polyline', { points: [new Point(10, 0), new Point(20, 0)] });
-  core.scene.addItem('Arc', { points: [new Point(10, 0), new Point(10, 10), new Point(0, 10)] });
-  core.scene.addItem('Rectangle', { points: [new Point(10, 0), new Point(0, 10)] });
-  core.scene.addItem('Text', { points: [new Point(10, 0), new Point(0, 10)], height: 10, rotation: 0, string: 'text test' });
+  core.scene.addEntity('Line', { points: [new Point(10, 0), new Point(20, 0)] });
+  core.scene.addEntity('Circle', { points: [new Point(10, 0), new Point(20, 0)] });
+  core.scene.addEntity('Polyline', { points: [new Point(10, 0), new Point(20, 0)] });
+  core.scene.addEntity('Arc', { points: [new Point(10, 0), new Point(10, 10), new Point(0, 10)] });
+  core.scene.addEntity('Rectangle', { points: [new Point(10, 0), new Point(0, 10)] });
+  core.scene.addEntity('Text', { points: [new Point(10, 0), new Point(0, 10)], height: 10, rotation: 0, string: 'text test' });
 
   // Add items to selection set
   for (let i = 0; i < core.scene.entities.count(); i++) {
@@ -131,3 +131,33 @@ test('Test Rotate.action', () => {
     expect(core.scene.entities.get(i).points[0].y).toBeCloseTo(0);
   }
 });
+
+test('Rotate.execute with reference - resets inputPoint to rotation centre', async () => {
+  const origInputManager = core.scene.inputManager;
+
+  const basePoint = new Point(10, 0);
+  // inputs: basePoint, 'r' (reference option), refBase, refEnd, then undefined to exit the while loop
+  const inputs = [basePoint, 'r', new Point(5, 0), new Point(5, 10), undefined];
+  let callCount = 0;
+  const mockInputManager = {
+    requestInput: async () => {
+      if (callCount < inputs.length) return inputs[callCount++];
+    },
+    executeCommand: () => {},
+    inputPoint: null,
+  };
+  core.scene.inputManager = mockInputManager;
+
+  core.scene.clear();
+  core.scene.addEntity('Line', { points: [new Point(10, 0), new Point(20, 0)] });
+  core.scene.selectionManager.addToSelectionSet(0);
+
+  const rotate = new Rotate();
+  await rotate.execute();
+
+  // After the reference sequence completes, inputPoint must be reset to the
+  // rotation centre (points[0]) so the tracking line uses the correct origin.
+  expect(mockInputManager.inputPoint).toEqual(basePoint);
+
+  core.scene.inputManager = origInputManager;
+});