@design-core/core 0.0.5 → 0.0.7

package/test/tools/fillet.test.js

@@ -1,6 +1,7 @@
 import { Core } from '../../core/core/core.js';
 import { Point } from '../../core/entities/point.js';
 import { Fillet } from '../../core/tools/fillet.js';
+import { DesignCore } from '../../core/designCore.js';
 import { Strings } from '../../core/lib/strings.js';
 import { SingleSelection } from '../../core/lib/selectionManager.js';
 import { expect, jest } from '@jest/globals';
@@ -829,3 +830,298 @@ test('Fillet.action radius>0 trimMode=false Line + Lwpolyline: standalone arc ad
   expect(core.scene.entities.get(0).points.length).toBe(2);
   expect(core.scene.entities.get(1).points.length).toBe(4);
 });
+
+// ─── action: closed polyline closing-wrap arc direction (regression) ──────────
+//
+// Square: P0=(0,0), P1=(10,0), P2=(10,10), P3=(0,10), closed flag=1.
+// Closing segment (idx=4): P3=(0,10)→P0=(0,0) — i.e. the left edge, travelling downward.
+// Segment 1: P0=(0,0)→P1=(10,0) — i.e. the bottom edge, travelling rightward.
+// The shared corner is P0=(0,0).
+//
+// With radius 2 the fillet must sit inside the square (bottom-left interior corner).
+// The arc centre is at (2,2).
+//   – lowerTangent = (0,2)  on the closing segment (left edge, y=2)
+//   – upperTangent = (2,0)  on segment 1 (bottom edge, x=2)
+//   – bulge on lowerTangent must be POSITIVE (CCW arc from (0,2) to (2,0) through ≈(0.59,0.59))
+//     (BasePolyline convention: –ve bulge = CW, +ve bulge = CCW)
+//
+// Before the fix the lowerTangent/upperTangent assignment was inverted, producing
+// an arc that traversed the exterior of the square.
+
+test('Fillet.action closing-wrap: lowerTangent is on closing segment (left edge)', () => {
+  core.scene.clear();
+  core.scene.addItem('Lwpolyline', { points: [new Point(0, 0), new Point(10, 0), new Point(10, 10), new Point(0, 10)] });
+  const polyEntity = core.scene.entities.get(0);
+  polyEntity.flags.setFlagValue(1);
+
+  core.scene.headers.filletRadius = 2;
+  core.scene.headers.trimMode = true;
+
+  // firstPick = closing segment (idx=4, left edge), secondPick = segment 1 (bottom edge)
+  const fillet = new Fillet();
+  fillet.firstPick.entity = polyEntity;
+  fillet.secondPick.entity = polyEntity;
+  fillet.firstPick.segment = polyEntity.getClosestSegment(new Point(0, 5));
+  fillet.firstPick.segmentIndex = polyEntity.getClosestSegmentIndex(new Point(0, 5));
+  fillet.firstPick.clickPoint = new Point(0, 5);
+  fillet.secondPick.segment = polyEntity.getClosestSegment(new Point(5, 0));
+  fillet.secondPick.segmentIndex = polyEntity.getClosestSegmentIndex(new Point(5, 0));
+  fillet.secondPick.clickPoint = new Point(5, 0);
+  fillet.action();
+
+  expect(core.scene.entities.count()).toBe(1);
+  const poly = core.scene.entities.get(0);
+  expect(poly.points.length).toBe(5);
+
+  // After the splice at cornerIdx=0:
+  //   points[0] = lowerTangent (arcStartPoint), points[1] = upperTangent
+  // lowerTangent must be on the closing segment (left edge, x≈0)
+  expect(poly.points[0].x).toBeCloseTo(0);
+  expect(poly.points[0].y).toBeCloseTo(2);
+  // upperTangent must be on segment 1 (bottom edge, y≈0)
+  expect(poly.points[1].x).toBeCloseTo(2);
+  expect(poly.points[1].y).toBeCloseTo(0);
+});
+
+test('Fillet.action closing-wrap: arc bulge sign is positive (CCW, fillet inside square)', () => {
+  // Same setup. The CCW arc from (0,2) to (2,0) sweeps through (≈0.59, ≈0.59)
+  // staying inside the square — a positive bulge value.
+  // Before the fix the lowerTangent/upperTangent were swapped, producing an arc
+  // that traversed the exterior of the square.
+  core.scene.clear();
+  core.scene.addItem('Lwpolyline', { points: [new Point(0, 0), new Point(10, 0), new Point(10, 10), new Point(0, 10)] });
+  const polyEntity = core.scene.entities.get(0);
+  polyEntity.flags.setFlagValue(1);
+
+  core.scene.headers.filletRadius = 2;
+  core.scene.headers.trimMode = true;
+
+  const fillet = new Fillet();
+  fillet.firstPick.entity = polyEntity;
+  fillet.secondPick.entity = polyEntity;
+  fillet.firstPick.segment = polyEntity.getClosestSegment(new Point(0, 5));
+  fillet.firstPick.segmentIndex = polyEntity.getClosestSegmentIndex(new Point(0, 5));
+  fillet.firstPick.clickPoint = new Point(0, 5);
+  fillet.secondPick.segment = polyEntity.getClosestSegment(new Point(5, 0));
+  fillet.secondPick.segmentIndex = polyEntity.getClosestSegmentIndex(new Point(5, 0));
+  fillet.secondPick.clickPoint = new Point(5, 0);
+  fillet.action();
+
+  const poly = core.scene.entities.get(0);
+  // points[0] carries the bulge for the arc from lowerTangent to upperTangent
+  expect(poly.points[0].bulge).toBeGreaterThan(0);
+});
+
+test('Fillet.action closing-wrap reversed pick order: arc bulge sign and tangent positions are correct', () => {
+  // Swap firstPick/secondPick — should produce the same geometry.
+  core.scene.clear();
+  core.scene.addItem('Lwpolyline', { points: [new Point(0, 0), new Point(10, 0), new Point(10, 10), new Point(0, 10)] });
+  const polyEntity = core.scene.entities.get(0);
+  polyEntity.flags.setFlagValue(1);
+
+  core.scene.headers.filletRadius = 2;
+  core.scene.headers.trimMode = true;
+
+  // firstPick = segment 1 (bottom edge), secondPick = closing segment (left edge, idx=4)
+  const fillet = new Fillet();
+  fillet.firstPick.entity = polyEntity;
+  fillet.secondPick.entity = polyEntity;
+  fillet.firstPick.segment = polyEntity.getClosestSegment(new Point(5, 0));
+  fillet.firstPick.segmentIndex = polyEntity.getClosestSegmentIndex(new Point(5, 0));
+  fillet.firstPick.clickPoint = new Point(5, 0);
+  fillet.secondPick.segment = polyEntity.getClosestSegment(new Point(0, 5));
+  fillet.secondPick.segmentIndex = polyEntity.getClosestSegmentIndex(new Point(0, 5));
+  fillet.secondPick.clickPoint = new Point(0, 5);
+  fillet.action();
+
+  expect(core.scene.entities.count()).toBe(1);
+  const poly = core.scene.entities.get(0);
+  expect(poly.points.length).toBe(5);
+
+  // Regardless of pick order: lowerTangent at (0,2), upperTangent at (2,0), bulge > 0 (CCW)
+  expect(poly.points[0].x).toBeCloseTo(0);
+  expect(poly.points[0].y).toBeCloseTo(2);
+  expect(poly.points[1].x).toBeCloseTo(2);
+  expect(poly.points[1].y).toBeCloseTo(0);
+  expect(poly.points[0].bulge).toBeGreaterThan(0);
+});
+
+// ─── action: entity property inheritance ─────────────────────────────────────
+
+test('Fillet.action arc inherits layer, lineWidth, lineType from first entity', () => {
+  // Perpendicular L-corner at origin; first entity on a non-default layer.
+  core.scene.clear();
+  core.scene.addItem('Line', { points: [new Point(-10, 0), new Point(0, 0)], layer: 'walls', lineWidth: 5, lineType: 'DASHED' });
+  core.scene.addItem('Line', { points: [new Point(0, 0), new Point(0, 10)] });
+
+  core.scene.headers.filletRadius = 2;
+  core.scene.headers.trimMode = false;
+
+  const fillet = new Fillet();
+  fillet.firstPick.entity = core.scene.entities.get(0);
+  fillet.secondPick.entity = core.scene.entities.get(1);
+  fillet.firstPick.clickPoint = new Point(-5, 0);
+  fillet.secondPick.clickPoint = new Point(0, 5);
+  fillet.action();
+
+  expect(core.scene.entities.count()).toBe(3);
+  const arc = core.scene.entities.get(2);
+  expect(arc.type).toBe('Arc');
+  expect(arc.getProperty('layer')).toBe('walls');
+  expect(arc.getProperty('lineWidth')).toBe(5);
+  expect(arc.getProperty('lineType')).toBe('DASHED');
+});
+
+test('Fillet.preview does not throw', () => {
+  const fillet = new Fillet();
+  expect(() => fillet.preview()).not.toThrow();
+});
+
+test('Fillet.preview returns early when findClosestItem returns undefined', () => {
+  core.scene.clear();
+  core.scene.addItem('Line', { points: [new Point(-10, 0), new Point(0, 0)] });
+  DesignCore.Scene.previewEntities.clear();
+
+  const fillet = new Fillet();
+  fillet.firstPick.entity = core.scene.entities.get(0);
+  fillet.firstPick.clickPoint = new Point(-5, 0);
+
+  const findSpy = jest.spyOn(core.scene.selectionManager, 'findClosestItem').mockReturnValue(undefined);
+  DesignCore.Mouse.pointOnScene = () => new Point(0, 5);
+  fillet.preview();
+  findSpy.mockRestore();
+
+  expect(DesignCore.Scene.previewEntities.count()).toBe(0);
+});
+
+test('Fillet.preview adds fillet arc to previewEntities in no-trim mode', () => {
+  core.scene.clear();
+  core.scene.addItem('Line', { points: [new Point(-10, 0), new Point(0, 0)] });
+  core.scene.addItem('Line', { points: [new Point(0, 0), new Point(0, 10)] });
+  DesignCore.Scene.previewEntities.clear();
+
+  core.scene.headers.filletRadius = 2;
+  core.scene.headers.trimMode = false;
+
+  const fillet = new Fillet();
+  fillet.firstPick.entity = core.scene.entities.get(0);
+  fillet.firstPick.clickPoint = new Point(-5, 0);
+
+  const findSpy = jest.spyOn(core.scene.selectionManager, 'findClosestItem').mockReturnValue(1);
+  DesignCore.Mouse.pointOnScene = () => new Point(0, 5);
+  fillet.preview();
+  findSpy.mockRestore();
+
+  expect(DesignCore.Scene.previewEntities.count()).toBeGreaterThanOrEqual(1);
+});
+
+test('Fillet.preview adds dulled segments and arc to previewEntities in trim mode', () => {
+  core.scene.clear();
+  core.scene.addItem('Line', { points: [new Point(-10, 0), new Point(0, 0)] });
+  core.scene.addItem('Line', { points: [new Point(0, 0), new Point(0, 10)] });
+  DesignCore.Scene.previewEntities.clear();
+
+  core.scene.headers.filletRadius = 2;
+  core.scene.headers.trimMode = true;
+
+  const fillet = new Fillet();
+  fillet.firstPick.entity = core.scene.entities.get(0);
+  fillet.firstPick.clickPoint = new Point(-5, 0);
+
+  const findSpy = jest.spyOn(core.scene.selectionManager, 'findClosestItem').mockReturnValue(1);
+  DesignCore.Mouse.pointOnScene = () => new Point(0, 5);
+  fillet.preview();
+  findSpy.mockRestore();
+
+  // dulled firstSeg + dulled secondSeg + firstTrimLine + secondTrimLine + arc = 5
+  expect(DesignCore.Scene.previewEntities.count()).toBeGreaterThanOrEqual(5);
+});
+
+test('Fillet.execute returns early when second-entity input is undefined (inner loop)', async () => {
+  core.scene.clear();
+  core.scene.addItem('Line', { points: [new Point(-10, 0), new Point(0, 0)] });
+  core.scene.addItem('Line', { points: [new Point(0, 0), new Point(0, 10)] });
+
+  const executeCommandSpy = jest.fn();
+  // Only one input: the first selection. Second requestInput returns undefined → inner loop returns.
+  await withMockInput(
+      core.scene,
+      [new SingleSelection(0, new Point(-5, 0))],
+      async () => {
+        const fillet = new Fillet();
+        await fillet.execute();
+        expect(executeCommandSpy).not.toHaveBeenCalled();
+      },
+      { extraMethods: { executeCommand: executeCommandSpy } },
+  );
+});
+
+test('Fillet.execute notifies NONCONSECUTIVESEGMENTS for non-adjacent polyline segments', async () => {
+  // 5-point polyline → 4 segments. Pick segment 1 (near -15,0) then segment 3 (near 5,0).
+  // Neither consecutive nor open-ends → NONCONSECUTIVESEGMENTS, then undefined to exit.
+  core.scene.clear();
+  core.scene.addItem('Lwpolyline', { points: [new Point(-20, 0), new Point(-10, 0), new Point(0, 0), new Point(10, 0), new Point(20, 0)] });
+
+  const notifySpy = jest.spyOn(core, 'notify');
+  await withMockInput(
+      core.scene,
+      [new SingleSelection(0, new Point(-15, 0)), new SingleSelection(0, new Point(5, 0)), undefined],
+      async () => {
+        const fillet = new Fillet();
+        await fillet.execute();
+      },
+  );
+  expect(notifySpy).toHaveBeenCalledWith(expect.stringContaining(Strings.Message.NONCONSECUTIVESEGMENTS));
+  notifySpy.mockRestore();
+});
+
+test('Fillet.execute Trim→Trim keeps trimMode=true', async () => {
+  core.scene.headers.trimMode = true;
+
+  await withMockInput(
+      core.scene,
+      ['Trim', 'Trim', undefined],
+      async () => {
+        const fillet = new Fillet();
+        await fillet.execute();
+      },
+  );
+
+  expect(core.scene.headers.trimMode).toBe(true);
+});
+
+// ─── regression: bulge must not leak onto Line endpoints ─────────────────────
+
+test('Fillet.action two fillets on the same line: trimmed endpoints have bulge = 0', () => {
+  // Line A: (-10, 0) → (10, 0)  horizontal
+  // Line B: (-10, 2) → (-10, -2) vertical at left end
+  // Line C: ( 10, 2) → ( 10, -2) vertical at right end
+  // Fillet A–B at the left corner, then A–C at the right corner.
+  // arc.toPolylinePoints() sets bulge on the start point;
+  // that value must not bleed onto the Line endpoints.
+  core.scene.clear();
+  core.scene.addItem('Line', { points: [new Point(-10, 0), new Point(10, 0)] });
+  core.scene.addItem('Line', { points: [new Point(-10, 2), new Point(-10, -2)] });
+  core.scene.addItem('Line', { points: [new Point(10, 2), new Point(10, -2)] });
+
+  core.scene.headers.filletRadius = 1;
+  core.scene.headers.trimMode = true;
+
+  const fillet1 = new Fillet();
+  fillet1.firstPick.entity = core.scene.entities.get(0);
+  fillet1.secondPick.entity = core.scene.entities.get(1);
+  fillet1.firstPick.clickPoint = new Point(-5, 0);
+  fillet1.secondPick.clickPoint = new Point(-10, 1);
+  fillet1.action();
+
+  const fillet2 = new Fillet();
+  fillet2.firstPick.entity = core.scene.entities.get(0);
+  fillet2.secondPick.entity = core.scene.entities.get(2);
+  fillet2.firstPick.clickPoint = new Point(5, 0);
+  fillet2.secondPick.clickPoint = new Point(10, 1);
+  fillet2.action();
+
+  const line = core.scene.entities.get(0);
+  expect(line.points[0].bulge).toBe(0);
+  expect(line.points[1].bulge).toBe(0);
+});

package/test/tools/matchProp.test.js

@@ -69,16 +69,16 @@ test('Test MatchProp.action matches properties from source to targets', () => {
   // Validate that layer property was matched to targets
   for (let i = 0; i < match.destinationSetIndices.length; i++) {
     const tgt = core.scene.entities.get(match.destinationSetIndices[i]);
-    expect(tgt.layer).toBe('test');
+    expect(tgt.getProperty('layer')).toBe('test');
   }
 
   const circle = core.scene.entities.get(1);
-  expect(circle.radius).toBe(10); // original radius
+  expect(circle.getProperty('radius')).toBe(10); // original radius
 
   const arc = core.scene.entities.get(3);
-  expect(arc.radius).toBe(10); // original radius
+  expect(arc.getProperty('radius')).toBe(10); // original radius
 
   const text = core.scene.entities.get(5);
-  expect(text.height).toBe(10); // original height
-  expect(text.string).toBe('text test'); // original string
+  expect(text.getProperty('height')).toBe(10); // original height
+  expect(text.getProperty('string')).toBe('text test'); // original string
 });

package/test/tools/mirror.test.js

@@ -231,8 +231,8 @@ test('Test Mirror.action - keep source (default)', () => {
   for (let i = 0; i < entityCount; i++) {
     const original = core.scene.entities.get(i);
     const copy = core.scene.entities.get(i + entityCount);
-    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'));
   }
 });
 
@@ -310,8 +310,8 @@ test('Test Mirror.action - arc direction is reversed', () => {
   const original = core.scene.entities.get(0);
   const mirrored = core.scene.entities.get(1);
 
-  expect(original.direction).toBe(1);
-  expect(mirrored.direction).toBe(-1);
+  expect(original.getProperty('direction')).toBe(1);
+  expect(mirrored.getProperty('direction')).toBe(-1);
 });
 
 test('Test Mirror.getMirroredPoints', () => {
@@ -395,7 +395,7 @@ test('Mirror.preview - no points set, adds no temp entities', () => {
   // No points pushed — guard condition should prevent any work
   mirror.preview();
 
-  expect(core.scene.tempEntities.count()).toBe(0);
+  expect(core.scene.auxiliaryEntities.count()).toBe(0);
 });
 
 test('Mirror.preview - one point set, draws temp mirror line using mouse position', () => {
@@ -409,8 +409,8 @@ test('Mirror.preview - one point set, draws temp mirror line using mouse positio
   mirror.points.push(new Point(3, 3)); // pt1 distinct from default mouse (0,0) scene position
   mirror.preview();
 
-  // Temp mirror line should have been created
-  expect(core.scene.tempEntities.count()).toBeGreaterThanOrEqual(1);
+  // Rubber-band mirror line should have been created
+  expect(core.scene.auxiliaryEntities.count()).toBeGreaterThanOrEqual(1);
 });
 
 test('Mirror.preview - two distinct points, draws mirror line and mirrors selected items', () => {
@@ -425,8 +425,8 @@ test('Mirror.preview - two distinct points, draws mirror line and mirrors select
   mirror.points.push(new Point(1, 0)); // pt2 — mirror across X axis
   mirror.preview();
 
-  // Temp mirror line should exist
-  expect(core.scene.tempEntities.count()).toBeGreaterThanOrEqual(1);
+  // Rubber-band mirror line should exist
+  expect(core.scene.auxiliaryEntities.count()).toBeGreaterThanOrEqual(1);
 
   // The selectedItems copy should have its points mirrored (y negated)
   const previewItem = core.scene.selectionManager.selectedItems[0];
@@ -445,8 +445,8 @@ test('Mirror.preview - identical points, draws line but skips mirroring selected
   mirror.points.push(new Point(5, 5)); // pt2 — same as pt1, zero-length mirror line
   mirror.preview();
 
-  // Temp line is still drawn
-  expect(core.scene.tempEntities.count()).toBeGreaterThanOrEqual(1);
+  // Rubber-band line is still drawn
+  expect(core.scene.auxiliaryEntities.count()).toBeGreaterThanOrEqual(1);
 
   // Selected item points should be unchanged (mirroring skipped)
   const previewItem = core.scene.selectionManager.selectedItems[0];
@@ -467,9 +467,9 @@ test('Mirror.preview - reverses direction for entities with a direction property
   mirror.preview();
 
   // Original entity direction is unchanged
-  expect(core.scene.entities.get(0).direction).toBe(1);
+  expect(core.scene.entities.get(0).getProperty('direction')).toBe(1);
 
   // Preview copy has direction reversed
   const previewItem = core.scene.selectionManager.selectedItems[0];
-  expect(previewItem.direction).toBe(-1);
+  expect(previewItem.getProperty('direction')).toBe(-1);
 });

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();
@@ -267,7 +268,7 @@ 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', () => {
@@ -286,7 +287,7 @@ 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', () => {
@@ -464,7 +465,7 @@ test('Test Offset.getOffsetPoints - arc inward offset shrinks radius', () => {
   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', () => {
@@ -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 selectedItem is null', () => {
+  core.scene.clear();
+  DesignCore.Scene.previewEntities.clear();
+  core.scene.headers.offsetDistance = 5;
+
+  const offset = new Offset();
+  offset.selectedItem = 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.addItem('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.selectedItem = 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.addItem('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.selectedItem = 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.addItem('Lwpolyline', { points: [new Point(0, 0), new Point(10, 0), new Point(10, 10)] });
+
+  const offset = new Offset();
+  offset.selectedItem = 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.addItem('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.selectedItem = 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: center (0,0), radius 10
+  core.scene.addItem('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', { selectedItemIndex: 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/rotate.test.js

@@ -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();
 
@@ -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 center', 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.addItem('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 center (points[0]) so the tracking line uses the correct origin.
+  expect(mockInputManager.inputPoint).toEqual(basePoint);
+
+  core.scene.inputManager = origInputManager;
+});