@design-core/core 51.2.0 → 52.0.0

package/test/lib/inputManager.test.js

@@ -6,6 +6,8 @@ import { Point } from '../../core/entities/point.js';
 import { PromptOptions } from '../../core/lib/inputManager.js';
 import { Input, MouseDown, MouseUp } from '../../core/lib/inputManager.js';
 import { SingleSelection } from '../../core/lib/selectionManager.js';
+import { DimensionBase } from '../../core/dimensions/dimensionBase.js';
+import { GripStretch } from '../../core/tools/gripStretch.js';
 import { expect, jest } from '@jest/globals';
 
 const core = new Core();
@@ -269,6 +271,30 @@ test('starting a tool command from idle preserves the selection', () => {
   inputManager.reset();
 });
 
+// Regression test: startCommand() generalises cancelling a previously active command to
+// `activeCommand.cancel()` for any Tool, instead of special-casing GripStretch - Tool's default
+// cancel() just delegates to the same reset() the old `else` branch called directly, so this
+// must behave identically for every other Tool (Move, Erase, Offset, etc.)
+test('starting a new command calls cancel() on a previously active Tool', () => {
+  inputManager.reset();
+  const Erase = DesignCore.CommandManager.createNew('Erase').constructor;
+  jest.spyOn(Erase.prototype, 'execute').mockImplementation(() => {});
+  inputManager.onCommand('E');
+  expect(inputManager.activeCommand).toBeInstanceOf(Erase);
+
+  const cancelSpy = jest.spyOn(inputManager.activeCommand, 'cancel');
+  const resetSpy = jest.spyOn(inputManager, 'reset');
+
+  inputManager.onCommand('M');
+
+  expect(cancelSpy).toHaveBeenCalledTimes(1);
+  // Tool's default cancel() delegates to the very same reset()
+  expect(resetSpy).toHaveBeenCalled();
+
+  jest.restoreAllMocks();
+  inputManager.reset();
+});
+
 // ─── onCommand - command shortcut while non-accepting prompt is active ─────────
 
 test('onCommand with valid shortcut while POINT prompt active - switches command without notifying', () => {
@@ -877,6 +903,45 @@ test('mouseMoved skips highlightEntityUnderMouse when snapping is active and sna
   inputManager.reset();
 });
 
+test('mouseMoved still calls highlightEntityUnderMouse when a command preview exists but the prompt also accepts SINGLESELECTION', () => {
+  // Reproduces the DIM command's second selection prompt: a candidate dimension preview is
+  // shown (from the first selected entity) while the prompt still accepts a second selection.
+  inputManager.reset();
+  inputManager.activeCommand = new Line();
+  const po = new PromptOptions('', [Input.Type.POINT, Input.Type.SINGLESELECTION]);
+  inputManager.requestInput(po);
+  jest.spyOn(inputManager.snapping, 'snap').mockReturnValue(undefined);
+  jest.spyOn(DesignCore.Scene.previewEntities, 'count').mockReturnValue(1);
+  jest.spyOn(core.scene.selectionManager, 'findClosestItem').mockReturnValue(0);
+  jest.spyOn(core.scene.entities, 'get').mockReturnValue(new Line());
+  core.mouse.buttonOneDown = false;
+
+  inputManager.mouseMoved();
+
+  expect(core.scene.hoverEntities.count()).toBe(1);
+  jest.restoreAllMocks();
+  po.cancel();
+  inputManager.reset();
+});
+
+test('mouseMoved skips highlightEntityUnderMouse when a command preview exists and the prompt only accepts POINT', () => {
+  inputManager.reset();
+  inputManager.activeCommand = new Line();
+  const po = new PromptOptions('', [Input.Type.POINT]);
+  inputManager.requestInput(po);
+  jest.spyOn(inputManager.snapping, 'snap').mockReturnValue(undefined);
+  jest.spyOn(DesignCore.Scene.previewEntities, 'count').mockReturnValue(1);
+  const highlightSpy = jest.spyOn(inputManager, 'highlightEntityUnderMouse');
+  core.mouse.buttonOneDown = false;
+
+  inputManager.mouseMoved();
+
+  expect(highlightSpy).not.toHaveBeenCalled();
+  jest.restoreAllMocks();
+  po.cancel();
+  inputManager.reset();
+});
+
 // ─── mouseDown – no MOUSEDOWN prompt ─────────────────────────────────────────
 
 test('mouseDown case 0 without MOUSEDOWN prompt does not attempt to resolve a prompt', () => {
@@ -929,6 +994,37 @@ test('mouseUp case 0 with no prompt and no active command and mouse not moved -
   windowSelectSpy.mockRestore();
 });
 
+// Regression test: grip editing has neither an active command nor a prompt of its own, so
+// mouseUp(0)'s (promptOption || activeCommand) guard used to skip over it and call windowSelect()
+// whenever the mouse moved since mousedown - i.e. every click-drag-release used to grab a grip
+// (mousedown grabs it, drag moves it, mouseup released over a different point) also started a
+// crossing/window selection. GripStretch now marks grip editing as the active command, so the
+// existing guard correctly skips window-select during an in-progress drag too
+test('mouseUp case 0 does not call windowSelect while GripStretch is active', () => {
+  inputManager.reset();
+  selectDimensionWithGrip(10, 10);
+  jest.spyOn(DesignCore.Mouse, 'pointOnScene').mockReturnValue(new Point(10, 10));
+  inputManager.onLeftClick(new Point(10, 10));
+  expect(inputManager.activeCommand).toBeInstanceOf(GripStretch);
+
+  const windowSelectSpy = jest.spyOn(inputManager, 'windowSelect').mockImplementation(() => {});
+  core.mouse.mouseDownCanvasPoint = new Point(0, 0);
+  core.mouse.x = 50;
+  core.mouse.y = 50;
+
+  inputManager.mouseUp(0);
+
+  expect(windowSelectSpy).not.toHaveBeenCalled();
+  // the grip is still stuck to the mouse - mouseUp must not interfere with the in-progress drag
+  expect(inputManager.activeCommand).toBeInstanceOf(GripStretch);
+
+  windowSelectSpy.mockRestore();
+  core.mouse.x = 0;
+  core.mouse.y = 0;
+  jest.restoreAllMocks();
+  inputManager.reset();
+});
+
 // ─── highlightEntityUnderMouse – selection prompts ───────────────────────────
 
 test('highlightEntityUnderMouse returns true with SINGLESELECTION prompt and entity found', () => {
@@ -1006,7 +1102,226 @@ test('onLeftClick with SINGLESELECTION prompt and entity nearby - selects the en
   inputManager.reset();
 });
 
-// ─── onEnterPressed – SELECTIONSET already accepted ──────────────────────────
+// ─── grip editing ─────────────────────────────────────────────────────────────
+
+/**
+ * Select a fresh DimensionBase with a Pt11 (text position) grip at the given coordinates.
+ * @param {number} x
+ * @param {number} y
+ * @return {number} index of the entity in DesignCore.Scene.entities
+ */
+function selectDimensionWithGrip(x, y) {
+  core.scene.clear();
+  const dim = new DimensionBase({});
+  dim.points = [
+    Object.assign(new Point(0, 0), { sequence: 13 }),
+    Object.assign(new Point(x, y), { sequence: 11 }),
+  ];
+  DesignCore.Scene.entities.add(dim);
+  core.scene.selectionManager.addToSelectionSet(0);
+  return 0;
+}
+
+// GripStretch's execute() resolves its "stretch point" prompt asynchronously (same as any
+// other Tool's requestInput) - flush the microtask queue after a drop click before asserting.
+const flushPromises = () => new Promise((resolve) => setTimeout(resolve, 0));
+
+test('onLeftClick grabs a grip under the mouse and starts GripStretch', () => {
+  inputManager.reset();
+  selectDimensionWithGrip(10, 10);
+  jest.spyOn(DesignCore.Mouse, 'pointOnScene').mockReturnValue(new Point(10, 10));
+  const singleSelectSpy = jest.spyOn(core.scene.selectionManager, 'singleSelect');
+
+  inputManager.onLeftClick(new Point(10, 10));
+
+  expect(inputManager.activeCommand).toBeInstanceOf(GripStretch);
+  expect(inputManager.activeCommand.entityIndex).toBe(0);
+  expect(singleSelectSpy).not.toHaveBeenCalled();
+  jest.restoreAllMocks();
+  inputManager.reset();
+});
+
+test('mouseMoved updates the selected-entity preview clone while GripStretch is active', () => {
+  inputManager.reset();
+  selectDimensionWithGrip(10, 10);
+  jest.spyOn(DesignCore.Mouse, 'pointOnScene').mockReturnValue(new Point(10, 10));
+  inputManager.onLeftClick(new Point(10, 10));
+  expect(inputManager.activeCommand).toBeInstanceOf(GripStretch);
+
+  jest.spyOn(DesignCore.Mouse, 'pointOnScene').mockReturnValue(new Point(50, 60));
+  inputManager.mouseMoved();
+
+  const previewEntity = core.scene.selectionManager.selectedEntities[0];
+  const previewPt11 = previewEntity.getPointBySequence(previewEntity.points, 11);
+  expect(previewPt11.x).toBe(50);
+  expect(previewPt11.y).toBe(60);
+
+  // the real scene entity is untouched until drop
+  const realPt11 = core.scene.entities.get(0).getPointBySequence(core.scene.entities.get(0).points, 11);
+  expect(realPt11.x).toBe(10);
+  expect(realPt11.y).toBe(10);
+
+  jest.restoreAllMocks();
+  inputManager.reset();
+});
+
+test('onLeftClick drops an active grip, committing the new point to the real entity', async () => {
+  inputManager.reset();
+  selectDimensionWithGrip(10, 10);
+  jest.spyOn(DesignCore.Mouse, 'pointOnScene').mockReturnValue(new Point(10, 10));
+  inputManager.onLeftClick(new Point(10, 10));
+  expect(inputManager.activeCommand).toBeInstanceOf(GripStretch);
+
+  jest.spyOn(DesignCore.Mouse, 'pointOnScene').mockReturnValue(new Point(50, 60));
+  inputManager.onLeftClick(new Point(50, 60));
+  await flushPromises();
+
+  expect(inputManager.activeCommand).toBeUndefined();
+  const realEntity = core.scene.entities.get(0);
+  const realPt11 = realEntity.getPointBySequence(realEntity.points, 11);
+  expect(realPt11.x).toBe(50);
+  expect(realPt11.y).toBe(60);
+
+  jest.restoreAllMocks();
+  inputManager.reset();
+});
+
+// Regression test: requestInput() sets inputManager.inputPoint to the dropped point (needed for
+// polar/ortho tracking), but GripStretch's completion path bypasses the standard reset() that
+// normally clears it - leaving the next command's first point (or the next grip drag's tracking
+// line) anchored to this stale drop position instead of starting fresh
+test('onLeftClick drops an active grip clears inputPoint, not just activeCommand', async () => {
+  inputManager.reset();
+  selectDimensionWithGrip(10, 10);
+  jest.spyOn(DesignCore.Mouse, 'pointOnScene').mockReturnValue(new Point(10, 10));
+  inputManager.onLeftClick(new Point(10, 10));
+
+  jest.spyOn(DesignCore.Mouse, 'pointOnScene').mockReturnValue(new Point(50, 60));
+  inputManager.onLeftClick(new Point(50, 60));
+  await flushPromises();
+
+  expect(inputManager.inputPoint).toBeNull();
+
+  jest.restoreAllMocks();
+  inputManager.reset();
+});
+
+// Regression test: the grip drop commits only 'points' via UpdateState, but DimensionBase's
+// points setter also flips dimType.userPositionedText as a side effect. Since State.do() only
+// snapshots the properties explicitly listed in the commit, undo used to restore the old points
+// while leaving the flag true - reverting the points but not the (now stale) automatic-placement
+// text layout. userPositionedText must now be committed explicitly alongside points so its
+// pre-drag value (false, for an initially auto-positioned dimension) is captured for undo too.
+// Also covers Scene.undo()/redo() reloading the retained selection preview clone, which used to
+// stay stuck at the dropped position while findGripUnderMouse() hit-tested the restored geometry
+test('undo after a grip drop restores both points and the original auto-positioned state', async () => {
+  inputManager.reset();
+  const entityIndex = selectDimensionWithGrip(10, 10);
+  const entity = core.scene.entities.get(entityIndex);
+  expect(entity.dimType.hasUserPositionedText()).toBe(false);
+
+  jest.spyOn(DesignCore.Mouse, 'pointOnScene').mockReturnValue(new Point(10, 10));
+  inputManager.onLeftClick(new Point(10, 10));
+
+  jest.spyOn(DesignCore.Mouse, 'pointOnScene').mockReturnValue(new Point(50, 60));
+  inputManager.onLeftClick(new Point(50, 60));
+  await flushPromises();
+
+  const draggedEntity = core.scene.entities.get(entityIndex);
+  expect(draggedEntity.dimType.hasUserPositionedText()).toBe(true);
+  const draggedPt11 = draggedEntity.getPointBySequence(draggedEntity.points, 11);
+  expect(draggedPt11.x).toBe(50);
+  expect(draggedPt11.y).toBe(60);
+
+  core.scene.undo();
+
+  const restoredEntity = core.scene.entities.get(entityIndex);
+  const restoredPt11 = restoredEntity.getPointBySequence(restoredEntity.points, 11);
+  expect(restoredPt11.x).toBe(10);
+  expect(restoredPt11.y).toBe(10);
+  expect(restoredEntity.dimType.hasUserPositionedText()).toBe(false);
+
+  // the retained selection preview clone must be reloaded too, not just the real entity -
+  // otherwise Canvas keeps drawing the dropped clone while the grip hit-test uses the restored one
+  const restoredClone = core.scene.selectionManager.selectedEntities[0];
+  const restoredClonePt11 = restoredClone.getPointBySequence(restoredClone.points, 11);
+  expect(restoredClonePt11.x).toBe(10);
+  expect(restoredClonePt11.y).toBe(10);
+  expect(core.scene.selectionManager.findGripUnderMouse(new Point(10, 10))).toBeDefined();
+
+  core.scene.redo();
+
+  const redoneEntity = core.scene.entities.get(entityIndex);
+  expect(redoneEntity.dimType.hasUserPositionedText()).toBe(true);
+  const redonePt11 = redoneEntity.getPointBySequence(redoneEntity.points, 11);
+  expect(redonePt11.x).toBe(50);
+  expect(redonePt11.y).toBe(60);
+
+  const redoneClone = core.scene.selectionManager.selectedEntities[0];
+  const redoneClonePt11 = redoneClone.getPointBySequence(redoneClone.points, 11);
+  expect(redoneClonePt11.x).toBe(50);
+  expect(redoneClonePt11.y).toBe(60);
+  expect(core.scene.selectionManager.findGripUnderMouse(new Point(50, 60))).toBeDefined();
+
+  jest.restoreAllMocks();
+  inputManager.reset();
+});
+
+// Regression test: starting a command while a grip is stuck to the mouse used to leave
+// activeGrip set, because startCommand() only reset state when activeCommand was already
+// defined - but a grip can only be grabbed while idle (activeCommand undefined). The dangling
+// grip then suppressed the new command's preview during mouse movement, and its next click
+// dropped the grip instead of answering the command's prompt
+test('startCommand cancels an active grip and reloads the selection previews', () => {
+  inputManager.reset();
+  selectDimensionWithGrip(10, 10);
+
+  jest.spyOn(DesignCore.Mouse, 'pointOnScene').mockReturnValue(new Point(10, 10));
+  inputManager.onLeftClick(new Point(10, 10));
+  expect(inputManager.activeCommand).toBeInstanceOf(GripStretch);
+
+  // drag the grip - this mutates only the live preview clone's Pt11, not the real entity
+  jest.spyOn(DesignCore.Mouse, 'pointOnScene').mockReturnValue(new Point(80, 90));
+  inputManager.mouseMoved();
+  const previewEntity = core.scene.selectionManager.selectedEntities[0];
+  const draggedPreviewPt11 = previewEntity.getPointBySequence(previewEntity.points, 11);
+  expect(draggedPreviewPt11.x).toBe(80);
+
+  // Prevent Move.execute() from running so we can isolate startCommand's own behaviour.
+  const Move = DesignCore.CommandManager.createNew('Move').constructor;
+  jest.spyOn(Move.prototype, 'execute').mockImplementation(() => {});
+
+  inputManager.startCommand('Move');
+
+  expect(inputManager.activeCommand).toBeInstanceOf(Move);
+
+  // the preview clone must be reloaded from the real (undragged) entity, not left dragged
+  const reloadedEntity = core.scene.selectionManager.selectedEntities[0];
+  const reloadedPt11 = reloadedEntity.getPointBySequence(reloadedEntity.points, 11);
+  expect(reloadedPt11.x).toBe(10);
+  expect(reloadedPt11.y).toBe(10);
+
+  jest.restoreAllMocks();
+  inputManager.reset();
+});
+
+// Regression test: pressing Enter while a grip is active ends GripStretch via the normal
+// reset() path, deselecting the entity - this matches ending any other command on Enter
+test('onEnterPressed ends an active grip and deselects the entity', () => {
+  inputManager.reset();
+  selectDimensionWithGrip(10, 10);
+  jest.spyOn(DesignCore.Mouse, 'pointOnScene').mockReturnValue(new Point(10, 10));
+  inputManager.onLeftClick(new Point(10, 10));
+  expect(inputManager.activeCommand).toBeInstanceOf(GripStretch);
+
+  inputManager.onEnterPressed();
+
+  expect(inputManager.activeCommand).toBeUndefined();
+  expect(core.scene.selectionManager.selectionSet.selectionSet.length).toBe(0);
+
+  jest.restoreAllMocks();
+  inputManager.reset();
+});
 
 test('onEnterPressed with SELECTIONSET prompt already accepted - resets', () => {
   inputManager.reset();

package/test/lib/selectionManager.test.js

@@ -1,5 +1,6 @@
 import { Core } from '../../core/core/core.js';
 import { Point } from '../../core/entities/point.js';
+import { DimensionBase } from '../../core/dimensions/dimensionBase.js';
 
 const core = new Core();
 const selectionManager = core.scene.selectionManager;
@@ -71,3 +72,44 @@ test('Test SelectionManager.selectAll()', () => {
   expect(selectionManager.selectionSet.selectionSet).toEqual([0, 1, 2]);
 });
 
+// ─── findGripUnderMouse ───────────────────────────────────────────────────────
+
+/**
+ * Select a fresh DimensionBase with a Pt11 (text position) grip at the given coordinates.
+ * @param {number} x
+ * @param {number} y
+ * @return {number} index of the entity in core.scene.entities
+ */
+function selectDimensionWithGrip(x, y) {
+  selectionManager.reset();
+  const dim = new DimensionBase({});
+  dim.points = [
+    Object.assign(new Point(0, 0), { sequence: 13 }),
+    Object.assign(new Point(x, y), { sequence: 11 }),
+  ];
+  core.scene.entities.add(dim);
+  const entityIndex = core.scene.entities.count() - 1;
+  selectionManager.addToSelectionSet(entityIndex);
+  return entityIndex;
+}
+
+test('findGripUnderMouse returns undefined when no entity is selected', () => {
+  selectionManager.reset();
+  expect(selectionManager.findGripUnderMouse(new Point(0, 0))).toBeUndefined();
+});
+
+test('findGripUnderMouse returns the grip when the point is within tolerance', () => {
+  const entityIndex = selectDimensionWithGrip(10, 10);
+  const found = selectionManager.findGripUnderMouse(new Point(10, 10));
+  expect(found).toBeDefined();
+  expect(found.entityIndex).toBe(entityIndex);
+  expect(found.grip.point.x).toBe(10);
+  expect(found.grip.point.y).toBe(10);
+});
+
+test('findGripUnderMouse returns undefined when the point is far from any grip', () => {
+  selectDimensionWithGrip(10, 10);
+  expect(selectionManager.findGripUnderMouse(new Point(1000, 1000))).toBeUndefined();
+});
+
+

package/test/renderers/pdfRenderer.test.js

@@ -178,6 +178,32 @@ describe('PdfRenderer — drawing', () => {
     // cos(π/4) ≈ 0.7071, sin(π/4) ≈ 0.7071
     expect(output).toContain('0.7071');
   });
+
+  test('drawText encodes non-ASCII characters as WinAnsi octal escapes', () => {
+    const renderer = new PdfRenderer(100, 100);
+    renderer.drawText([
+      { char: '\u00B0', x: 0, y: 0, rotation: 0 },
+      { char: '\u00D8', x: 0, y: 0, rotation: 0 },
+    ], 'Helvetica', 5);
+    const output = renderer.getOutput();
+    expect(output).toContain('(\\260)');
+    expect(output).toContain('(\\330)');
+    expect(output).not.toMatch(/[^\x00-\x7f]/);
+  });
+
+  test.each([
+    ['\u2019', '\\222'], // right single quote
+    ['\u201C', '\\223'], // left double quote
+    ['\u2013', '\\226'], // en dash
+    ['\u2014', '\\227'], // em dash
+    ['\u20AC', '\\200'], // euro sign
+    ['\u2122', '\\231'], // trademark
+    ['\u4E2D', '\\077'], // unsupported, replaced with ?
+  ])('drawText maps %s to WinAnsi %s', (char, escape) => {
+    const renderer = new PdfRenderer(100, 100);
+    renderer.drawText([{ char, x: 0, y: 0, rotation: 0 }], 'Helvetica', 5);
+    expect(renderer.getOutput()).toContain(`(${escape})`);
+  });
 });
 
 describe('PdfRenderer — state methods', () => {

package/test/tables/dimstyle.test.js

@@ -1,4 +1,5 @@
 import { DimStyle } from '../../core/tables/dimStyle';
+import { DesignCore } from '../../core/designCore.js';
 
 describe('DimStyle', () => {
   let style;
@@ -67,6 +68,37 @@ describe('DimStyle', () => {
     style.setValue('customProp', 'hello');
     expect(style.customProp).toBeUndefined();
   });
+
+  describe('getTextStyleHandle', () => {
+    beforeEach(() => {
+      DesignCore.Core = {
+        styleManager: {
+          getItems: () => [
+            { name: 'STANDARD', handle: '19' },
+            { name: '19', handle: '2A' },
+          ],
+        },
+      };
+    });
+
+    test('resolves a style name by name', () => {
+      expect(new DimStyle({ DIMTXSTY: '19' }).getTextStyleHandle()).toBe('2A');
+    });
+
+    test('resolves an imported group 340 value strictly as a handle', () => {
+      expect(new DimStyle({ 340: '19' }).getTextStyleHandle()).toBe('19');
+    });
+
+    test('falls back to the Standard style when the reference is unknown', () => {
+      expect(new DimStyle({ 340: 'FF' }).getTextStyleHandle()).toBe('19');
+    });
+
+    test('setValue switches DIMTXSTY back to a name reference', () => {
+      const dimStyle = new DimStyle({ 340: '19' });
+      dimStyle.setValue('DIMTXSTY', '19');
+      expect(dimStyle.getTextStyleHandle()).toBe('2A');
+    });
+  });
 });
 
 

package/test/tools/gripStretch.test.js

@@ -0,0 +1,108 @@
+import { Tool } from '../../core/tools/tool.js';
+import { GripStretch } from '../../core/tools/gripStretch.js';
+import { Core } from '../../core/core/core.js';
+import { DesignCore } from '../../core/designCore.js';
+import { DimensionBase } from '../../core/dimensions/dimensionBase.js';
+import { Point } from '../../core/entities/point.js';
+import { jest } from '@jest/globals';
+
+const core = new Core();
+
+test('GripStretch is a Tool with type GripStretch', () => {
+  const gripStretch = new GripStretch();
+  expect(gripStretch).toBeInstanceOf(Tool);
+  expect(gripStretch.type).toBe('GripStretch');
+});
+
+test('GripStretch is not registered as a typeable command', () => {
+  expect(typeof GripStretch.register).toBe('undefined');
+});
+
+test('GripStretch.action commits the dropped grip position to the real entity', () => {
+  core.scene.clear();
+  const dim = new DimensionBase({});
+  dim.points = [
+    Object.assign(new Point(0, 0), { sequence: 13 }),
+    Object.assign(new Point(10, 10), { sequence: 11 }),
+  ];
+  DesignCore.Scene.entities.add(dim);
+  core.scene.selectionManager.addToSelectionSet(0);
+
+  const grip = dim.getGrips()[0];
+  const gripStretch = new GripStretch(0, grip);
+  gripStretch.points.push(new Point(50, 60));
+
+  gripStretch.action();
+
+  const entity = core.scene.entities.get(0);
+  const pt11 = entity.getPointBySequence(entity.points, 11);
+  expect(pt11.x).toBe(50);
+  expect(pt11.y).toBe(60);
+  expect(entity.dimType.hasUserPositionedText()).toBe(true);
+});
+
+test('GripStretch.preview live-updates the selected-entity preview clone, not the real entity', () => {
+  core.scene.clear();
+  const dim = new DimensionBase({});
+  dim.points = [
+    Object.assign(new Point(0, 0), { sequence: 13 }),
+    Object.assign(new Point(10, 10), { sequence: 11 }),
+  ];
+  DesignCore.Scene.entities.add(dim);
+  core.scene.selectionManager.addToSelectionSet(0);
+
+  const grip = dim.getGrips()[0];
+  const gripStretch = new GripStretch(0, grip);
+  jest.spyOn(DesignCore.Mouse, 'pointOnScene').mockReturnValue(new Point(50, 60));
+
+  gripStretch.preview();
+
+  const previewEntity = core.scene.selectionManager.selectedEntities[0];
+  const previewPt11 = previewEntity.getPointBySequence(previewEntity.points, 11);
+  expect(previewPt11.x).toBe(50);
+  expect(previewPt11.y).toBe(60);
+
+  const realPt11 = core.scene.entities.get(0).getPointBySequence(core.scene.entities.get(0).points, 11);
+  expect(realPt11.x).toBe(10);
+  expect(realPt11.y).toBe(10);
+
+  jest.restoreAllMocks();
+});
+
+test('GripStretch.execute requests the stretch point then commits, keeping the entity selected', async () => {
+  core.scene.clear();
+  const dim = new DimensionBase({});
+  dim.points = [
+    Object.assign(new Point(0, 0), { sequence: 13 }),
+    Object.assign(new Point(10, 10), { sequence: 11 }),
+  ];
+  DesignCore.Scene.entities.add(dim);
+  core.scene.selectionManager.addToSelectionSet(0);
+
+  const grip = dim.getGrips()[0];
+  const gripStretch = new GripStretch(0, grip);
+
+  const origInputManager = DesignCore.Scene.inputManager;
+  DesignCore.Scene.inputManager = {
+    requestInput: async (op) => {
+      expect(op.promptMessage).toBe('Specify stretch point');
+      return new Point(50, 60);
+    },
+    actionCommand: () => gripStretch.action(),
+    refreshPreview: () => {},
+  };
+
+  try {
+    await gripStretch.execute();
+  } finally {
+    DesignCore.Scene.inputManager = origInputManager;
+  }
+
+  const entity = core.scene.entities.get(0);
+  const pt11 = entity.getPointBySequence(entity.points, 11);
+  expect(pt11.x).toBe(50);
+  expect(pt11.y).toBe(60);
+  // grip editing must leave the entity selected afterwards, unlike most commands
+  expect(core.scene.selectionManager.selectionSet.selectionSet).toContain(0);
+});
+

package/test/tools/offset.test.js

@@ -269,6 +269,7 @@ test('Test Offset.action - offset circle outward', () => {
   expect(newCircle.points[0].y).toBeCloseTo(0);
   // New radius should be 15
   expect(newCircle.getProperty('radius')).toBeCloseTo(15);
+  expect(newCircle.type).toBe('Circle'); // not an Arc
 });
 
 test('Test Offset.action - offset circle inward', () => {
@@ -288,6 +289,7 @@ test('Test Offset.action - offset circle inward', () => {
   expect(newCircle.points[0].x).toBeCloseTo(0);
   expect(newCircle.points[0].y).toBeCloseTo(0);
   expect(newCircle.getProperty('radius')).toBeCloseTo(7);
+  expect(newCircle.type).toBe('Circle'); // not an Arc
 });
 
 test('Test Offset.action - offset circle inward returns null when radius would be zero', () => {

package/test/tools/tool.test.js

@@ -0,0 +1,25 @@
+import { Core } from '../../core/core/core.js';
+import { DesignCore } from '../../core/designCore.js';
+import { Tool } from '../../core/tools/tool.js';
+import { jest } from '@jest/globals';
+
+new Core();
+
+afterEach(() => {
+  jest.restoreAllMocks();
+});
+
+test('Tool.cancel default delegates to inputManager.reset()', () => {
+  const tool = new Tool();
+  const resetSpy = jest.spyOn(DesignCore.Scene.inputManager, 'reset').mockImplementation(() => {});
+
+  tool.cancel();
+
+  expect(resetSpy).toHaveBeenCalledTimes(1);
+});
+
+test('Tool.preview and Tool.action are no-ops by default', () => {
+  const tool = new Tool();
+  expect(() => tool.preview()).not.toThrow();
+  expect(() => tool.action()).not.toThrow();
+});