@design-core/core 0.0.4 → 0.0.5

package/test/entities/circle.test.js

@@ -292,45 +292,35 @@ test('Circle.draw does not throw', () => {
 
 test('Circle.snaps returns centre snap', () => {
   const circle = new Circle({ points: [new Point(0, 0), new Point(10, 0)] });
-  DesignCore.Settings.centresnap = true;
-  DesignCore.Settings.quadrantsnap = false;
-  DesignCore.Settings.nearestsnap = false;
   const snaps = circle.snaps(new Point(5, 0), 100);
-  expect(snaps).toHaveLength(1);
-  expect(snaps[0].x).toBe(0);
-  expect(snaps[0].y).toBe(0);
+  const centreSnaps = snaps.filter((s) => s.type === 'centre');
+  expect(centreSnaps).toHaveLength(1);
+  expect(centreSnaps[0].snapPoint.x).toBe(0);
+  expect(centreSnaps[0].snapPoint.y).toBe(0);
 });
 
 test('Circle.snaps returns four quadrant snaps', () => {
   const circle = new Circle({ points: [new Point(0, 0), new Point(10, 0)] });
-  DesignCore.Settings.centresnap = false;
-  DesignCore.Settings.quadrantsnap = true;
-  DesignCore.Settings.nearestsnap = false;
   const snaps = circle.snaps(new Point(5, 0), 100);
-  expect(snaps).toHaveLength(4);
-  expect(snaps.some((p) => p.x === 10 && p.y === 0)).toBe(true);// 0°
-  expect(snaps.some((p) => p.x === 0 && p.y === 10)).toBe(true);// 90°
-  expect(snaps.some((p) => p.x === -10 && p.y === 0)).toBe(true);// 180°
-  expect(snaps.some((p) => p.x === 0 && p.y === -10)).toBe(true);// 270°
+  const quadrantSnaps = snaps.filter((s) => s.type === 'quadrant');
+  expect(quadrantSnaps).toHaveLength(4);
+  expect(quadrantSnaps.some((p) => p.snapPoint.x === 10 && p.snapPoint.y === 0)).toBe(true);// 0°
+  expect(quadrantSnaps.some((p) => p.snapPoint.x === 0 && p.snapPoint.y === 10)).toBe(true);// 90°
+  expect(quadrantSnaps.some((p) => p.snapPoint.x === -10 && p.snapPoint.y === 0)).toBe(true);// 180°
+  expect(quadrantSnaps.some((p) => p.snapPoint.x === 0 && p.snapPoint.y === -10)).toBe(true);// 270°
 });
 
 test('Circle.snaps nearest snap fires when close enough', () => {
   const circle = new Circle({ points: [new Point(0, 0), new Point(10, 0)] });
-  DesignCore.Settings.centresnap = false;
-  DesignCore.Settings.quadrantsnap = false;
-  DesignCore.Settings.nearestsnap = true;
   // Mouse on the circle surface with large delta
   const snaps = circle.snaps(new Point(10, 0), 1000);
-  expect(snaps.length).toBeGreaterThanOrEqual(1);
+  expect(snaps.filter((s) => s.type === 'nearest').length).toBeGreaterThanOrEqual(1);
 });
 
 test('Circle.snaps nearest snap does not fire when too far', () => {
   const circle = new Circle({ points: [new Point(0, 0), new Point(10, 0)] });
-  DesignCore.Settings.centresnap = false;
-  DesignCore.Settings.quadrantsnap = false;
-  DesignCore.Settings.nearestsnap = true;
   const snaps = circle.snaps(new Point(100, 100), 1);
-  expect(snaps.length).toBe(0);
+  expect(snaps.filter((s) => s.type === 'nearest').length).toBe(0);
 });
 
 test('Circle.fromPolylinePoints round-trip preserves centre and radius', () => {
@@ -352,3 +342,39 @@ test('Circle.fromPolylinePoints precision drift is negligible', () => {
   expect(drift).toBeLessThan(1e-10);
   expect(Math.abs(rebuilt.radius - circle.radius)).toBeLessThan(1e-10);
 });
+
+test('Circle.snaps returns two tangent snaps from outside', () => {
+  const circle = new Circle({ points: [new Point(0, 0), new Point(10, 0)] });
+  const savedInputPoint = DesignCore.Scene.inputManager.inputPoint;
+  // fromPoint=(20,0): distanceToCenter=20 > radius=10
+  // tangentHalfAngle = acos(10/20) = π/3; both tangent points at (5, ±8.66) are on the full circle
+  DesignCore.Scene.inputManager.inputPoint = new Point(20, 0);
+  const snaps = circle.snaps(new Point(5, 0), 100);
+  const tangentSnaps = snaps.filter((s) => s.type === 'tangent');
+  expect(tangentSnaps.length).toBe(2);
+  expect(tangentSnaps.some((s) => s.snapPoint.x > 4.9 && s.snapPoint.y > 8.5)).toBe(true);
+  expect(tangentSnaps.some((s) => s.snapPoint.x > 4.9 && s.snapPoint.y < -8.5)).toBe(true);
+  DesignCore.Scene.inputManager.inputPoint = savedInputPoint;
+});
+
+test('Circle.snaps returns no tangent when fromPoint is inside the circle', () => {
+  const circle = new Circle({ points: [new Point(0, 0), new Point(10, 0)] });
+  const savedInputPoint = DesignCore.Scene.inputManager.inputPoint;
+  DesignCore.Scene.inputManager.inputPoint = new Point(1, 1); // distanceToCenter ≈ 1.41 < radius 10
+  const snaps = circle.snaps(new Point(5, 0), 100);
+  expect(snaps.filter((s) => s.type === 'tangent').length).toBe(0);
+  DesignCore.Scene.inputManager.inputPoint = savedInputPoint;
+});
+
+test('Circle.snaps returns perpendicular snap from outside', () => {
+  const circle = new Circle({ points: [new Point(0, 0), new Point(10, 0)] });
+  const savedInputPoint = DesignCore.Scene.inputManager.inputPoint;
+  // fromPoint=(20,0): angleFromCentreToInput=0; perpendicularPoint=(10,0)
+  DesignCore.Scene.inputManager.inputPoint = new Point(20, 0);
+  const snaps = circle.snaps(new Point(5, 0), 100);
+  const perpSnaps = snaps.filter((s) => s.type === 'perpendicular');
+  expect(perpSnaps.length).toBe(1);
+  expect(perpSnaps[0].snapPoint.x).toBeCloseTo(10);
+  expect(perpSnaps[0].snapPoint.y).toBeCloseTo(0);
+  DesignCore.Scene.inputManager.inputPoint = savedInputPoint;
+});

package/test/entities/insert.test.js

@@ -19,13 +19,15 @@ rotatedInsert.block.addItem(line);
 test('Test Insert.snaps', () => {
   const point = new Point(100, 100);
   const snaps = insert.snaps(point, 1);
-  expect(snaps[0].x).toBeCloseTo(101);
-  expect(snaps[0].y).toBeCloseTo(102);
+  const endSnaps = snaps.filter((s) => s.type === 'end');
+  expect(endSnaps[0].snapPoint.x).toBeCloseTo(101);
+  expect(endSnaps[0].snapPoint.y).toBeCloseTo(102);
 
   // Test snaps for a rotated block
   const rotatedSnaps = rotatedInsert.snaps(point);
-  expect(rotatedSnaps[0].x).toBeCloseTo(-0.7071);
-  expect(rotatedSnaps[0].y).toBeCloseTo(143.5426);
+  const rotatedEndSnaps = rotatedSnaps.filter((s) => s.type === 'end');
+  expect(rotatedEndSnaps[0].snapPoint.x).toBeCloseTo(-0.7071);
+  expect(rotatedEndSnaps[0].snapPoint.y).toBeCloseTo(143.5426);
 });
 
 test('Test Insert.closestPoint', () => {
@@ -88,3 +90,11 @@ AcDbBlockReference
   newInsert.dxf(file);
   expect(file.contents).toEqual(dxfString);
 });
+
+test('Insert.snaps returns a node snap at points[0]', () => {
+  const nodeInsert = new Insert({ points: [new Point(5, 10)] });
+  const nodeSnaps = nodeInsert.snaps(new Point(0, 0), 100).filter((s) => s.type === 'node');
+  expect(nodeSnaps.length).toBe(1);
+  expect(nodeSnaps[0].snapPoint.x).toBe(5);
+  expect(nodeSnaps[0].snapPoint.y).toBe(10);
+});

package/test/entities/line.test.js

@@ -201,3 +201,56 @@ test('Line.fromPolylinePoints round-trip preserves points exactly', () => {
   expect(rebuilt.points[1].x).toBe(15);
   expect(rebuilt.points[1].y).toBe(-4);
 });
+
+test('Line.snaps returns two end snaps at both endpoints', () => {
+  const line = new Line({ points: [new Point(0, 0), new Point(10, 0)] });
+  const endSnaps = line.snaps(new Point(5, 0), 100).filter((s) => s.type === 'end');
+  expect(endSnaps.length).toBe(2);
+  expect(endSnaps.some((s) => s.snapPoint.x === 0 && s.snapPoint.y === 0)).toBe(true);
+  expect(endSnaps.some((s) => s.snapPoint.x === 10 && s.snapPoint.y === 0)).toBe(true);
+});
+
+test('Line.snaps returns mid snap at midpoint', () => {
+  const line = new Line({ points: [new Point(0, 0), new Point(10, 0)] });
+  const midSnaps = line.snaps(new Point(5, 0), 100).filter((s) => s.type === 'mid');
+  expect(midSnaps.length).toBe(1);
+  expect(midSnaps[0].snapPoint.x).toBe(5);
+  expect(midSnaps[0].snapPoint.y).toBe(0);
+});
+
+test('Line.snaps nearest fires when mouse is close to the line', () => {
+  const line = new Line({ points: [new Point(0, 0), new Point(10, 0)] });
+  // mouse at (5, 0.5): distance to line = 0.5; delta=10 so delta/10=1; 0.5 < 1 → fires
+  const snaps = line.snaps(new Point(5, 0.5), 10);
+  expect(snaps.filter((s) => s.type === 'nearest').length).toBe(1);
+});
+
+test('Line.snaps nearest does not fire when mouse is too far from the line', () => {
+  const line = new Line({ points: [new Point(0, 0), new Point(10, 0)] });
+  // mouse at (5, 20): distance to line = 20; delta=1 so delta/10=0.1; 20 > 0.1 → no fire
+  const snaps = line.snaps(new Point(5, 20), 1);
+  expect(snaps.filter((s) => s.type === 'nearest').length).toBe(0);
+});
+
+test('Line.snaps perpendicular fires when foot falls on the segment', () => {
+  const line = new Line({ points: [new Point(0, 0), new Point(10, 0)] });
+  const savedInputPoint = DesignCore.Scene.inputManager.inputPoint;
+  // fromPoint=(5,5): foot of perpendicular = (5,0), which IS on the segment
+  DesignCore.Scene.inputManager.inputPoint = new Point(5, 5);
+  const snaps = line.snaps(new Point(5, 0), 100);
+  const perpSnaps = snaps.filter((s) => s.type === 'perpendicular');
+  expect(perpSnaps.length).toBe(1);
+  expect(perpSnaps[0].snapPoint.x).toBeCloseTo(5);
+  expect(perpSnaps[0].snapPoint.y).toBeCloseTo(0);
+  DesignCore.Scene.inputManager.inputPoint = savedInputPoint;
+});
+
+test('Line.snaps perpendicular does not fire when foot falls off the segment', () => {
+  const line = new Line({ points: [new Point(0, 0), new Point(10, 0)] });
+  const savedInputPoint = DesignCore.Scene.inputManager.inputPoint;
+  // fromPoint=(20,5): foot = (20,0), which is BEYOND the segment end at (10,0)
+  DesignCore.Scene.inputManager.inputPoint = new Point(20, 5);
+  const snaps = line.snaps(new Point(5, 0), 100);
+  expect(snaps.filter((s) => s.type === 'perpendicular').length).toBe(0);
+  DesignCore.Scene.inputManager.inputPoint = savedInputPoint;
+});

package/test/entities/text.test.js

@@ -535,7 +535,8 @@ test('Text snaps returns all snap points', () => {
   const t = new Text({ points: [new Point(1, 2)] });
   t.boundingRect = { width: 10, height: 10 };
   const snaps = t.snaps(new Point(0, 0), 1);
-  expect(snaps.length).toBe(5);
+  expect(snaps.length).toBe(1);
+  expect(snaps[0].type).toBe('node');
 });
 
 test('Text closestPoint returns correct distance', () => {
@@ -630,3 +631,11 @@ test('Text.execute does not create entity for empty string', async () => {
 
   expect(executeCommandCalled).toBe(false);
 });
+
+test('Text.snaps node snap position matches points[0]', () => {
+  const t = new Text({ points: [new Point(5, 10)] });
+  const nodeSnaps = t.snaps(new Point(0, 0), 100).filter((s) => s.type === 'node');
+  expect(nodeSnaps.length).toBe(1);
+  expect(nodeSnaps[0].snapPoint.x).toBe(5);
+  expect(nodeSnaps[0].snapPoint.y).toBe(10);
+});

package/test/lib/input.test.js

@@ -0,0 +1,117 @@
+import { Input, MouseDown, MouseUp } from '../../core/lib/inputManager.js';
+import { Point } from '../../core/entities/point.js';
+import { SingleSelection, SelectionSet } from '../../core/lib/selectionManager.js';
+import { expect } from '@jest/globals';
+
+// Stub classes that simulate what terser does in a production build:
+// constructor.name is mangled to a single letter but static type is preserved.
+
+/** Stub simulating a minified class resolved as Point. */
+class MangledPoint {
+  static type = 'Point';
+}
+
+/** Stub simulating a minified class resolved as SingleSelection. */
+class MangledSingleSelection {
+  static type = 'SingleSelection';
+}
+
+/** Stub simulating a minified class resolved as SelectionSet. */
+class MangledSelectionSet {
+  static type = 'SelectionSet';
+}
+
+/** Stub simulating a minified class resolved as MouseDown. */
+class MangledMouseDown {
+  static type = 'MouseDown';
+}
+
+/** Stub simulating a minified class resolved as MouseUp. */
+class MangledMouseUp {
+  static type = 'MouseUp';
+}
+
+/** Stub with no static type and an unrecognised constructor.name. */
+class UnknownStub {}
+
+// ─── Input.Type ───────────────────────────────────────────────────────────────
+
+test('Input.Type contains all expected type entries', () => {
+  const keys = Object.keys(Input.Type);
+  expect(keys).toContain('POINT');
+  expect(keys).toContain('SELECTIONSET');
+  expect(keys).toContain('SINGLESELECTION');
+  expect(keys).toContain('NUMBER');
+  expect(keys).toContain('STRING');
+  expect(keys).toContain('DYNAMIC');
+  expect(keys).toContain('MOUSEDOWN');
+  expect(keys).toContain('MOUSEUP');
+});
+
+// ─── Input.getType — undefined ────────────────────────────────────────────────
+
+test('Input.getType returns undefined for undefined input', () => {
+  expect(Input.getType(undefined)).toBeUndefined();
+});
+
+// ─── Input.getType — constructor.name path (dev / unminified) ─────────────────
+
+test('Input.getType resolves Point via constructor.name', () => {
+  expect(Input.getType(new Point(1, 2))).toBe(Input.Type.POINT);
+});
+
+test('Input.getType resolves SingleSelection via constructor.name', () => {
+  expect(Input.getType(new SingleSelection(0, new Point(0, 0)))).toBe(Input.Type.SINGLESELECTION);
+});
+
+test('Input.getType resolves SelectionSet via constructor.name', () => {
+  expect(Input.getType(new SelectionSet())).toBe(Input.Type.SELECTIONSET);
+});
+
+test('Input.getType resolves MouseDown via constructor.name', () => {
+  expect(Input.getType(new MouseDown())).toBe(Input.Type.MOUSEDOWN);
+});
+
+test('Input.getType resolves MouseUp via constructor.name', () => {
+  expect(Input.getType(new MouseUp())).toBe(Input.Type.MOUSEUP);
+});
+
+test('Input.getType resolves Number via constructor.name', () => {
+  expect(Input.getType(42)).toBe(Input.Type.NUMBER);
+});
+
+test('Input.getType resolves String via constructor.name', () => {
+  expect(Input.getType('hello')).toBe(Input.Type.STRING);
+});
+
+// ─── Input.getType — static type path (minified / production) ─────────────────
+
+test('Input.getType resolves via static type when constructor.name is mangled (Point)', () => {
+  expect(Input.getType(new MangledPoint())).toBe(Input.Type.POINT);
+});
+
+test('Input.getType resolves via static type when constructor.name is mangled (SingleSelection)', () => {
+  expect(Input.getType(new MangledSingleSelection())).toBe(Input.Type.SINGLESELECTION);
+});
+
+test('Input.getType resolves via static type when constructor.name is mangled (SelectionSet)', () => {
+  expect(Input.getType(new MangledSelectionSet())).toBe(Input.Type.SELECTIONSET);
+});
+
+test('Input.getType resolves via static type when constructor.name is mangled (MouseDown)', () => {
+  expect(Input.getType(new MangledMouseDown())).toBe(Input.Type.MOUSEDOWN);
+});
+
+test('Input.getType resolves via static type when constructor.name is mangled (MouseUp)', () => {
+  expect(Input.getType(new MangledMouseUp())).toBe(Input.Type.MOUSEUP);
+});
+
+// ─── Input.getType — no match ─────────────────────────────────────────────────
+
+test('Input.getType returns undefined when neither static type nor constructor.name matches', () => {
+  expect(Input.getType(new UnknownStub())).toBeUndefined();
+});
+
+test('Input.getType returns undefined for a plain object', () => {
+  expect(Input.getType({})).toBeUndefined();
+});

package/test/lib/settings.test.js

@@ -41,10 +41,8 @@ test('Settings constructor - colour defaults', () => {
   const fresh = new (settings.constructor)();
   expect(fresh.canvasbackgroundcolour).toEqual({ r: 30, g: 30, b: 30 });
   expect(fresh.selecteditemscolour).toEqual({ r: 0, g: 255, b: 0 });
-  expect(fresh.snapcolour).toEqual({ r: 255, g: 0, b: 0 });
+  expect(fresh.snaptrackingcolour).toEqual({ r: 55, g: 180, b: 75 });
   expect(fresh.gridcolour).toEqual({ r: 119, g: 118, b: 123 });
-  expect(fresh.helpergeometrycolour).toEqual({ r: 0, g: 195, b: 255 });
-  expect(fresh.polarsnapcolour).toEqual({ r: 55, g: 180, b: 75 });
   expect(fresh.selectionWindow).toEqual({ r: 0, g: 255, b: 0 });
   expect(fresh.crossingWindow).toEqual({ r: 0, g: 0, b: 255 });
 });
@@ -84,9 +82,9 @@ test('setSetting with false value does not trigger polar/ortho exclusion', () =>
 });
 
 test('setSetting updates arbitrary colour settings', () => {
-  settings.setSetting('polarsnapcolour', { r: 1, g: 2, b: 3 });
-  expect(settings.polarsnapcolour).toEqual({ r: 1, g: 2, b: 3 });
-  settings.setSetting('polarsnapcolour', { r: 55, g: 180, b: 75 });
+  settings.setSetting('snaptrackingcolour', { r: 1, g: 2, b: 3 });
+  expect(settings.snaptrackingcolour).toEqual({ r: 1, g: 2, b: 3 });
+  settings.setSetting('snaptrackingcolour', { r: 55, g: 180, b: 75 });
 });
 
 test('setSetting updates polarangle', () => {
@@ -118,7 +116,7 @@ test('getSetting returns current value after setSetting', () => {
 });
 
 test('getSetting returns correct type for colour objects', () => {
-  const colour = settings.getSetting('snapcolour');
+  const colour = settings.getSetting('snaptrackingcolour');
   expect(colour).toHaveProperty('r');
   expect(colour).toHaveProperty('g');
   expect(colour).toHaveProperty('b');

package/test/lib/snapping.test.js

@@ -1,6 +1,6 @@
 import { jest } from '@jest/globals';
 import { Core } from '../../core/core/core.js';
-import { Snapping } from '../../core/lib/snapping.js';
+import { Snapping, SnapPoint } from '../../core/lib/snapping.js';
 import { Point } from '../../core/entities/point.js';
 import { DesignCore } from '../../core/designCore.js';
 
@@ -24,16 +24,16 @@ test('Test Snapping.getSnapPoint', () => {
   core.mouse.mouseMoved(8, 8);
   // Get the snap point
   const snapPoint1 = snapping.getSnapPoint();
-  expect(snapPoint1.x).toBe(10);
-  expect(snapPoint1.y).toBe(10);
+  expect(snapPoint1.snapPoint.x).toBe(10);
+  expect(snapPoint1.snapPoint.y).toBe(10);
 
 
   // set the mouse position
   core.mouse.mouseMoved(101, 11);
   // Get the snap point
   const snapPoint2 = snapping.getSnapPoint();
-  expect(snapPoint2.x).toBe(100);
-  expect(snapPoint2.y).toBe(10);
+  expect(snapPoint2.snapPoint.x).toBe(100);
+  expect(snapPoint2.snapPoint.y).toBe(10);
 
   // set the mouse position
   core.mouse.mouseMoved(100, 100);
@@ -48,8 +48,8 @@ test('Test Snapping.snap active', () => {
   core.mouse.mouseMoved(8, 8);
   const result = snapping.snap();
   expect(result).toBeDefined();
-  expect(result.x).toBe(10);
-  expect(result.y).toBe(10);
+  expect(result.snapPoint.x).toBe(10);
+  expect(result.snapPoint.y).toBe(10);
   expect(DesignCore.Scene.auxiliaryEntities.count()).toBeGreaterThan(0);
 });
 
@@ -61,24 +61,29 @@ test('Test Snapping.snap inactive', () => {
 
 test('Test Snapping.addSnapPoint', () => {
   DesignCore.Scene.auxiliaryEntities.clear();
-  snapping.addSnapPoint(new Point(10, 10));
+  snapping.addSnapPoint(new SnapPoint(new Point(10, 10)));
   expect(DesignCore.Scene.auxiliaryEntities.count()).toBe(1);
 });
 
 test('Test SnapPoint.draw', () => {
   DesignCore.Scene.auxiliaryEntities.clear();
-  snapping.addSnapPoint(new Point(0.5, 0.5));
+  snapping.addSnapPoint(new SnapPoint(new Point(0.5, 0.5), SnapPoint.Type.CENTRE));
   const snapPointEntity = DesignCore.Scene.auxiliaryEntities.get(0);
   const ctx = {
-    fillStyle: '',
+    strokeStyle: '',
+    lineWidth: 0,
+    setLineDash: jest.fn(),
     beginPath: jest.fn(),
+    moveTo: jest.fn(),
+    lineTo: jest.fn(),
+    closePath: jest.fn(),
     arc: jest.fn(),
-    fill: jest.fn(),
+    stroke: jest.fn(),
   };
   snapPointEntity.draw(ctx, 1);
   expect(ctx.beginPath).toHaveBeenCalled();
   expect(ctx.arc).toHaveBeenCalledWith(0.5, 0.5, expect.any(Number), 0, 6.283);
-  expect(ctx.fill).toHaveBeenCalled();
+  expect(ctx.stroke).toHaveBeenCalled();
 });
 
 test('Test Snapping.addTrackingLine', () => {
@@ -193,3 +198,204 @@ test('Test Snapping.orthoSnap', () => {
   core.mouse.mouseMoved(100, -20);
   expect(snapping.orthoSnap(new Point(0, 0))).toBeUndefined();
 });
+
+// ─── Context mock helpers ────────────────────────────────────────────────────
+
+/** @return {object} mock HTML canvas context for SnapPoint.draw tests */
+function makeSnapCtx() {
+  return {
+    strokeStyle: '',
+    lineWidth: 0,
+    setLineDash: jest.fn(),
+    beginPath: jest.fn(),
+    moveTo: jest.fn(),
+    lineTo: jest.fn(),
+    closePath: jest.fn(),
+    arc: jest.fn(),
+    stroke: jest.fn(),
+  };
+}
+
+/** @return {object} mock HTML canvas context for TrackingLine.draw tests */
+function makeTrackingCtx() {
+  return {
+    save: jest.fn(),
+    restore: jest.fn(),
+    beginPath: jest.fn(),
+    strokeStyle: '',
+    lineWidth: 0,
+    setLineDash: jest.fn(),
+    moveTo: jest.fn(),
+    lineTo: jest.fn(),
+    stroke: jest.fn(),
+  };
+}
+
+// ─── Snapping.reset ──────────────────────────────────────────────────────────
+
+test('Test Snapping.reset', () => {
+  snapping.active = true;
+  snapping.snapOverride = SnapPoint.Type.END;
+  snapping.reset();
+  expect(snapping.active).toBe(false);
+  expect(snapping.snapOverride).toBeNull();
+});
+
+// ─── Snapping.setSnapOverride ────────────────────────────────────────────────
+
+test('Test Snapping.setSnapOverride valid type', () => {
+  snapping.setSnapOverride(SnapPoint.Type.END);
+  expect(snapping.snapOverride).toBe(SnapPoint.Type.END);
+});
+
+test('Test Snapping.setSnapOverride null clears override', () => {
+  snapping.setSnapOverride(SnapPoint.Type.END);
+  snapping.setSnapOverride(null);
+  expect(snapping.snapOverride).toBeNull();
+});
+
+test('Test Snapping.setSnapOverride NONE type', () => {
+  snapping.setSnapOverride(SnapPoint.Type.NONE);
+  expect(snapping.snapOverride).toBe(SnapPoint.Type.NONE);
+  snapping.setSnapOverride(null);
+});
+
+test('Test Snapping.setSnapOverride invalid type throws', () => {
+  expect(() => snapping.setSnapOverride('invalid')).toThrow('Invalid snap override type: invalid');
+});
+
+// ─── Snapping.getSnapPoint with snap override ────────────────────────────────
+
+test('Test Snapping.getSnapPoint with END override returns end snap', () => {
+  snapping.setSnapOverride(SnapPoint.Type.END);
+  core.mouse.mouseMoved(8, 8);
+  const result = snapping.getSnapPoint();
+  expect(result).toBeDefined();
+  expect(result.type).toBe(SnapPoint.Type.END);
+  snapping.setSnapOverride(null);
+});
+
+test('Test Snapping.getSnapPoint with NONE override suppresses all snaps', () => {
+  snapping.setSnapOverride(SnapPoint.Type.NONE);
+  core.mouse.mouseMoved(8, 8);
+  const result = snapping.getSnapPoint();
+  expect(result).toBeUndefined();
+  snapping.setSnapOverride(null);
+});
+
+test('Test Snapping.getSnapPoint with non-matching override returns undefined', () => {
+  // Mouse near end of line at (10,10); mid-point is at (55,10), well outside aperture
+  snapping.setSnapOverride(SnapPoint.Type.MID);
+  core.mouse.mouseMoved(8, 8);
+  const result = snapping.getSnapPoint();
+  expect(result).toBeUndefined();
+  snapping.setSnapOverride(null);
+});
+
+// ─── SnapPoint.draw – all snap types ────────────────────────────────────────
+
+test('Test SnapPoint.draw END type draws closed polygon without arc', () => {
+  const sp = new SnapPoint(new Point(5, 5), SnapPoint.Type.END);
+  const ctx = makeSnapCtx();
+  sp.draw(ctx, 1);
+  expect(ctx.beginPath).toHaveBeenCalled();
+  expect(ctx.closePath).toHaveBeenCalled();
+  expect(ctx.stroke).toHaveBeenCalled();
+  expect(ctx.arc).not.toHaveBeenCalled();
+});
+
+test('Test SnapPoint.draw MID type draws closed polygon without arc', () => {
+  const sp = new SnapPoint(new Point(5, 5), SnapPoint.Type.MID);
+  const ctx = makeSnapCtx();
+  sp.draw(ctx, 1);
+  expect(ctx.beginPath).toHaveBeenCalled();
+  expect(ctx.closePath).toHaveBeenCalled();
+  expect(ctx.stroke).toHaveBeenCalled();
+  expect(ctx.arc).not.toHaveBeenCalled();
+});
+
+test('Test SnapPoint.draw QUADRANT type draws closed polygon without arc', () => {
+  const sp = new SnapPoint(new Point(5, 5), SnapPoint.Type.QUADRANT);
+  const ctx = makeSnapCtx();
+  sp.draw(ctx, 1);
+  expect(ctx.beginPath).toHaveBeenCalled();
+  expect(ctx.closePath).toHaveBeenCalled();
+  expect(ctx.stroke).toHaveBeenCalled();
+  expect(ctx.arc).not.toHaveBeenCalled();
+});
+
+test('Test SnapPoint.draw NEAREST type draws closed polygon without arc', () => {
+  const sp = new SnapPoint(new Point(5, 5), SnapPoint.Type.NEAREST);
+  const ctx = makeSnapCtx();
+  sp.draw(ctx, 1);
+  expect(ctx.beginPath).toHaveBeenCalled();
+  expect(ctx.closePath).toHaveBeenCalled();
+  expect(ctx.stroke).toHaveBeenCalled();
+  expect(ctx.arc).not.toHaveBeenCalled();
+});
+
+test('Test SnapPoint.draw TANGENT type draws arc with tangent line', () => {
+  const sp = new SnapPoint(new Point(5, 5), SnapPoint.Type.TANGENT);
+  const ctx = makeSnapCtx();
+  sp.draw(ctx, 1);
+  expect(ctx.beginPath).toHaveBeenCalled();
+  expect(ctx.arc).toHaveBeenCalledWith(5, 5, expect.any(Number), 0, 6.283);
+  expect(ctx.stroke).toHaveBeenCalled();
+  expect(ctx.closePath).not.toHaveBeenCalled();
+});
+
+test('Test SnapPoint.draw NODE type draws arc with X inside', () => {
+  const sp = new SnapPoint(new Point(5, 5), SnapPoint.Type.NODE);
+  const ctx = makeSnapCtx();
+  sp.draw(ctx, 1);
+  expect(ctx.beginPath).toHaveBeenCalled();
+  expect(ctx.arc).toHaveBeenCalledWith(5, 5, expect.any(Number), 0, 6.283);
+  expect(ctx.stroke).toHaveBeenCalled();
+  expect(ctx.closePath).not.toHaveBeenCalled();
+});
+
+test('Test SnapPoint.draw PERPENDICULAR type draws L-shape without arc', () => {
+  const sp = new SnapPoint(new Point(5, 5), SnapPoint.Type.PERPENDICULAR);
+  const ctx = makeSnapCtx();
+  sp.draw(ctx, 1);
+  expect(ctx.beginPath).toHaveBeenCalled();
+  expect(ctx.stroke).toHaveBeenCalled();
+  expect(ctx.closePath).not.toHaveBeenCalled();
+  expect(ctx.arc).not.toHaveBeenCalled();
+});
+
+// ─── TrackingLine.draw – out-of-bounds cases ─────────────────────────────────
+
+test('Test TrackingLine.draw vertical line outside x bounds', () => {
+  DesignCore.Scene.auxiliaryEntities.clear();
+  // dir.x === 0 and from.x = 2 > boundsMax.x = 1 → draw returns early
+  snapping.addTrackingLine(new Point(2, -0.5), new Point(2, 0.5));
+  const trackingLine = DesignCore.Scene.auxiliaryEntities.get(0);
+  const ctx = makeTrackingCtx();
+  trackingLine.draw(ctx, 1);
+  expect(ctx.moveTo).not.toHaveBeenCalled();
+  expect(ctx.stroke).not.toHaveBeenCalled();
+});
+
+test('Test TrackingLine.draw horizontal line outside y bounds', () => {
+  DesignCore.Scene.auxiliaryEntities.clear();
+  // dir.y === 0 and from.y = -5 < boundsMin.y = -1 → draw returns early
+  snapping.addTrackingLine(new Point(0.5, -5), new Point(0.8, -5));
+  const trackingLine = DesignCore.Scene.auxiliaryEntities.get(0);
+  const ctx = makeTrackingCtx();
+  trackingLine.draw(ctx, 1);
+  expect(ctx.moveTo).not.toHaveBeenCalled();
+  expect(ctx.stroke).not.toHaveBeenCalled();
+});
+
+test('Test TrackingLine.draw line does not intersect canvas bounds', () => {
+  DesignCore.Scene.auxiliaryEntities.clear();
+  // from = (2, -0.5), dir = (1, 1): x-clamp gives t ∈ [-2, -1], y-clamp gives t ∈ [-0.5, 0.5]
+  // tMax (-1) < tMin (-0.5) → draw returns early
+  snapping.addTrackingLine(new Point(2, -0.5), new Point(3, 0.5));
+  const trackingLine = DesignCore.Scene.auxiliaryEntities.get(0);
+  const ctx = makeTrackingCtx();
+  trackingLine.draw(ctx, 1);
+  expect(ctx.moveTo).not.toHaveBeenCalled();
+  expect(ctx.stroke).not.toHaveBeenCalled();
+});