tabletcommand-location 2.3.8 → 2.4.1

package/src/test/location.ts

@@ -5,7 +5,7 @@ import storeModule, { StoreModule } from "../store";
 import mockModule from "./mock";
 import locationModule, { LocationModule } from "../location";
 import { LocationPayload } from "../types";
-import { BackendModels } from "tabletcommand-backend-models";
+import { AccountIndustry, BackendModels } from "tabletcommand-backend-models";
 
 let location: LocationModule;
 let store: StoreModule;
@@ -150,6 +150,259 @@ describe("location", () => {
       assert.equal(locationRecord[0]?.visibility.includes("shared"), true);
       /* cSpell:enable */
     });
+    it("applies person invariants on the geotab path, ignoring device mapping", async () => {
+      const department = mockDepartment;
+      // BEEDOO3 has a device mapping with mapId BOOPBEEP99 and locationToCAD:
+      // true; a person payload must not pick either of those up.
+      const items = [{
+        vehicleId: "BEEDOO3",
+        radioName: "Smokey Bear",
+        latitude: 34.35264,
+        longitude: -119.0669,
+        avlTime: "2026-07-10T15:43:36.816Z",
+        kindType: "person",
+        locationType: "person",
+        source: "TXRX",
+        transponderUUID: "aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee",
+        userId: "TXRX-aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee",
+        session: "TXRX-aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee",
+        username: "Smokey Bear",
+        visibility: [],
+      }] as unknown as LocationPayload[];
+      await location.processItemsDeviceMappingGeotab(department, items, new Date());
+      const recs = await models.Location.find({});
+      assert.equal(recs.length, 1);
+      assert.equal(recs[0]?.username, "Smokey Bear");
+      assert.equal(recs[0]?.session, "TXRX-aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee");
+      assert.equal(recs[0]?.transponderUUID, "aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee");
+      assert.equal(recs[0]?.active, true);
+      assert.equal(recs[0]?.shared, false);
+      assert.equal(recs[0]?.sendToCAD, false);
+      assert.deepEqual(recs[0]?.visibility, ["visible"]);
+    });
+    it("skips geotab person locations with neither personnelUUID nor transponderUUID", async () => {
+      const department = mockDepartment;
+      const items = [{
+        vehicleId: "BEEDOO3",
+        radioName: "Smokey Bear",
+        latitude: 34.35264,
+        longitude: -119.0669,
+        avlTime: "2026-07-10T15:43:36.816Z",
+        kindType: "person",
+        locationType: "person",
+        source: "TXRX",
+        visibility: [],
+      }] as unknown as LocationPayload[];
+      await location.processItemsDeviceMappingGeotab(department, items, new Date());
+      const recs = await models.Location.find({});
+      assert.equal(recs.length, 0);
+    });
+    it("saves person locations keyed by session with person invariants, no CAD vehicle", async () => {
+      const atDate = new Date();
+      const department = mockDepartment;
+      const items = [{
+        vehicleId: "12345",
+        radioName: "SmokeyBear",
+        latitude: 34.35264,
+        longitude: -119.0669,
+        avlTime: "2026-07-10T15:43:36.816Z",
+        kindType: "person",
+        locationType: "person",
+        kind: "",
+        type: "",
+        source: "TXRX",
+        personnelUUID: "11111111-2222-3333-4444-555555555555",
+        userId: "TXRX-12345",
+        session: "TXRX-12345",
+        username: "SmokeyBear",
+        visibility: [],
+      }] as unknown as LocationPayload[];
+      await location.processItems(department, items, atDate);
+      const recs = await models.Location.find({});
+      assert.equal(recs.length, 1);
+      assert.equal(recs[0]?.kindType, "person");
+      assert.equal(recs[0]?.locationType, "person");
+      assert.equal(recs[0]?.personnelUUID, "11111111-2222-3333-4444-555555555555");
+      assert.equal(recs[0]?.transponderUUID, "");
+      assert.equal(recs[0]?.username, "SmokeyBear");
+      assert.equal(recs[0]?.userId, "TXRX-12345");
+      assert.equal(recs[0]?.session, "TXRX-12345");
+      assert.equal(recs[0]?.active, true);
+      assert.equal(recs[0]?.shared, false);
+      assert.equal(recs[0]?.sendToCAD, false);
+      assert.deepEqual(recs[0]?.visibility, ["visible"]);
+      // Person records must not create phantom CAD vehicles
+      const vehicles = await models.CADVehicle.find({});
+      assert.equal(vehicles.length, 0);
+    });
+    it("stamps kindType on person locations classified by locationType alone", async () => {
+      const atDate = new Date();
+      const department = mockDepartment;
+      const items = [{
+        vehicleId: "12345",
+        radioName: "SmokeyBear",
+        latitude: 34.35264,
+        longitude: -119.0669,
+        avlTime: "2026-07-10T15:43:36.816Z",
+        locationType: "person",
+        source: "TXRX",
+        personnelUUID: "11111111-2222-3333-4444-555555555555",
+        userId: "TXRX-12345",
+        session: "TXRX-12345",
+        username: "SmokeyBear",
+        visibility: [],
+      }] as unknown as LocationPayload[];
+      await location.processItems(department, items, atDate);
+      const recs = await models.Location.find({});
+      assert.equal(recs.length, 1);
+      // The person feed queries kindType: "person", so the record must not
+      // rely on the payload having set it
+      assert.equal(recs[0]?.kindType, "person");
+      assert.equal(recs[0]?.locationType, "person");
+      assert.equal(recs[0]?.personnelUUID, "11111111-2222-3333-4444-555555555555");
+      const vehicles = await models.CADVehicle.find({});
+      assert.equal(vehicles.length, 0);
+    });
+    it("accepts transponder person locations on transponderUUID alone", async () => {
+      const atDate = new Date();
+      const department = mockDepartment;
+      const items = [{
+        vehicleId: "FB:9D:2C:3E:C9:E4",
+        radioName: "Fire Hose 1",
+        latitude: 34.35264,
+        longitude: -119.0669,
+        avlTime: "2026-07-10T15:43:36.816Z",
+        kindType: "person",
+        locationType: "person",
+        source: "TXRX",
+        transponderUUID: "aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee",
+        userId: "TXRX-aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee",
+        session: "TXRX-aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee",
+        username: "Fire Hose 1",
+        visibility: [],
+      }] as unknown as LocationPayload[];
+      await location.processItems(department, items, atDate);
+      const recs = await models.Location.find({});
+      assert.equal(recs.length, 1);
+      assert.equal(recs[0]?.transponderUUID, "aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee");
+      assert.equal(recs[0]?.personnelUUID, "");
+      assert.equal(recs[0]?.session, "TXRX-aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee");
+      assert.equal(recs[0]?.active, true);
+      assert.equal(recs[0]?.shared, false);
+      assert.equal(recs[0]?.sendToCAD, false);
+      assert.deepEqual(recs[0]?.visibility, ["visible"]);
+      // Person records must not create phantom CAD vehicles
+      const vehicles = await models.CADVehicle.find({});
+      assert.equal(vehicles.length, 0);
+    });
+    it("updates person locations in place on rename, preserving person fields", async () => {
+      const department = mockDepartment;
+      const base = {
+        vehicleId: "FB:9D:2C:3E:C9:E4",
+        radioName: "William Jones",
+        latitude: 34.35264,
+        longitude: -119.0669,
+        avlTime: "2026-07-10T15:43:36.816Z",
+        kindType: "person",
+        locationType: "person",
+        source: "TXRX",
+        transponderUUID: "aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee",
+        userId: "TXRX-aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee",
+        session: "TXRX-aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee",
+        username: "William Jones",
+        visibility: [],
+      };
+      await location.processItems(department, [base] as unknown as LocationPayload[], new Date());
+      const renamed = {
+        ...base,
+        radioName: "Bill Jones",
+        username: "Bill Jones",
+        latitude: 34.4,
+      };
+      await location.processItems(department, [renamed] as unknown as LocationPayload[], new Date());
+      const recs = await models.Location.find({});
+      assert.equal(recs.length, 1);
+      assert.equal(recs[0]?.username, "Bill Jones");
+      assert.equal(recs[0]?.session, "TXRX-aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee");
+      assert.equal(recs[0]?.locationGeoJSON.coordinates[1], 34.4);
+      // Update path must preserve the person fields
+      assert.equal(recs[0]?.kindType, "person");
+      assert.equal(recs[0]?.locationType, "person");
+      assert.equal(recs[0]?.transponderUUID, "aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee");
+      assert.deepEqual(recs[0]?.visibility, ["visible"]);
+    });
+    it("does not wipe transponderUUID when an update omits it", async () => {
+      const department = mockDepartment;
+      const base = {
+        vehicleId: "FB:9D:2C:3E:C9:E4",
+        radioName: "Fire Hose 1",
+        latitude: 34.35264,
+        longitude: -119.0669,
+        avlTime: "2026-07-10T15:43:36.816Z",
+        kindType: "person",
+        locationType: "person",
+        source: "TXRX",
+        transponderUUID: "aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee",
+        userId: "TXRX-aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee",
+        session: "TXRX-aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee",
+        username: "Fire Hose 1",
+        visibility: [],
+      };
+      await location.processItems(department, [base] as unknown as LocationPayload[], new Date());
+      // Same session, but this update carries only a personnelUUID
+      const update = {
+        ...base,
+        transponderUUID: "",
+        personnelUUID: "11111111-2222-3333-4444-555555555555",
+        latitude: 34.4,
+      };
+      await location.processItems(department, [update] as unknown as LocationPayload[], new Date());
+      const recs = await models.Location.find({});
+      assert.equal(recs.length, 1);
+      assert.equal(recs[0]?.transponderUUID, "aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee");
+      assert.equal(recs[0]?.personnelUUID, "11111111-2222-3333-4444-555555555555");
+      assert.equal(recs[0]?.locationGeoJSON.coordinates[1], 34.4);
+    });
+    it("skips person locations with neither personnelUUID nor transponderUUID", async () => {
+      const department = mockDepartment;
+      const items = [{
+        vehicleId: "12345",
+        radioName: "William Jones",
+        latitude: 34.35264,
+        longitude: -119.0669,
+        avlTime: "2026-07-10T15:43:36.816Z",
+        kindType: "person",
+        locationType: "person",
+        source: "TXRX",
+        session: "TXRX-12345",
+        visibility: [],
+      }] as unknown as LocationPayload[];
+      await location.processItems(department, items, new Date());
+      const recs = await models.Location.find({});
+      assert.equal(recs.length, 0);
+      const vehicles = await models.CADVehicle.find({});
+      assert.equal(vehicles.length, 0);
+    });
+    it("continues processing the batch after an invalid item", async () => {
+      const department = mockDepartment;
+      const items = [{
+        vehicleId: "",
+        radioName: "",
+        latitude: 0,
+        longitude: 0,
+        avlTime: "1602563494",
+      }, {
+        vehicleId: "BEEDOO1",
+        radioName: "BEEDOO1",
+        latitude: 34.35264,
+        longitude: -119.0669,
+        avlTime: "1602563494",
+      }] as unknown as LocationPayload[];
+      await location.processItems(department, items, new Date());
+      const recs = await models.Location.find({});
+      assert.equal(recs.length, 1);
+      assert.equal(recs[0]?.username, "BEEDOO1");
+    });
     it("carries kind/type/locationType/kindColor onto the saved Location", async () => {
       const atDate = new Date();
       const department = mockDepartment;
@@ -176,5 +429,57 @@ describe("location", () => {
       assert.equal(recs[0]?.kindColor?.text, "#FFFFFF");
       assert.instanceOf(recs[0]?.kindColorChangedAt, Date);
     });
+    it("stamps the department's industry on the saved location", async () => {
+      const atDate = new Date();
+      const session = "item-with-industry-utility";
+      const items = [{
+        vehicleId: "BEEDOO1",
+        radioName: "BEEDOO1",
+        latitude: 34.35264,
+        longitude: -119.0669,
+        avlTime: "1602563494",
+        session,
+      }] as unknown as LocationPayload[];
+      await location.processItems(mockDepartment, items, atDate);
+      const sut = await models.Location.findOne({ session });
+      assert.equal(sut?.industry, AccountIndustry.Utility);
+    });
+    it("falls back to fire industry when the department has none set", async () => {
+      const atDate = new Date();
+      const session = "item-with-industry-fallback";
+      const department = { ...mockDepartment, industry: undefined };
+      const items = [{
+        vehicleId: "BEEDOO1",
+        radioName: "BEEDOO1",
+        latitude: 34.35264,
+        longitude: -119.0669,
+        avlTime: "1602563494",
+        session,
+      }] as unknown as LocationPayload[];
+      await location.processItems(department, items, atDate);
+      const sut = await models.Location.findOne({ session });
+      assert.equal(sut?.industry, AccountIndustry.Fire);
+    });
+    it("updates industry in place and stamps propsChangedAt when it changes", async () => {
+      const base = {
+        vehicleId: "BEEDOO1",
+        radioName: "BEEDOO1",
+        latitude: 34.35264,
+        longitude: -119.0669,
+        avlTime: "1602563494",
+      } as unknown as LocationPayload;
+      await location.processItems(mockDepartment, [base], new Date());
+      const initial = await models.Location.find({});
+      assert.equal(initial[0]?.industry, AccountIndustry.Utility);
+      const initialPropsChangedAt = initial[0]?.propsChangedAt;
+      assert.instanceOf(initialPropsChangedAt, Date);
+
+      const lawDepartment = { ...mockDepartment, industry: AccountIndustry.Law };
+      await location.processItems(lawDepartment, [base], new Date());
+      const recs = await models.Location.find({});
+      assert.equal(recs.length, 1);
+      assert.equal(recs[0]?.industry, AccountIndustry.Law);
+      assert.isAbove(recs[0]!.propsChangedAt.valueOf(), initialPropsChangedAt!.valueOf());
+    });
   });
 });

package/src/test/mock.ts

@@ -1,6 +1,7 @@
 import * as mongoose from "mongoose";
 import {
   BackendModels,
+  AccountIndustry,
   Agency,
   Department,
   convertToObjectId as ObjectId
@@ -15,11 +16,16 @@ export default function(modelsModule: typeof import("tabletcommand-backend-model
     _id: ObjectId(departmentId),
     department: "Test Department",
     accountType: "production",
+    industry: AccountIndustry.Utility,
     shareAVL: {
       enabled: true,
       opAreaName: "Test Area",
       opAreaCode: "TEST",
       fadeZoomLevel: 45000,
+      area: {
+        type: "Polygon",
+        coordinates: [],
+      },
     },
     signupDomains: [],
     signupKey: "abcd",

package/src/test/query.ts

@@ -0,0 +1,209 @@
+import { assert } from "chai";
+import { describe, it, describe as context } from "node:test";
+import {
+  adminListLocations,
+  adminListPersonLocations,
+  adminListUAVLocations,
+  adminListAircraftLocations,
+  adminListSharedLocations,
+  adminListFocusedLocations,
+  syncListSharedLocations,
+  syncListLocations,
+  syncListPersonLocations,
+  syncListAircraftLocations,
+  syncListUAVLocations,
+  metersToRadians,
+} from "../query";
+
+const departmentId = "5195426cc4e016a988000969";
+const movedAt = new Date("2024-01-01T00:00:00.000Z");
+const modifiedDate = new Date("2024-01-02T00:00:00.000Z");
+const longitude = -119.0669;
+const latitude = 34.35264;
+const diagonal = 5000;
+
+describe("query", () => {
+  context("adminListLocations", () => {
+    it("Scopes to the department, excludes uav and person/transponder-tracked records", () => {
+      const { list } = adminListLocations({ departmentId, movedAt });
+      assert.equal(list.active, true);
+      assert.equal(list.departmentId, departmentId);
+      assert.deepEqual(list.kindType, { $ne: "uav" });
+    });
+
+    it("Drops the active filter when showAll is true", () => {
+      const { list } = adminListLocations({ departmentId, movedAt, showAll: true });
+      assert.isUndefined(list.active);
+    });
+
+    it("Keeps the active filter when showAll is not set", () => {
+      const { list } = adminListLocations({ departmentId, movedAt });
+      assert.property(list, "active");
+    });
+  });
+
+  context("adminListPersonLocations", () => {
+    it("Scopes to the department and person kindType", () => {
+      const { list } = adminListPersonLocations({ departmentId, movedAt });
+      assert.equal(list.active, true);
+      assert.equal(list.departmentId, departmentId);
+      assert.equal(list.kindType, "person");
+      assert.deepEqual(list.movedAt, { $gte: movedAt });
+    });
+
+    it("Drops the active filter when showAll is true", () => {
+      const { list } = adminListPersonLocations({ departmentId, movedAt, showAll: true });
+      assert.isUndefined(list.active);
+    });
+  });
+
+  context("adminListUAVLocations", () => {
+    it("Scopes to the department and uav kindType", () => {
+      const { list } = adminListUAVLocations({ departmentId, movedAt });
+      assert.equal(list.active, true);
+      assert.equal(list.departmentId, departmentId);
+      assert.equal(list.kindType, "uav");
+      assert.deepEqual(list.movedAt, { $gte: movedAt });
+    });
+
+    it("Drops the active filter when showAll is true", () => {
+      const { list } = adminListUAVLocations({ departmentId, movedAt, showAll: true });
+      assert.isUndefined(list.active);
+    });
+  });
+
+  context("adminListAircraftLocations", () => {
+    it("Excludes the caller's department and matches shared ADSB aircraft", () => {
+      const { list } = adminListAircraftLocations({ departmentId, movedAt, longitude, latitude, diagonal });
+      assert.equal(list.shared, true);
+      assert.equal(list.active, true);
+      assert.equal(list.source, "ADSB");
+      assert.deepEqual(list.kindType, { $in: ["fixed-wing", "helicopter"] });
+      assert.deepEqual(list.departmentId, { $ne: departmentId });
+    });
+
+    it("Sends movedAt as an ISO string", () => {
+      const { list } = adminListAircraftLocations({ departmentId, movedAt, longitude, latitude, diagonal });
+      assert.deepEqual(list.movedAt, { $gte: movedAt.toISOString() });
+    });
+
+    it("Builds a $centerSphere filter as [longitude, latitude] with the diagonal converted to radians", () => {
+      const { list } = adminListAircraftLocations({ departmentId, movedAt, longitude, latitude, diagonal });
+      assert.deepEqual(list.locationGeoJSON.$geoWithin.$centerSphere, [
+        [longitude, latitude],
+        diagonal / metersToRadians,
+      ]);
+    });
+  });
+
+  context("adminListSharedLocations", () => {
+    it("Excludes the caller's department, ADSB source, and uav kindType", () => {
+      const { list } = adminListSharedLocations({ departmentId, movedAt, longitude, latitude, diagonal });
+      assert.equal(list.shared, true);
+      assert.equal(list.active, true);
+      assert.deepEqual(list.source, { $ne: "ADSB" });
+      assert.deepEqual(list.kindType, { $ne: "uav" });
+      assert.deepEqual(list.departmentId, { $ne: departmentId });
+    });
+  });
+
+  context("adminListFocusedLocations", () => {
+    it("Scopes to the caller's department with a geo filter", () => {
+      const { list } = adminListFocusedLocations({ departmentId, movedAt, longitude, latitude, diagonal });
+      assert.equal(list.active, true);
+      assert.equal(list.departmentId, departmentId);
+      assert.property(list, "locationGeoJSON");
+    });
+
+    it("Drops the geo filter (not active) when showAll is true", () => {
+      const { list } = adminListFocusedLocations({ departmentId, movedAt, longitude, latitude, diagonal, showAll: true });
+      assert.isUndefined(list.locationGeoJSON);
+      assert.equal(list.active, true);
+    });
+  });
+
+  context("syncListSharedLocations", () => {
+    it("Excludes the caller's department and ADSB/DroneSense sources", () => {
+      const { list } = syncListSharedLocations({ departmentId, movedAt, modifiedDate, longitude, latitude, diagonal });
+      assert.equal(list.shared, true);
+      assert.deepEqual(list.source, { $nin: ["ADSB", "DroneSense"] });
+      assert.deepEqual(list.departmentId, { $ne: departmentId });
+      assert.deepEqual(list.modified, { $gte: modifiedDate.toISOString() });
+      assert.deepEqual(list.movedAt, { $gte: movedAt.toISOString() });
+    });
+  });
+
+  context("syncListLocations", () => {
+    it("Scopes to the department, excludes uav and person/transponder-tracked records", () => {
+      const { list } = syncListLocations({ departmentId, movedAt, modifiedDate });
+      assert.equal(list.departmentId, departmentId);
+      assert.deepEqual(list.kindType, { $ne: "uav" });
+      assert.deepEqual(list.modified, { $gte: modifiedDate.toISOString() });
+      assert.deepEqual(list.movedAt, { $gte: movedAt.toISOString() });
+      assert.deepEqual(list.$and, [
+        { $or: [{ personnelUUID: "" }, { personnelUUID: { $exists: false } }] },
+        { $or: [{ transponderUUID: "" }, { transponderUUID: { $exists: false } }] },
+      ]);
+    });
+  });
+
+  context("syncListPersonLocations", () => {
+    it("Scopes to the department and person kindType", () => {
+      const { list } = syncListPersonLocations({ departmentId, movedAt, modifiedDate });
+      assert.equal(list.departmentId, departmentId);
+      assert.equal(list.kindType, "person");
+      assert.deepEqual(list.modified, { $gte: modifiedDate.toISOString() });
+      assert.deepEqual(list.movedAt, { $gte: movedAt.toISOString() });
+    });
+  });
+
+  context("syncListUAVLocations", () => {
+    it("Scopes to the department and uav kindType", () => {
+      const { list } = syncListUAVLocations({ departmentId, movedAt, modifiedDate });
+      assert.equal(list.departmentId, departmentId);
+      assert.equal(list.kindType, "uav");
+      assert.deepEqual(list.modified, { $gte: modifiedDate.toISOString() });
+      assert.deepEqual(list.movedAt, { $gte: movedAt.toISOString() });
+    });
+  });
+
+  context("syncListAircraftLocations", () => {
+    const base = { departmentId, movedAt, modifiedDate };
+
+    it("Matches shared ADSB aircraft, scoped away from the caller's department", () => {
+      const { list } = syncListAircraftLocations({ ...base, longitude, latitude, diagonal });
+      assert.equal(list.shared, true);
+      assert.equal(list.source, "ADSB");
+      assert.deepEqual(list.kindType, { $in: ["fixed-wing", "helicopter"] });
+      assert.deepEqual(list.departmentId, { $ne: departmentId });
+    });
+
+    it("Adds a geo filter when given valid, non-zero coordinates", () => {
+      const { list } = syncListAircraftLocations({ ...base, longitude, latitude, diagonal });
+      assert.deepEqual(list.locationGeoJSON.$geoWithin.$centerSphere, [
+        [longitude, latitude],
+        diagonal / metersToRadians,
+      ]);
+    });
+
+    it("Omits the geo filter when coordinates are at the origin", () => {
+      const { list } = syncListAircraftLocations({ ...base, longitude: 0, latitude: 0, diagonal });
+      assert.isUndefined(list.locationGeoJSON);
+    });
+
+    it("Omits the geo filter when coordinates are within the origin (<= 0.01)", () => {
+      const { list } = syncListAircraftLocations({ ...base, longitude: 0.01, latitude: 0.01, diagonal });
+      assert.isUndefined(list.locationGeoJSON);
+    });
+
+    it("Omits the geo filter when latitude is out of range", () => {
+      const { list } = syncListAircraftLocations({ ...base, longitude, latitude: 90, diagonal });
+      assert.isUndefined(list.locationGeoJSON);
+    });
+
+    it("Omits the geo filter when longitude is out of range", () => {
+      const { list } = syncListAircraftLocations({ ...base, longitude: 180, latitude, diagonal });
+      assert.isUndefined(list.locationGeoJSON);
+    });
+  });
+});

package/src/types.ts

@@ -27,6 +27,21 @@ export interface LocationPayload {
   heading?: number;
   vehicleId: string;
   visibility: LocationVisibility[];
+  // Person records: link to PersonnelKnown.uuid. A person Location needs a
+  // non-empty personnelUUID or transponderUUID with both empty it would leak
+  // into the vehicle sync endpoints (filters on personnelUUID: "").
+  personnelUUID?: string;
+  // TrackerResponder.uuid for transponder-tracked seats; who occupies the seat
+  // is resolved at read time from the responder's assignment, personnelUUID
+  // stays empty on these records.
+  transponderUUID?: string;
+  // Identity overrides. When set, these replace the derived radioName-vehicleId
+  // identity so display-name changes don't fork records (e.g. "TXRX-<uuid>").
+  // Caused because up to this point these were derived/generated and changing
+  // would then change the record and break lookups causing a new record.
+  userId?: string;
+  session?: string;
+  username?: string;
 }
 
 export interface Vehicle {

package/test.sh

@@ -17,7 +17,7 @@ if hash brew 2>/dev/null; then
     fi
 fi
 
-NODE_VERSION="v24.13.0"
+NODE_VERSION="v24.15.0"
 
 nvm use $NODE_VERSION || nvm install $NODE_VERSION