signalk-racer 1.1.1 → 1.1.2

package/.claude/settings.local.json

@@ -0,0 +1,11 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(npm test:*)",
+      "Bash(git -C /home/gregw/src/signalk-racer tag -l)",
+      "Bash(git -C /home/gregw/src/signalk-racer log --oneline -5)",
+      "Bash(git -C /home/gregw/src/signalk-racer status -sb)",
+      "Bash(git -C /home/gregw/src/signalk-racer remote -v)"
+    ]
+  }
+}

package/README.md

@@ -189,4 +189,41 @@ npm install
 npm link
 cd ~/.signalk
 npm link signalk-racer
-```
+```
+
+---
+## 🚀 Releasing
+
+Releases are cut manually from a clean `main` checkout and published to npm.
+
+### Pre-flight
+
+1. Confirm `main` is up to date and clean: `git checkout main && git pull && git status`.
+2. Run the test suite: `npm test`.
+3. Review commits since the last release: `git log $(git describe --tags --abbrev=0)..HEAD --oneline`.
+4. Decide the version bump (semver): `patch` for bug fixes, `minor` for features, `major` for breaking changes.
+
+### Cut the release
+
+1. Update `ReleaseNotes.md` — add a new entry at the top with the new version and a short bullet list of changes, then `git add ReleaseNotes.md`.
+2. Bump the version and create the git tag in one step (note the non-default tag prefix so it matches the existing `signalk-racer-X.Y.Z` convention):
+   ```
+   npm version <patch|minor|major> --tag-version-prefix=signalk-racer-
+   ```
+   This rewrites `package.json`, includes any staged files (e.g. `ReleaseNotes.md`) in the bump commit, and creates tag `signalk-racer-X.Y.Z`.
+3. Push the commit and the tag:
+   ```
+   git push origin main
+   git push origin signalk-racer-X.Y.Z
+   ```
+
+### Publish to npm
+
+1. Confirm npm auth: `npm whoami` (login with `npm login` if needed).
+2. Dry-run the publish to inspect the tarball contents: `npm publish --dry-run`.
+3. Publish: `npm publish` (the package is public and unscoped; no `--access` flag needed).
+
+### After release
+
+1. Verify on npm: `npm view signalk-racer version` should report the new version.
+2. (Optional) Create a GitHub release from the new tag with notes copied from `ReleaseNotes.md`.

package/ReleaseNotes.md

@@ -1,3 +1,7 @@
+## 1.1.2 TTL fixes
+ + use a FIFO queue for VMGs towards the line.
+ + avoid undefined values in deltas
+
 ## 1.1.1 Unit tests
 + split into index.js and racing.js for unit testing
 + unit tested TTL 

package/index.js

@@ -196,19 +196,22 @@ module.exports = (app) => {
     });
 
     // send multiple deltas, each in the form of { path, value }
+    // null values are preserved (meaningful in SignalK for clearing a value);
+    // undefined values are dropped to avoid "Delta is missing value" warnings.
     function sendDeltas(updatesArray) {
-        const timestamp = new Date().toISOString();
+        const values = updatesArray
+            .filter(({value}) => value !== undefined)
+            .map(({path, value}) => ({path, value}));
+
+        if (values.length === 0) return;
 
         const delta = {
             context: 'vessels.self',
             updates: [
                 {
                     source: {label: 'signalk-racer'},
-                    timestamp: timestamp,
-                    values: updatesArray.map(({path, value}) => ({
-                        path,
-                        value
-                    }))
+                    timestamp: new Date().toISOString(),
+                    values
                 }
             ]
         };
@@ -812,8 +815,8 @@ module.exports = (app) => {
             if (cog != null && sog != null) {
                 collectVmgSamples(cog, sog, startLine.bearing, toZoneVz, perpToLineVx);
             }
-            const ttl = computeTimeToLine(cog, sog, startLine.bearing, toZoneVz, perpToLineVx, ocs, closestEnd);
-            const ttb = !ocs && state.timerRunning && state.timeToStart > 0 ? (state.timeToStart - ttl) : null;
+            const ttl = computeTimeToLine(cog, sog, startLine.bearing, toZoneVz, perpToLineVx, ocs, closestEnd, state.timeToStart ?? 0);
+            const ttb = !ocs && state.timerRunning && state.timeToStart > 0 && ttl != null ? (state.timeToStart - ttl) : null;
 
             sendDeltas([
                 {path: 'navigation.racing.distanceStartline', value: distanceToLine},

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "signalk-racer",
-  "version": "1.1.1",
+  "version": "1.1.2",
   "description": "Signalk plugin to calculate values of interest to sail racers, such as: Time to Start; Time of Start, Time to Burn; Distance to Line; Next leg TWA.",
   "main": "index.js",
   "repository": {

package/racer.js

@@ -8,27 +8,31 @@ let cfg = {
     percentile: 0.9
 };
 
-let log = { debug: () => {} };
+let log = {
+    debug: () => {
+    }
+};
 
 function initRacer(config = {}, logger = null) {
-    cfg = { ...cfg, ...config };
+    cfg = {...cfg, ...config};
     if (logger?.debug) log = logger;
 }
 
 // VMG sample state is kept private to this module.
-// These arrays are kept sorted ascending.
+// Each entry has a `sorted` array (ascending, for O(1) percentile) and a
+// `queue` array (insertion-order FIFO, for correct oldest-first eviction).
 const vmgState = {
-    vmgToLinePos: [],  // VMG towards the line (not OCS to line)
-    vmgToLineNeg: [],  // VMG away from the line (OCS to line)
-    vmgToZonePort: [], // Motion along the line towards the PORT end (pin)
-    vmgToZoneStb: [],  // Motion along the line towards the STARBOARD end (boat)
+    vmgToLinePos: {sorted: [], queue: []},  // VMG towards the line (not OCS to line)
+    vmgToLineNeg: {sorted: [], queue: []},  // VMG away from the line (OCS to line)
+    vmgToZonePort: {sorted: [], queue: []}, // Motion along the line towards the PORT end (pin)
+    vmgToZoneStb: {sorted: [], queue: []}, // Motion along the line towards the STARBOARD end (boat)
 };
 
 function resetVmgSamples() {
-    vmgState.vmgToLinePos.length = 0;
-    vmgState.vmgToLineNeg.length = 0;
-    vmgState.vmgToZonePort.length = 0;
-    vmgState.vmgToZoneStb.length = 0;
+    for (const vmg of Object.values(vmgState)) {
+        vmg.sorted.length = 0;
+        vmg.queue.length = 0;
+    }
 }
 
 function toDegrees(rad) {
@@ -41,10 +45,10 @@ function toRadians(deg) {
     return deg * (Math.PI / 180);
 }
 
-function percentile(sortedArray, p) {
-    if (!sortedArray || !sortedArray.length) return 0;
-    const idx = Math.floor(p * (sortedArray.length - 1));
-    return sortedArray[idx];
+function percentile(vmg, p) {
+    if (!vmg.sorted.length) return 0;
+    const idx = Math.floor(p * (vmg.sorted.length - 1));
+    return vmg.sorted[idx];
 }
 
 function collectVmgSamples(cog, sog, lineBearing, toZoneVz, perpToLineVx) {
@@ -65,20 +69,36 @@ function collectVmgSamples(cog, sog, lineBearing, toZoneVz, perpToLineVx) {
     insertSample(vmgState.vmgToZoneStb, -vmgTangent);
 }
 
-function insertSample(arr, value) {
-    if (value <= 1.0) return; // reject low VMGs
-    if (arr.length >= cfg.maxSamples) arr.shift(); // Keep up to 10 minutes at 1Hz
-
-    let lo = 0, hi = arr.length;
+function insertSample(vmg, value) {
+    if (value <= 1.0)
+        return; // reject low VMGs
+    if (vmg.queue.length >= cfg.maxSamples) {
+        const oldest = vmg.queue.shift(); // evict oldest from FIFO
+        // remove oldest from sorted (binary search)
+        let lo = 0, hi = vmg.sorted.length;
+        while (lo < hi) {
+            const mid = (lo + hi) >> 1;
+            if (vmg.sorted[mid] < oldest)
+                lo = mid + 1;
+            else
+                hi = mid;
+        }
+        vmg.sorted.splice(lo, 1);
+    }
+    // insert value into sorted (binary search)
+    let lo = 0, hi = vmg.sorted.length;
     while (lo < hi) {
         const mid = (lo + hi) >> 1;
-        if (arr[mid] < value) lo = mid + 1;
-        else hi = mid;
+        if (vmg.sorted[mid] < value)
+            lo = mid + 1;
+        else
+            hi = mid;
     }
-    arr.splice(lo, 0, value);
+    vmg.sorted.splice(lo, 0, value);
+    vmg.queue.push(value);
 }
 
-function computeTimeToLine(cog, sog, lineBearing, toZoneVz, perpToLineVx, ocs, closestEnd) {
+function computeTimeToLine(cog, sog, lineBearing, toZoneVz, perpToLineVx, ocs, closestEnd, timeToStart = 0) {
     let vmgNormalSigned = 0;
     let vmgTangentSigned = 0;
 
@@ -146,7 +166,7 @@ function computeTimeToLine(cog, sog, lineBearing, toZoneVz, perpToLineVx, ocs, c
     }
 
     // If we still somehow have zero (no speed or distances), just return time to start so TTB logic doesn't explode.
-    return ttl <= 0 ? vmgState.timeToStart : ttl;
+    return ttl <= 0 ? timeToStart : ttl;
 }
 
 module.exports = {

package/tests/racer-maths.test.js

@@ -24,12 +24,13 @@ describe('racer math', () => {
         expect(toRadians(undefined)).toBeNull();
     });
     test('percentile: test maths', () => {
-        expect(_percentile([], 0.5)).toBe(0);
-        expect(_percentile([10], 0.5)).toBe(10);
-        expect(_percentile([10, 20, 30], 0)).toBe(10);
-        expect(_percentile([10, 20, 30], 0.5)).toBe(20);
-        expect(_percentile([10, 20, 30], 0.9)).toBe(20);
-        expect(_percentile([10, 20, 30], 1)).toBe(30);
-        expect(_percentile([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 0.75)).toBe(7);
+        const vmg = (arr) => ({ sorted: arr, queue: [] });
+        expect(_percentile(vmg([]), 0.5)).toBe(0);
+        expect(_percentile(vmg([10]), 0.5)).toBe(10);
+        expect(_percentile(vmg([10, 20, 30]), 0)).toBe(10);
+        expect(_percentile(vmg([10, 20, 30]), 0.5)).toBe(20);
+        expect(_percentile(vmg([10, 20, 30]), 0.9)).toBe(20);
+        expect(_percentile(vmg([10, 20, 30]), 1)).toBe(30);
+        expect(_percentile(vmg([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]), 0.75)).toBe(7);
     })
 });

package/tests/racer-ttl.test.js

@@ -14,15 +14,18 @@ describe('racer ttl', () => {
     test('timeToLineNoVMG: no VMG', () => {
         resetVmgSamples();
         expect(computeTimeToLine(toRadians(0), 10, 270, 0, 100, false, 'stb')).toBeCloseTo(10);
-        expect(computeTimeToLine(toRadians(0), 10, 270, 100, 0, false, 'stb')).toBeUndefined();
+        // Fallback: ttl computed as 0, so returns the supplied timeToStart.
+        expect(computeTimeToLine(toRadians(0), 10, 270, 100, 0, false, 'stb', 300)).toBe(300);
+        // Default timeToStart parameter is 0.
+        expect(computeTimeToLine(toRadians(0), 10, 270, 100, 0, false, 'stb')).toBe(0);
     });
 
     test('timeToLineSmallVmg: small VMG', () => {
         resetVmgSamples();
-        _vmgState.vmgToLinePos.push(1, 1, 1);
-        _vmgState.vmgToLineNeg.push(2, 2, 2);
-        _vmgState.vmgToZonePort.push(1, 1, 1);
-        _vmgState.vmgToZoneStb.push(2, 2, 2);
+        _vmgState.vmgToLinePos.sorted.push(1, 1, 1);
+        _vmgState.vmgToLineNeg.sorted.push(2, 2, 2);
+        _vmgState.vmgToZonePort.sorted.push(1, 1, 1);
+        _vmgState.vmgToZoneStb.sorted.push(2, 2, 2);
 
         expect(computeTimeToLine(toRadians(-1), 10, 270, 0, 100, false, 'stb')).toBeCloseTo(10);
         expect(computeTimeToLine(toRadians(0), 10, 270, 100, 0, false, 'stb')).toBeCloseTo(100);
@@ -59,10 +62,10 @@ describe('racer ttl', () => {
 
     test('timeToLineSmallInstant: small instant', () => {
         resetVmgSamples();
-        _vmgState.vmgToLinePos.push(10, 10, 10, 10, 10, 10, 10, 10, 10, 15);
-        _vmgState.vmgToLineNeg.push(20, 20, 20, 20, 20, 20, 20, 20, 20, 25);
-        _vmgState.vmgToZonePort.push(10, 10, 10, 10, 10, 10, 10, 10, 10, 15);
-        _vmgState.vmgToZoneStb.push(20, 20, 20, 20, 20, 20, 20, 20, 20, 25);
+        _vmgState.vmgToLinePos.sorted.push(10, 10, 10, 10, 10, 10, 10, 10, 10, 15);
+        _vmgState.vmgToLineNeg.sorted.push(20, 20, 20, 20, 20, 20, 20, 20, 20, 25);
+        _vmgState.vmgToZonePort.sorted.push(10, 10, 10, 10, 10, 10, 10, 10, 10, 15);
+        _vmgState.vmgToZoneStb.sorted.push(20, 20, 20, 20, 20, 20, 20, 20, 20, 25);
 
         expect(computeTimeToLine(toRadians(-1), 1, 270, 0, 100, false, 'stb')).toBeCloseTo(10);
         expect(computeTimeToLine(toRadians(0), 1, 270, 100, 0, false, 'stb')).toBeCloseTo(10);

package/tests/racer-vmg.test.js

@@ -11,154 +11,158 @@ const {
 
 describe('racer vmg', () => {
     test('resetVmgSamples: test arrays are cleared', () => {
-        _vmgState.vmgToLinePos.push(1, 2, 3);
-        _vmgState.vmgToLineNeg.push(4, 5, 6);
-        _vmgState.vmgToZonePort.push(7, 8, 9);
-        _vmgState.vmgToZoneStb.push(10, 11, 12);
-        expect(_vmgState.vmgToLinePos.length).toBe(3);
-        expect(_vmgState.vmgToLineNeg.length).toBe(3);
-        expect(_vmgState.vmgToZonePort.length).toBe(3);
-        expect(_vmgState.vmgToZoneStb.length).toBe(3);
+        _vmgState.vmgToLinePos.sorted.push(1, 2, 3);
+        _vmgState.vmgToLinePos.queue.push(1, 2, 3);
+        _vmgState.vmgToLineNeg.sorted.push(4, 5, 6);
+        _vmgState.vmgToLineNeg.queue.push(4, 5, 6);
+        _vmgState.vmgToZonePort.sorted.push(7, 8, 9);
+        _vmgState.vmgToZonePort.queue.push(7, 8, 9);
+        _vmgState.vmgToZoneStb.sorted.push(10, 11, 12);
+        _vmgState.vmgToZoneStb.queue.push(10, 11, 12);
+        expect(_vmgState.vmgToLinePos.sorted.length).toBe(3);
+        expect(_vmgState.vmgToLineNeg.sorted.length).toBe(3);
+        expect(_vmgState.vmgToZonePort.sorted.length).toBe(3);
+        expect(_vmgState.vmgToZoneStb.sorted.length).toBe(3);
         resetVmgSamples();
-        expect(_vmgState.vmgToLinePos.length).toBe(0);
-        expect(_vmgState.vmgToLineNeg.length).toBe(0);
-        expect(_vmgState.vmgToZonePort.length).toBe(0);
-        expect(_vmgState.vmgToZoneStb.length).toBe(0);
+        expect(_vmgState.vmgToLinePos.sorted.length).toBe(0);
+        expect(_vmgState.vmgToLineNeg.sorted.length).toBe(0);
+        expect(_vmgState.vmgToZonePort.sorted.length).toBe(0);
+        expect(_vmgState.vmgToZoneStb.sorted.length).toBe(0);
     });
 
 
     test('collectVmgSamplesEastWestNarrow: test east west line, with perpendicular and narrow approaches', () => {
         resetVmgSamples();
         collectVmgSamples(toRadians(0), 19.7, 270, 0, 0);
-        expect(_vmgState.vmgToLinePos.length).toBe(1);
-        expect(_vmgState.vmgToLinePos[0]).toBeCloseTo(19.7);
-        expect(_vmgState.vmgToLineNeg.length).toBe(0);
-        expect(_vmgState.vmgToZonePort.length).toBe(0);
-        expect(_vmgState.vmgToZoneStb.length).toBe(0);
+        expect(_vmgState.vmgToLinePos.sorted.length).toBe(1);
+        expect(_vmgState.vmgToLinePos.sorted[0]).toBeCloseTo(19.7);
+        expect(_vmgState.vmgToLineNeg.sorted.length).toBe(0);
+        expect(_vmgState.vmgToZonePort.sorted.length).toBe(0);
+        expect(_vmgState.vmgToZoneStb.sorted.length).toBe(0);
 
         collectVmgSamples(toRadians(8.21), 19.7, 270, 0, 0);
-        expect(_vmgState.vmgToLinePos.length).toBe(2);
-        expect(_vmgState.vmgToLinePos[0]).toBeCloseTo(19.5);
-        expect(_vmgState.vmgToLinePos[1]).toBeCloseTo(19.7);
-        expect(_vmgState.vmgToLineNeg.length).toBe(0);
-        expect(_vmgState.vmgToZonePort.length).toBe(0);
-        expect(_vmgState.vmgToZoneStb.length).toBe(1);
-        expect(_vmgState.vmgToZoneStb[0]).toBeCloseTo(2.81);
+        expect(_vmgState.vmgToLinePos.sorted.length).toBe(2);
+        expect(_vmgState.vmgToLinePos.sorted[0]).toBeCloseTo(19.5);
+        expect(_vmgState.vmgToLinePos.sorted[1]).toBeCloseTo(19.7);
+        expect(_vmgState.vmgToLineNeg.sorted.length).toBe(0);
+        expect(_vmgState.vmgToZonePort.sorted.length).toBe(0);
+        expect(_vmgState.vmgToZoneStb.sorted.length).toBe(1);
+        expect(_vmgState.vmgToZoneStb.sorted[0]).toBeCloseTo(2.81);
     });
 
 
     test('collectVmgSamplesEastWest: test east west line with circle', () => {
         resetVmgSamples();
         collectVmgSamples(toRadians(0), 5, 270, 0, 0);
-        expect(_vmgState.vmgToLinePos.length).toBe(1);
-        expect(_vmgState.vmgToLinePos[0]).toBe(5);
-        expect(_vmgState.vmgToLineNeg.length).toBe(0);
-        expect(_vmgState.vmgToZonePort.length).toBe(0);
-        expect(_vmgState.vmgToZoneStb.length).toBe(0);
+        expect(_vmgState.vmgToLinePos.sorted.length).toBe(1);
+        expect(_vmgState.vmgToLinePos.sorted[0]).toBe(5);
+        expect(_vmgState.vmgToLineNeg.sorted.length).toBe(0);
+        expect(_vmgState.vmgToZonePort.sorted.length).toBe(0);
+        expect(_vmgState.vmgToZoneStb.sorted.length).toBe(0);
 
         collectVmgSamples(toRadians(36.87), 5, 270, 0, 0);
-        expect(_vmgState.vmgToLinePos.length).toBe(2);
-        expect(_vmgState.vmgToLinePos[0]).toBeCloseTo(4);
-        expect(_vmgState.vmgToLinePos[1]).toBe(5);
-        expect(_vmgState.vmgToLineNeg.length).toBe(0);
-        expect(_vmgState.vmgToZonePort.length).toBe(0);
-        expect(_vmgState.vmgToZoneStb.length).toBe(1);
-        expect(_vmgState.vmgToZoneStb[0]).toBeCloseTo(3);
+        expect(_vmgState.vmgToLinePos.sorted.length).toBe(2);
+        expect(_vmgState.vmgToLinePos.sorted[0]).toBeCloseTo(4);
+        expect(_vmgState.vmgToLinePos.sorted[1]).toBe(5);
+        expect(_vmgState.vmgToLineNeg.sorted.length).toBe(0);
+        expect(_vmgState.vmgToZonePort.sorted.length).toBe(0);
+        expect(_vmgState.vmgToZoneStb.sorted.length).toBe(1);
+        expect(_vmgState.vmgToZoneStb.sorted[0]).toBeCloseTo(3);
 
         collectVmgSamples(toRadians(90), 5, 270, 0, 0);
-        expect(_vmgState.vmgToLinePos.length).toBe(2);
-        expect(_vmgState.vmgToLinePos[0]).toBeCloseTo(4);
-        expect(_vmgState.vmgToLinePos[1]).toBeCloseTo(5);
-        expect(_vmgState.vmgToLineNeg.length).toBe(0);
-        expect(_vmgState.vmgToZonePort.length).toBe(0);
-        expect(_vmgState.vmgToZoneStb.length).toBe(2);
-        expect(_vmgState.vmgToZoneStb[0]).toBeCloseTo(3);
-        expect(_vmgState.vmgToZoneStb[1]).toBeCloseTo(5);
+        expect(_vmgState.vmgToLinePos.sorted.length).toBe(2);
+        expect(_vmgState.vmgToLinePos.sorted[0]).toBeCloseTo(4);
+        expect(_vmgState.vmgToLinePos.sorted[1]).toBeCloseTo(5);
+        expect(_vmgState.vmgToLineNeg.sorted.length).toBe(0);
+        expect(_vmgState.vmgToZonePort.sorted.length).toBe(0);
+        expect(_vmgState.vmgToZoneStb.sorted.length).toBe(2);
+        expect(_vmgState.vmgToZoneStb.sorted[0]).toBeCloseTo(3);
+        expect(_vmgState.vmgToZoneStb.sorted[1]).toBeCloseTo(5);
 
         collectVmgSamples(toRadians(90 + 36.87), 5, 270, 0, 0);
-        expect(_vmgState.vmgToLinePos.length).toBe(2);
-        expect(_vmgState.vmgToLinePos[0]).toBeCloseTo(4);
-        expect(_vmgState.vmgToLinePos[1]).toBeCloseTo(5);
-        expect(_vmgState.vmgToLineNeg.length).toBe(1);
-        expect(_vmgState.vmgToLineNeg[0]).toBeCloseTo(3);
-        expect(_vmgState.vmgToZonePort.length).toBe(0);
-        expect(_vmgState.vmgToZoneStb.length).toBe(3);
-        expect(_vmgState.vmgToZoneStb[0]).toBeCloseTo(3);
-        expect(_vmgState.vmgToZoneStb[1]).toBeCloseTo(4);
-        expect(_vmgState.vmgToZoneStb[2]).toBeCloseTo(5);
+        expect(_vmgState.vmgToLinePos.sorted.length).toBe(2);
+        expect(_vmgState.vmgToLinePos.sorted[0]).toBeCloseTo(4);
+        expect(_vmgState.vmgToLinePos.sorted[1]).toBeCloseTo(5);
+        expect(_vmgState.vmgToLineNeg.sorted.length).toBe(1);
+        expect(_vmgState.vmgToLineNeg.sorted[0]).toBeCloseTo(3);
+        expect(_vmgState.vmgToZonePort.sorted.length).toBe(0);
+        expect(_vmgState.vmgToZoneStb.sorted.length).toBe(3);
+        expect(_vmgState.vmgToZoneStb.sorted[0]).toBeCloseTo(3);
+        expect(_vmgState.vmgToZoneStb.sorted[1]).toBeCloseTo(4);
+        expect(_vmgState.vmgToZoneStb.sorted[2]).toBeCloseTo(5);
 
         collectVmgSamples(toRadians(180), 5, 270, 0, 0);
-        expect(_vmgState.vmgToLinePos.length).toBe(2);
-        expect(_vmgState.vmgToLinePos[0]).toBeCloseTo(4);
-        expect(_vmgState.vmgToLinePos[1]).toBeCloseTo(5);
-        expect(_vmgState.vmgToLineNeg.length).toBe(2);
-        expect(_vmgState.vmgToLineNeg[0]).toBeCloseTo(3);
-        expect(_vmgState.vmgToLineNeg[1]).toBeCloseTo(5);
-        expect(_vmgState.vmgToZonePort.length).toBe(0);
-        expect(_vmgState.vmgToZoneStb.length).toBe(3);
-        expect(_vmgState.vmgToZoneStb[0]).toBeCloseTo(3);
-        expect(_vmgState.vmgToZoneStb[1]).toBeCloseTo(4);
-        expect(_vmgState.vmgToZoneStb[2]).toBeCloseTo(5);
+        expect(_vmgState.vmgToLinePos.sorted.length).toBe(2);
+        expect(_vmgState.vmgToLinePos.sorted[0]).toBeCloseTo(4);
+        expect(_vmgState.vmgToLinePos.sorted[1]).toBeCloseTo(5);
+        expect(_vmgState.vmgToLineNeg.sorted.length).toBe(2);
+        expect(_vmgState.vmgToLineNeg.sorted[0]).toBeCloseTo(3);
+        expect(_vmgState.vmgToLineNeg.sorted[1]).toBeCloseTo(5);
+        expect(_vmgState.vmgToZonePort.sorted.length).toBe(0);
+        expect(_vmgState.vmgToZoneStb.sorted.length).toBe(3);
+        expect(_vmgState.vmgToZoneStb.sorted[0]).toBeCloseTo(3);
+        expect(_vmgState.vmgToZoneStb.sorted[1]).toBeCloseTo(4);
+        expect(_vmgState.vmgToZoneStb.sorted[2]).toBeCloseTo(5);
 
         collectVmgSamples(toRadians(180 + 53.13), 5, 270, 0, 0);
-        expect(_vmgState.vmgToLinePos.length).toBe(2);
-        expect(_vmgState.vmgToLinePos[0]).toBeCloseTo(4);
-        expect(_vmgState.vmgToLinePos[1]).toBeCloseTo(5);
-        expect(_vmgState.vmgToLineNeg.length).toBe(3);
-        expect(_vmgState.vmgToLineNeg[0]).toBeCloseTo(3);
-        expect(_vmgState.vmgToLineNeg[1]).toBeCloseTo(3);
-        expect(_vmgState.vmgToLineNeg[2]).toBeCloseTo(5);
-        expect(_vmgState.vmgToZonePort.length).toBe(1);
-        expect(_vmgState.vmgToZonePort[0]).toBeCloseTo(4);
-        expect(_vmgState.vmgToZoneStb.length).toBe(3);
-        expect(_vmgState.vmgToZoneStb[0]).toBeCloseTo(3);
-        expect(_vmgState.vmgToZoneStb[1]).toBeCloseTo(4);
-        expect(_vmgState.vmgToZoneStb[2]).toBeCloseTo(5);
+        expect(_vmgState.vmgToLinePos.sorted.length).toBe(2);
+        expect(_vmgState.vmgToLinePos.sorted[0]).toBeCloseTo(4);
+        expect(_vmgState.vmgToLinePos.sorted[1]).toBeCloseTo(5);
+        expect(_vmgState.vmgToLineNeg.sorted.length).toBe(3);
+        expect(_vmgState.vmgToLineNeg.sorted[0]).toBeCloseTo(3);
+        expect(_vmgState.vmgToLineNeg.sorted[1]).toBeCloseTo(3);
+        expect(_vmgState.vmgToLineNeg.sorted[2]).toBeCloseTo(5);
+        expect(_vmgState.vmgToZonePort.sorted.length).toBe(1);
+        expect(_vmgState.vmgToZonePort.sorted[0]).toBeCloseTo(4);
+        expect(_vmgState.vmgToZoneStb.sorted.length).toBe(3);
+        expect(_vmgState.vmgToZoneStb.sorted[0]).toBeCloseTo(3);
+        expect(_vmgState.vmgToZoneStb.sorted[1]).toBeCloseTo(4);
+        expect(_vmgState.vmgToZoneStb.sorted[2]).toBeCloseTo(5);
 
         collectVmgSamples(toRadians(270), 5, 270, 0, 0);
-        expect(_vmgState.vmgToLinePos.length).toBe(2);
-        expect(_vmgState.vmgToLinePos[0]).toBeCloseTo(4);
-        expect(_vmgState.vmgToLinePos[1]).toBeCloseTo(5);
-        expect(_vmgState.vmgToLineNeg.length).toBe(3);
-        expect(_vmgState.vmgToLineNeg[0]).toBeCloseTo(3);
-        expect(_vmgState.vmgToLineNeg[1]).toBeCloseTo(3);
-        expect(_vmgState.vmgToLineNeg[2]).toBeCloseTo(5);
-        expect(_vmgState.vmgToZonePort.length).toBe(2);
-        expect(_vmgState.vmgToZonePort[0]).toBeCloseTo(4);
-        expect(_vmgState.vmgToZonePort[1]).toBeCloseTo(5);
-        expect(_vmgState.vmgToZoneStb.length).toBe(3);
-        expect(_vmgState.vmgToZoneStb[0]).toBeCloseTo(3);
-        expect(_vmgState.vmgToZoneStb[1]).toBeCloseTo(4);
-        expect(_vmgState.vmgToZoneStb[2]).toBeCloseTo(5);
+        expect(_vmgState.vmgToLinePos.sorted.length).toBe(2);
+        expect(_vmgState.vmgToLinePos.sorted[0]).toBeCloseTo(4);
+        expect(_vmgState.vmgToLinePos.sorted[1]).toBeCloseTo(5);
+        expect(_vmgState.vmgToLineNeg.sorted.length).toBe(3);
+        expect(_vmgState.vmgToLineNeg.sorted[0]).toBeCloseTo(3);
+        expect(_vmgState.vmgToLineNeg.sorted[1]).toBeCloseTo(3);
+        expect(_vmgState.vmgToLineNeg.sorted[2]).toBeCloseTo(5);
+        expect(_vmgState.vmgToZonePort.sorted.length).toBe(2);
+        expect(_vmgState.vmgToZonePort.sorted[0]).toBeCloseTo(4);
+        expect(_vmgState.vmgToZonePort.sorted[1]).toBeCloseTo(5);
+        expect(_vmgState.vmgToZoneStb.sorted.length).toBe(3);
+        expect(_vmgState.vmgToZoneStb.sorted[0]).toBeCloseTo(3);
+        expect(_vmgState.vmgToZoneStb.sorted[1]).toBeCloseTo(4);
+        expect(_vmgState.vmgToZoneStb.sorted[2]).toBeCloseTo(5);
 
         collectVmgSamples(-toRadians(53.13), 5, 270, 0, 0);
-        expect(_vmgState.vmgToLinePos.length).toBe(3);
-        expect(_vmgState.vmgToLinePos[0]).toBeCloseTo(3);
-        expect(_vmgState.vmgToLinePos[1]).toBeCloseTo(4);
-        expect(_vmgState.vmgToLinePos[2]).toBeCloseTo(5);
-        expect(_vmgState.vmgToLineNeg.length).toBe(3);
-        expect(_vmgState.vmgToLineNeg[0]).toBeCloseTo(3);
-        expect(_vmgState.vmgToLineNeg[1]).toBeCloseTo(3);
-        expect(_vmgState.vmgToLineNeg[2]).toBeCloseTo(5);
-        expect(_vmgState.vmgToZonePort.length).toBe(3);
-        expect(_vmgState.vmgToZonePort[0]).toBeCloseTo(4);
-        expect(_vmgState.vmgToZonePort[1]).toBeCloseTo(4);
-        expect(_vmgState.vmgToZonePort[2]).toBeCloseTo(5);
-        expect(_vmgState.vmgToZoneStb.length).toBe(3);
-        expect(_vmgState.vmgToZoneStb[0]).toBeCloseTo(3);
-        expect(_vmgState.vmgToZoneStb[1]).toBeCloseTo(4);
-        expect(_vmgState.vmgToZoneStb[2]).toBeCloseTo(5);
+        expect(_vmgState.vmgToLinePos.sorted.length).toBe(3);
+        expect(_vmgState.vmgToLinePos.sorted[0]).toBeCloseTo(3);
+        expect(_vmgState.vmgToLinePos.sorted[1]).toBeCloseTo(4);
+        expect(_vmgState.vmgToLinePos.sorted[2]).toBeCloseTo(5);
+        expect(_vmgState.vmgToLineNeg.sorted.length).toBe(3);
+        expect(_vmgState.vmgToLineNeg.sorted[0]).toBeCloseTo(3);
+        expect(_vmgState.vmgToLineNeg.sorted[1]).toBeCloseTo(3);
+        expect(_vmgState.vmgToLineNeg.sorted[2]).toBeCloseTo(5);
+        expect(_vmgState.vmgToZonePort.sorted.length).toBe(3);
+        expect(_vmgState.vmgToZonePort.sorted[0]).toBeCloseTo(4);
+        expect(_vmgState.vmgToZonePort.sorted[1]).toBeCloseTo(4);
+        expect(_vmgState.vmgToZonePort.sorted[2]).toBeCloseTo(5);
+        expect(_vmgState.vmgToZoneStb.sorted.length).toBe(3);
+        expect(_vmgState.vmgToZoneStb.sorted[0]).toBeCloseTo(3);
+        expect(_vmgState.vmgToZoneStb.sorted[1]).toBeCloseTo(4);
+        expect(_vmgState.vmgToZoneStb.sorted[2]).toBeCloseTo(5);
 
     });
 
     test('collectVmgSamplesNW2SE: test NW to SE line approached obliquely', () => {
         resetVmgSamples();
         collectVmgSamples(toRadians(0), 19.7, 8.21, 0, 0);
-        expect(_vmgState.vmgToLinePos.length).toBe(0);
-        expect(_vmgState.vmgToLineNeg.length).toBe(1);
-        expect(_vmgState.vmgToLineNeg[0]).toBeCloseTo(2.81);
-        expect(_vmgState.vmgToZonePort.length).toBe(1);
-        expect(_vmgState.vmgToZonePort[0]).toBeCloseTo(19.5);
-        expect(_vmgState.vmgToZoneStb.length).toBe(0);
+        expect(_vmgState.vmgToLinePos.sorted.length).toBe(0);
+        expect(_vmgState.vmgToLineNeg.sorted.length).toBe(1);
+        expect(_vmgState.vmgToLineNeg.sorted[0]).toBeCloseTo(2.81);
+        expect(_vmgState.vmgToZonePort.sorted.length).toBe(1);
+        expect(_vmgState.vmgToZonePort.sorted[0]).toBeCloseTo(19.5);
+        expect(_vmgState.vmgToZoneStb.sorted.length).toBe(0);
     });
 });