@holoscript/plugin-geolocation-gis 2.0.1 → 2.0.2

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@holoscript/plugin-geolocation-gis",
-  "version": "2.0.1",
+  "version": "2.0.2",
   "main": "src/index.ts",
   "peerDependencies": {
-    "@holoscript/core": "8.0.6"
+    "@holoscript/core": ">=8.0.0"
   },
   "license": "MIT",
   "scripts": {
     "test": "vitest run --passWithNoTests",
     "test:coverage": "vitest run --coverage --passWithNoTests"
   }
-}
+}

package/src/__tests__/geodesy.test.ts

@@ -39,8 +39,8 @@ describe('vincentyInverse', () => {
   it('London → New York distance is in the 5550–5620 km range', () => {
     // Exact value depends on precise coordinates; WGS-84 ellipsoidal geodesic ≈ 5585 km.
     // Published spherical estimates vary 5570–5590 km depending on source.
-    const london   = { latDeg: 51.5074, lonDeg: -0.1278 };
-    const newYork  = { latDeg: 40.7128, lonDeg: -74.0060 };
+    const london = { latDeg: 51.5074, lonDeg: -0.1278 };
+    const newYork = { latDeg: 40.7128, lonDeg: -74.006 };
     const r = vincentyInverse(london, newYork);
     expect(r.distanceM / 1000).toBeGreaterThan(5550);
     expect(r.distanceM / 1000).toBeLessThan(5620);
@@ -49,7 +49,7 @@ describe('vincentyInverse', () => {
   it('London → New York forward azimuth is roughly NW (~288°)', () => {
     const r = vincentyInverse(
       { latDeg: 51.5074, lonDeg: -0.1278 },
-      { latDeg: 40.7128, lonDeg: -74.0060 },
+      { latDeg: 40.7128, lonDeg: -74.006 }
     );
     // Initial bearing London → NY is roughly 288° (NW)
     expect(r.forwardAzimuthDeg).toBeGreaterThan(270);
@@ -111,18 +111,18 @@ describe('llaToECEF and ecefToLLA', () => {
 
   it('ECEF roundtrip preserves LLA within 1 mm altitude and 1e-9 deg lat/lon', () => {
     const original: { latDeg: number; lonDeg: number; altM: number }[] = [
-      { latDeg:  51.5074, lonDeg:   -0.1278, altM:    10 },
-      { latDeg:  40.7128, lonDeg:  -74.0060, altM:    50 },
-      { latDeg: -33.8688, lonDeg:  151.2093, altM:    40 },
-      { latDeg:  35.6762, lonDeg:  139.6503, altM:    40 },
-      { latDeg:  -0.1000, lonDeg:  -78.4678, altM: 2_850 }, // Quito
+      { latDeg: 51.5074, lonDeg: -0.1278, altM: 10 },
+      { latDeg: 40.7128, lonDeg: -74.006, altM: 50 },
+      { latDeg: -33.8688, lonDeg: 151.2093, altM: 40 },
+      { latDeg: 35.6762, lonDeg: 139.6503, altM: 40 },
+      { latDeg: -0.1, lonDeg: -78.4678, altM: 2_850 }, // Quito
     ];
     for (const lla of original) {
-      const ecef     = llaToECEF(lla);
-      const back     = ecefToLLA(ecef);
+      const ecef = llaToECEF(lla);
+      const back = ecefToLLA(ecef);
       expect(Math.abs(back.latDeg - lla.latDeg)).toBeLessThan(1e-9);
       expect(Math.abs(back.lonDeg - lla.lonDeg)).toBeLessThan(1e-9);
-      expect(Math.abs(back.altM   - lla.altM  )).toBeLessThan(0.001); // 1 mm
+      expect(Math.abs(back.altM - lla.altM)).toBeLessThan(0.001); // 1 mm
     }
   });
 
@@ -138,8 +138,8 @@ describe('llaToECEF and ecefToLLA', () => {
 // ─── Great-circle waypoints ───────────────────────────────────────────────────
 
 describe('greatCircleWaypoints', () => {
-  const london  = { latDeg: 51.5074, lonDeg: -0.1278 };
-  const newYork = { latDeg: 40.7128, lonDeg: -74.0060 };
+  const london = { latDeg: 51.5074, lonDeg: -0.1278 };
+  const newYork = { latDeg: 40.7128, lonDeg: -74.006 };
 
   it('returns numIntermediate+2 waypoints (endpoints included)', () => {
     const route = greatCircleWaypoints(london, newYork, 8);
@@ -149,7 +149,7 @@ describe('greatCircleWaypoints', () => {
   it('first waypoint matches origin, last matches destination', () => {
     const route = greatCircleWaypoints(london, newYork, 4);
     const first = route.waypoints[0];
-    const last  = route.waypoints[route.waypoints.length - 1];
+    const last = route.waypoints[route.waypoints.length - 1];
     expect(first.latDeg).toBeCloseTo(london.latDeg, 4);
     expect(first.lonDeg).toBeCloseTo(london.lonDeg, 4);
     expect(last.latDeg).toBeCloseTo(newYork.latDeg, 4);
@@ -165,7 +165,7 @@ describe('greatCircleWaypoints', () => {
   });
 
   it('totalDistanceM matches vincentyInverse result', () => {
-    const route   = greatCircleWaypoints(london, newYork, 4);
+    const route = greatCircleWaypoints(london, newYork, 4);
     const vincenty = vincentyInverse(london, newYork);
     expect(route.totalDistanceM).toBeCloseTo(vincenty.distanceM, 0);
   });
@@ -187,10 +187,10 @@ describe('pointInGeofence', () => {
   const parisFence = {
     id: 'paris-box',
     vertices: [
-      { latDeg: 48.80, lonDeg: 2.25 },
+      { latDeg: 48.8, lonDeg: 2.25 },
       { latDeg: 48.92, lonDeg: 2.25 },
       { latDeg: 48.92, lonDeg: 2.42 },
-      { latDeg: 48.80, lonDeg: 2.42 },
+      { latDeg: 48.8, lonDeg: 2.42 },
     ],
   };
 
@@ -231,7 +231,9 @@ describe('pointInGeofence', () => {
   });
 
   it('degenerate polygon (< 3 vertices) returns false', () => {
-    expect(pointInGeofence({ latDeg: 0, lonDeg: 0 }, { id: 'bad', vertices: [{ latDeg: 0, lonDeg: 0 }] })).toBe(false);
+    expect(
+      pointInGeofence({ latDeg: 0, lonDeg: 0 }, { id: 'bad', vertices: [{ latDeg: 0, lonDeg: 0 }] })
+    ).toBe(false);
   });
 });
 
@@ -239,7 +241,10 @@ describe('pointInGeofence', () => {
 
 describe('analyzeGeodesy', () => {
   it('returns converged=true for non-antipodal points', () => {
-    const r = analyzeGeodesy({ latDeg: 48.8566, lonDeg: 2.3522 }, { latDeg: 35.6762, lonDeg: 139.6503 });
+    const r = analyzeGeodesy(
+      { latDeg: 48.8566, lonDeg: 2.3522 },
+      { latDeg: 35.6762, lonDeg: 139.6503 }
+    );
     expect(r.converged).toBe(true);
   });
 
@@ -252,7 +257,10 @@ describe('analyzeGeodesy', () => {
 
 describe('buildGeodesyReceipt', () => {
   it('produces receipt with plugin=geolocation-gis and CAEL event', () => {
-    const result  = analyzeGeodesy({ latDeg: 51.5074, lonDeg: -0.1278 }, { latDeg: 40.7128, lonDeg: -74.0060 });
+    const result = analyzeGeodesy(
+      { latDeg: 51.5074, lonDeg: -0.1278 },
+      { latDeg: 40.7128, lonDeg: -74.006 }
+    );
     const receipt = buildGeodesyReceipt(result);
     expect(receipt.plugin).toBe('geolocation-gis');
     expect(receipt.cael.event).toBe('geolocation_gis.geodesy');
@@ -260,21 +268,24 @@ describe('buildGeodesyReceipt', () => {
   });
 
   it('accepted=true for convergent analysis', () => {
-    const result  = analyzeGeodesy({ latDeg: 0, lonDeg: 0 }, { latDeg: 1, lonDeg: 1 });
+    const result = analyzeGeodesy({ latDeg: 0, lonDeg: 0 }, { latDeg: 1, lonDeg: 1 });
     const receipt = buildGeodesyReceipt(result);
     expect(receipt.acceptance.accepted).toBe(true);
     expect(receipt.acceptance.violations).toHaveLength(0);
   });
 
   it('resultSummary.distanceKm matches vincenty distance', () => {
-    const result  = analyzeGeodesy({ latDeg: 51.5074, lonDeg: -0.1278 }, { latDeg: 40.7128, lonDeg: -74.0060 });
+    const result = analyzeGeodesy(
+      { latDeg: 51.5074, lonDeg: -0.1278 },
+      { latDeg: 40.7128, lonDeg: -74.006 }
+    );
     const receipt = buildGeodesyReceipt(result);
     // Receipt distance should match the Vincenty result (within floating-point rounding to 4 dp)
     expect(receipt.resultSummary.distanceKm).toBeCloseTo(result.vincenty.distanceM / 1000, 1);
   });
 
   it('uses provided runId', () => {
-    const result  = analyzeGeodesy({ latDeg: 0, lonDeg: 0 }, { latDeg: 10, lonDeg: 10 });
+    const result = analyzeGeodesy({ latDeg: 0, lonDeg: 0 }, { latDeg: 10, lonDeg: 10 });
     const receipt = buildGeodesyReceipt(result, { runId: 'geo-run-1' });
     expect(receipt.runId).toBe('geo-run-1');
   });

package/src/geodesy.ts

@@ -14,15 +14,12 @@
  *   WGS-84: NIMA TR8350.2 (3rd ed., 2000)
  */
 
-import {
-  DOMAIN_SIMULATION_RECEIPT_SCHEMA,
-  buildDomainSimulationReceipt,
-} from '@holoscript/core';
+import { DOMAIN_SIMULATION_RECEIPT_SCHEMA, buildDomainSimulationReceipt } from '@holoscript/core';
 
 // ─── WGS-84 constants ─────────────────────────────────────────────────────────
-const WGS84_A  = 6_378_137.0;                // semi-major axis (m)
-const WGS84_F  = 1 / 298.257_223_563;        // flattening
-const WGS84_B  = WGS84_A * (1 - WGS84_F);   // semi-minor axis (m)
+const WGS84_A = 6_378_137.0; // semi-major axis (m)
+const WGS84_F = 1 / 298.257_223_563; // flattening
+const WGS84_B = WGS84_A * (1 - WGS84_F); // semi-minor axis (m)
 const WGS84_E2 = 2 * WGS84_F - WGS84_F ** 2; // first eccentricity squared
 // second eccentricity squared
 const WGS84_EP2 = WGS84_E2 / (1 - WGS84_E2);
@@ -31,9 +28,9 @@ const WGS84_EP2 = WGS84_E2 / (1 - WGS84_E2);
 
 /** Geodetic coordinates (WGS-84). Lat/lon in decimal degrees, altitude in metres. */
 export interface LatLonAlt {
-  latDeg:  number; // −90 … +90
-  lonDeg:  number; // −180 … +180
-  altM:    number; // metres above WGS-84 ellipsoid
+  latDeg: number; // −90 … +90
+  lonDeg: number; // −180 … +180
+  altM: number; // metres above WGS-84 ellipsoid
 }
 
 /** Earth-Centered Earth-Fixed Cartesian coordinates (metres). */
@@ -45,47 +42,47 @@ export interface ECEF {
 
 /** Geofence defined by an ordered list of vertices forming a closed polygon. */
 export interface GeofencePolygon {
-  id:       string;
+  id: string;
   vertices: { latDeg: number; lonDeg: number }[];
 }
 
 /** Result of Vincenty inverse computation. */
 export interface VincentyResult {
-  distanceM:        number; // geodesic distance (m)
+  distanceM: number; // geodesic distance (m)
   forwardAzimuthDeg: number; // bearing from p1 → p2 (deg, 0=N, 90=E)
-  backAzimuthDeg:   number; // bearing from p2 → p1 (deg)
+  backAzimuthDeg: number; // bearing from p2 → p1 (deg)
   /** true if points are antipodal (distance undefined within machine epsilon) */
-  antipodal:        boolean;
+  antipodal: boolean;
 }
 
 /** A sequence of waypoints along a great-circle path. */
 export interface GreatCircleRoute {
-  origin:      { latDeg: number; lonDeg: number };
+  origin: { latDeg: number; lonDeg: number };
   destination: { latDeg: number; lonDeg: number };
-  waypoints:   { latDeg: number; lonDeg: number; fractionOfTotal: number }[];
+  waypoints: { latDeg: number; lonDeg: number; fractionOfTotal: number }[];
   totalDistanceM: number;
 }
 
 /** Combined result from a full geodesy analysis session. */
 export interface GeodesyAnalysisResult {
-  vincenty:   VincentyResult;
-  route:      GreatCircleRoute;
+  vincenty: VincentyResult;
+  route: GreatCircleRoute;
   ecefOrigin: ECEF;
-  ecefDest:   ECEF;
-  converged:  boolean;
+  ecefDest: ECEF;
+  converged: boolean;
 }
 
 export interface GeodesyReceipt {
-  plugin:        string;
-  runId:         string;
-  payloadHash:   string;
+  plugin: string;
+  runId: string;
+  payloadHash: string;
   hashAlgorithm: string;
-  cael:          { event: string; schemaVersion: string; ts: string };
-  acceptance:    { accepted: boolean; violations: string[] };
+  cael: { event: string; schemaVersion: string; ts: string };
+  acceptance: { accepted: boolean; violations: string[] };
   resultSummary: {
-    distanceKm:         number;
-    forwardAzimuthDeg:  number;
-    waypointCount:      number;
+    distanceKm: number;
+    forwardAzimuthDeg: number;
+    waypointCount: number;
   };
 }
 
@@ -94,9 +91,15 @@ export interface GeodesyReceipt {
 const DEG = Math.PI / 180;
 const RAD = 180 / Math.PI;
 
-function toRad(deg: number): number { return deg * DEG; }
-function toDeg(rad: number): number { return rad * RAD; }
-function normalizeDeg(d: number): number { return ((d % 360) + 360) % 360; }
+function toRad(deg: number): number {
+  return deg * DEG;
+}
+function toDeg(rad: number): number {
+  return rad * RAD;
+}
+function normalizeDeg(d: number): number {
+  return ((d % 360) + 360) % 360;
+}
 
 /** Prime vertical radius of curvature N(φ) */
 function primeVerticalRadius(sinPhi: number): number {
@@ -112,17 +115,19 @@ function primeVerticalRadius(sinPhi: number): number {
  */
 export function vincentyInverse(
   p1: { latDeg: number; lonDeg: number },
-  p2: { latDeg: number; lonDeg: number },
+  p2: { latDeg: number; lonDeg: number }
 ): VincentyResult {
   const phi1 = toRad(p1.latDeg);
   const phi2 = toRad(p2.latDeg);
-  const L    = toRad(p2.lonDeg - p1.lonDeg);
+  const L = toRad(p2.lonDeg - p1.lonDeg);
 
   const U1 = Math.atan((1 - WGS84_F) * Math.tan(phi1));
   const U2 = Math.atan((1 - WGS84_F) * Math.tan(phi2));
 
-  const sinU1 = Math.sin(U1), cosU1 = Math.cos(U1);
-  const sinU2 = Math.sin(U2), cosU2 = Math.cos(U2);
+  const sinU1 = Math.sin(U1),
+    cosU1 = Math.cos(U1);
+  const sinU2 = Math.sin(U2),
+    cosU2 = Math.cos(U2);
 
   let lambda = L;
   let lambdaP: number;
@@ -137,8 +142,7 @@ export function vincentyInverse(
     cosLambda = Math.cos(lambda);
 
     sinSigma = Math.sqrt(
-      (cosU2 * sinLambda) ** 2 +
-      (cosU1 * sinU2 - sinU1 * cosU2 * cosLambda) ** 2,
+      (cosU2 * sinLambda) ** 2 + (cosU1 * sinU2 - sinU1 * cosU2 * cosLambda) ** 2
     );
 
     if (sinSigma === 0) {
@@ -146,35 +150,37 @@ export function vincentyInverse(
       return { distanceM: 0, forwardAzimuthDeg: 0, backAzimuthDeg: 0, antipodal: false };
     }
 
-    cosSigma  = sinU1 * sinU2 + cosU1 * cosU2 * cosLambda;
-    sigma     = Math.atan2(sinSigma, cosSigma);
-    sinAlpha  = (cosU1 * cosU2 * sinLambda) / sinSigma;
+    cosSigma = sinU1 * sinU2 + cosU1 * cosU2 * cosLambda;
+    sigma = Math.atan2(sinSigma, cosSigma);
+    sinAlpha = (cosU1 * cosU2 * sinLambda) / sinSigma;
     cos2Alpha = 1 - sinAlpha * sinAlpha;
 
-    cos2SigmaM = cos2Alpha !== 0
-      ? cosSigma - (2 * sinU1 * sinU2) / cos2Alpha
-      : 0; // equatorial line
+    cos2SigmaM = cos2Alpha !== 0 ? cosSigma - (2 * sinU1 * sinU2) / cos2Alpha : 0; // equatorial line
 
     C = (WGS84_F / 16) * cos2Alpha * (4 + WGS84_F * (4 - 3 * cos2Alpha));
 
     lambdaP = lambda;
-    lambda  = L + (1 - C) * WGS84_F * sinAlpha *
-              (sigma + C * sinSigma * (cos2SigmaM + C * cosSigma * (-1 + 2 * cos2SigmaM ** 2)));
-
+    lambda =
+      L +
+      (1 - C) *
+        WGS84_F *
+        sinAlpha *
+        (sigma + C * sinSigma * (cos2SigmaM + C * cosSigma * (-1 + 2 * cos2SigmaM ** 2)));
   } while (Math.abs(lambda - lambdaP) > 1e-12 && ++iterations < 200);
 
   const antipodal = iterations >= 200;
 
-  const uSq  = cos2Alpha * WGS84_EP2;
+  const uSq = cos2Alpha * WGS84_EP2;
   const A_vc = 1 + (uSq / 16384) * (4096 + uSq * (-768 + uSq * (320 - 175 * uSq)));
   const B_vc = (uSq / 1024) * (256 + uSq * (-128 + uSq * (74 - 47 * uSq)));
 
-  const deltaSigma = B_vc * sinSigma * (
-    cos2SigmaM + (B_vc / 4) * (
-      cosSigma * (-1 + 2 * cos2SigmaM ** 2) -
-      (B_vc / 6) * cos2SigmaM * (-3 + 4 * sinSigma ** 2) * (-3 + 4 * cos2SigmaM ** 2)
-    )
-  );
+  const deltaSigma =
+    B_vc *
+    sinSigma *
+    (cos2SigmaM +
+      (B_vc / 4) *
+        (cosSigma * (-1 + 2 * cos2SigmaM ** 2) -
+          (B_vc / 6) * cos2SigmaM * (-3 + 4 * sinSigma ** 2) * (-3 + 4 * cos2SigmaM ** 2)));
 
   const distanceM = WGS84_B * A_vc * (sigma - deltaSigma);
 
@@ -184,7 +190,7 @@ export function vincentyInverse(
   return {
     distanceM,
     forwardAzimuthDeg: normalizeDeg(toDeg(fwdAz)),
-    backAzimuthDeg:    normalizeDeg(toDeg(bakAz)),
+    backAzimuthDeg: normalizeDeg(toDeg(bakAz)),
     antipodal,
   };
 }
@@ -193,13 +199,13 @@ export function vincentyInverse(
 
 /** Convert WGS-84 geodetic coordinates to ECEF Cartesian. */
 export function llaToECEF(lla: LatLonAlt): ECEF {
-  const phi    = toRad(lla.latDeg);
+  const phi = toRad(lla.latDeg);
   const lambda = toRad(lla.lonDeg);
-  const h      = lla.altM;
+  const h = lla.altM;
 
   const sinPhi = Math.sin(phi);
   const cosPhi = Math.cos(phi);
-  const N      = primeVerticalRadius(sinPhi);
+  const N = primeVerticalRadius(sinPhi);
 
   return {
     xM: (N + h) * cosPhi * Math.cos(lambda),
@@ -214,7 +220,7 @@ export function llaToECEF(lla: LatLonAlt): ECEF {
  */
 export function ecefToLLA(ecef: ECEF): LatLonAlt {
   const { xM, yM, zM } = ecef;
-  const p      = Math.sqrt(xM * xM + yM * yM);
+  const p = Math.sqrt(xM * xM + yM * yM);
   const lambda = Math.atan2(yM, xM);
 
   // Initial estimate (Bowring)
@@ -222,20 +228,23 @@ export function ecefToLLA(ecef: ECEF): LatLonAlt {
 
   for (let i = 0; i < 10; i++) {
     const sinPhi = Math.sin(phi);
-    const N      = primeVerticalRadius(sinPhi);
+    const N = primeVerticalRadius(sinPhi);
     const phiNew = Math.atan2(zM + WGS84_E2 * N * sinPhi, p);
-    if (Math.abs(phiNew - phi) < 1e-12) { phi = phiNew; break; }
+    if (Math.abs(phiNew - phi) < 1e-12) {
+      phi = phiNew;
+      break;
+    }
     phi = phiNew;
   }
 
   const sinPhi = Math.sin(phi);
-  const N      = primeVerticalRadius(sinPhi);
-  const h      = p / Math.cos(phi) - N;
+  const N = primeVerticalRadius(sinPhi);
+  const h = p / Math.cos(phi) - N;
 
   return {
     latDeg: toDeg(phi),
     lonDeg: toDeg(lambda),
-    altM:   h,
+    altM: h,
   };
 }
 
@@ -249,21 +258,22 @@ export function ecefToLLA(ecef: ECEF): LatLonAlt {
 export function greatCircleWaypoints(
   p1: { latDeg: number; lonDeg: number },
   p2: { latDeg: number; lonDeg: number },
-  numIntermediate = 8,
+  numIntermediate = 8
 ): GreatCircleRoute {
   const vincenty = vincentyInverse(p1, p2);
 
   // Convert to ECEF unit vectors (ignoring altitude — surface only)
   const toUnitVec = (p: { latDeg: number; lonDeg: number }) => {
-    const phi = toRad(p.latDeg), lam = toRad(p.lonDeg);
-    const cp  = Math.cos(phi);
+    const phi = toRad(p.latDeg),
+      lam = toRad(p.lonDeg);
+    const cp = Math.cos(phi);
     return { x: cp * Math.cos(lam), y: cp * Math.sin(lam), z: Math.sin(phi) };
   };
 
   const v1 = toUnitVec(p1);
   const v2 = toUnitVec(p2);
 
-  const dot   = v1.x * v2.x + v1.y * v2.y + v1.z * v2.z;
+  const dot = v1.x * v2.x + v1.y * v2.y + v1.z * v2.z;
   const omega = Math.acos(Math.max(-1, Math.min(1, dot))); // angular separation
 
   const total = numIntermediate + 2;
@@ -271,7 +281,9 @@ export function greatCircleWaypoints(
     const t = k / (total - 1);
     let vx: number, vy: number, vz: number;
     if (omega < 1e-10) {
-      vx = v1.x; vy = v1.y; vz = v1.z;
+      vx = v1.x;
+      vy = v1.y;
+      vz = v1.z;
     } else {
       const s = Math.sin(omega);
       const a = Math.sin((1 - t) * omega) / s;
@@ -287,8 +299,8 @@ export function greatCircleWaypoints(
   });
 
   return {
-    origin:        { latDeg: p1.latDeg, lonDeg: p1.lonDeg },
-    destination:   { latDeg: p2.latDeg, lonDeg: p2.lonDeg },
+    origin: { latDeg: p1.latDeg, lonDeg: p1.lonDeg },
+    destination: { latDeg: p2.latDeg, lonDeg: p2.lonDeg },
     waypoints,
     totalDistanceM: vincenty.distanceM,
   };
@@ -303,36 +315,36 @@ export function greatCircleWaypoints(
  * Returns true if the point is inside or on the boundary.
  */
 export function pointInGeofence(
-  point:   { latDeg: number; lonDeg: number },
-  polygon: GeofencePolygon,
+  point: { latDeg: number; lonDeg: number },
+  polygon: GeofencePolygon
 ): boolean {
   const verts = polygon.vertices;
   if (verts.length < 3) return false;
 
   // Project all vertices and test point onto flat plane using gnomonic projection
   // centred on the first vertex (good for polygons up to ~500 km wide).
-  const phi0   = toRad(verts[0].latDeg);
-  const lam0   = toRad(verts[0].lonDeg);
+  const phi0 = toRad(verts[0].latDeg);
+  const lam0 = toRad(verts[0].lonDeg);
   const cosPhi0 = Math.cos(phi0);
   const sinPhi0 = Math.sin(phi0);
 
   const project = (lat: number, lon: number): [number, number] => {
-    const phi = toRad(lat), lam = toRad(lon);
-    const c   = sinPhi0 * Math.sin(phi) + cosPhi0 * Math.cos(phi) * Math.cos(lam - lam0);
-    const x   = Math.cos(phi) * Math.sin(lam - lam0) / c;
-    const y   = (cosPhi0 * Math.sin(phi) - sinPhi0 * Math.cos(phi) * Math.cos(lam - lam0)) / c;
+    const phi = toRad(lat),
+      lam = toRad(lon);
+    const c = sinPhi0 * Math.sin(phi) + cosPhi0 * Math.cos(phi) * Math.cos(lam - lam0);
+    const x = (Math.cos(phi) * Math.sin(lam - lam0)) / c;
+    const y = (cosPhi0 * Math.sin(phi) - sinPhi0 * Math.cos(phi) * Math.cos(lam - lam0)) / c;
     return [x, y];
   };
 
   const [px, py] = project(point.latDeg, point.lonDeg);
-  const n        = verts.length;
-  let inside     = false;
+  const n = verts.length;
+  let inside = false;
 
   for (let i = 0, j = n - 1; i < n; j = i++) {
     const [xi, yi] = project(verts[i].latDeg, verts[i].lonDeg);
     const [xj, yj] = project(verts[j].latDeg, verts[j].lonDeg);
-    const intersect = yi > py !== yj > py &&
-                      px < ((xj - xi) * (py - yi)) / (yj - yi) + xi;
+    const intersect = yi > py !== yj > py && px < ((xj - xi) * (py - yi)) / (yj - yi) + xi;
     if (intersect) inside = !inside;
   }
 
@@ -347,17 +359,17 @@ export function pointInGeofence(
 export function analyzeGeodesy(
   origin: { latDeg: number; lonDeg: number; altM?: number },
   destination: { latDeg: number; lonDeg: number; altM?: number },
-  numWaypoints = 8,
+  numWaypoints = 8
 ): GeodesyAnalysisResult {
-  const p1  = { latDeg: origin.latDeg, lonDeg: origin.lonDeg };
-  const p2  = { latDeg: destination.latDeg, lonDeg: destination.lonDeg };
+  const p1 = { latDeg: origin.latDeg, lonDeg: origin.lonDeg };
+  const p2 = { latDeg: destination.latDeg, lonDeg: destination.lonDeg };
   const lla1: LatLonAlt = { ...p1, altM: origin.altM ?? 0 };
   const lla2: LatLonAlt = { ...p2, altM: destination.altM ?? 0 };
 
-  const vincenty   = vincentyInverse(p1, p2);
-  const route      = greatCircleWaypoints(p1, p2, numWaypoints);
+  const vincenty = vincentyInverse(p1, p2);
+  const route = greatCircleWaypoints(p1, p2, numWaypoints);
   const ecefOrigin = llaToECEF(lla1);
-  const ecefDest   = llaToECEF(lla2);
+  const ecefDest = llaToECEF(lla2);
 
   return { vincenty, route, ecefOrigin, ecefDest, converged: !vincenty.antipodal };
 }
@@ -366,31 +378,34 @@ export function analyzeGeodesy(
 
 export function buildGeodesyReceipt(
   result: GeodesyAnalysisResult,
-  options?: { runId?: string },
+  options?: { runId?: string }
 ): GeodesyReceipt {
   const violations: Array<{ criterion: string; message: string }> = [];
   if (result.vincenty.antipodal)
-    violations.push({ criterion: 'convergence', message: 'points are antipodal — geodesic undefined' });
+    violations.push({
+      criterion: 'convergence',
+      message: 'points are antipodal — geodesic undefined',
+    });
   if (!result.converged)
     violations.push({ criterion: 'convergence', message: 'Vincenty iteration did not converge' });
 
   const raw = buildDomainSimulationReceipt({
-    plugin:        'geolocation-gis',
+    plugin: 'geolocation-gis',
     pluginVersion: '1.0.0',
-    runId:         options?.runId ?? `geo-${Date.now().toString(36)}`,
-    modelId:       'geodesy-analysis',
+    runId: options?.runId ?? `geo-${Date.now().toString(36)}`,
+    modelId: 'geodesy-analysis',
     solverConfig: {
       solverType: 'vincenty-wgs84',
-      scale:      'global',
+      scale: 'global',
     },
     resultSummary: {
-      distanceKm:        +(result.vincenty.distanceM / 1000).toFixed(4),
+      distanceKm: +(result.vincenty.distanceM / 1000).toFixed(4),
       forwardAzimuthDeg: +result.vincenty.forwardAzimuthDeg.toFixed(4),
-      waypointCount:     result.route.waypoints.length,
+      waypointCount: result.route.waypoints.length,
     },
     cael: {
-      version:    'cael.v1',
-      event:      'geolocation_gis.geodesy',
+      version: 'cael.v1',
+      event: 'geolocation_gis.geodesy',
       solverType: 'geolocation-gis.vincenty-wgs84',
     },
     acceptance: { accepted: violations.length === 0, violations },

package/src/index.ts

@@ -13,8 +13,18 @@ import { createGeofenceHandler } from './traits/GeofenceTrait';
 
 export * from './geodesy';
 
-export const pluginMeta = { name: '@holoscript/plugin-geolocation-gis', version: '1.0.0', traits: ['map_view', 'route', 'poi', 'geocode', 'geofence', 'vincenty_geodesy'] };
-export const traitHandlers = [createMapViewHandler(), createRouteHandler(), createPOIHandler(), createGeocodeHandler(), createGeofenceHandler()];
+export const pluginMeta = {
+  name: '@holoscript/plugin-geolocation-gis',
+  version: '1.0.0',
+  traits: ['map_view', 'route', 'poi', 'geocode', 'geofence', 'vincenty_geodesy'],
+};
+export const traitHandlers = [
+  createMapViewHandler(),
+  createRouteHandler(),
+  createPOIHandler(),
+  createGeocodeHandler(),
+  createGeofenceHandler(),
+];
 
 // Runtime integration — behavioral `vincenty_geodesy` handler + opt-in registrar
 // that wire the real Vincenty solver into HoloScriptRuntime via the shared P1

package/src/runtime.ts

@@ -48,13 +48,13 @@ export interface RuntimeTraitHandler {
   onAttach?: (
     node: unknown,
     config: VincentyGeodesyTraitConfig,
-    context: TraitDispatchContext,
+    context: TraitDispatchContext
   ) => void;
   onUpdate?: (
     node: unknown,
     config: VincentyGeodesyTraitConfig,
     context: TraitDispatchContext,
-    delta: number,
+    delta: number
   ) => void;
 }
 
@@ -69,7 +69,7 @@ interface VincentyNode {
 function solveOntoNode(
   node: unknown,
   config: VincentyGeodesyTraitConfig | undefined,
-  context: TraitDispatchContext,
+  context: TraitDispatchContext
 ): void {
   const carrier = node as VincentyNode;
   const nodeId = carrier.id ?? carrier.name ?? 'unknown';

package/src/traits/GeocodeTrait.ts

@@ -1,18 +1,38 @@
 /** @geocode Trait — Address to coordinate conversion. @trait geocode */
 import type { TraitHandler, HSPlusNode, TraitContext, TraitEvent } from './types';
 
-export interface GeocodeConfig { address: string; provider: 'nominatim' | 'google' | 'mapbox'; language: string; }
+export interface GeocodeConfig {
+  address: string;
+  provider: 'nominatim' | 'google' | 'mapbox';
+  language: string;
+}
 const defaultConfig: GeocodeConfig = { address: '', provider: 'nominatim', language: 'en' };
 
 export function createGeocodeHandler(): TraitHandler<GeocodeConfig> {
-  return { name: 'geocode', defaultConfig,
-    onAttach(n: HSPlusNode, _c: GeocodeConfig, ctx: TraitContext) { n.__geocodeState = { result: null, isGeocoding: false }; ctx.emit?.('geocode:ready'); },
-    onDetach(n: HSPlusNode, _c: GeocodeConfig, ctx: TraitContext) { delete n.__geocodeState; ctx.emit?.('geocode:detached'); },
+  return {
+    name: 'geocode',
+    defaultConfig,
+    onAttach(n: HSPlusNode, _c: GeocodeConfig, ctx: TraitContext) {
+      n.__geocodeState = { result: null, isGeocoding: false };
+      ctx.emit?.('geocode:ready');
+    },
+    onDetach(n: HSPlusNode, _c: GeocodeConfig, ctx: TraitContext) {
+      delete n.__geocodeState;
+      ctx.emit?.('geocode:detached');
+    },
     onUpdate() {},
     onEvent(n: HSPlusNode, _c: GeocodeConfig, ctx: TraitContext, e: TraitEvent) {
-      const s = n.__geocodeState as Record<string, unknown> | undefined; if (!s) return;
-      if (e.type === 'geocode:lookup') { s.isGeocoding = true; ctx.emit?.('geocode:searching', { address: e.payload?.address }); }
-      if (e.type === 'geocode:result') { s.result = e.payload; s.isGeocoding = false; ctx.emit?.('geocode:found', e.payload); }
+      const s = n.__geocodeState as Record<string, unknown> | undefined;
+      if (!s) return;
+      if (e.type === 'geocode:lookup') {
+        s.isGeocoding = true;
+        ctx.emit?.('geocode:searching', { address: e.payload?.address });
+      }
+      if (e.type === 'geocode:result') {
+        s.result = e.payload;
+        s.isGeocoding = false;
+        ctx.emit?.('geocode:found', e.payload);
+      }
     },
   };
 }

package/src/traits/GeofenceTrait.ts

@@ -1,22 +1,47 @@
 /** @geofence Trait — Geographic boundary monitoring. @trait geofence */
 import type { TraitHandler, HSPlusNode, TraitContext, TraitEvent } from './types';
 
-export interface GeofenceConfig { center: { lat: number; lng: number }; radiusM: number; shape: 'circle' | 'polygon'; polygonPoints?: Array<{ lat: number; lng: number }>; triggerOnEnter: boolean; triggerOnExit: boolean; }
-const defaultConfig: GeofenceConfig = { center: { lat: 0, lng: 0 }, radiusM: 100, shape: 'circle', triggerOnEnter: true, triggerOnExit: true };
+export interface GeofenceConfig {
+  center: { lat: number; lng: number };
+  radiusM: number;
+  shape: 'circle' | 'polygon';
+  polygonPoints?: Array<{ lat: number; lng: number }>;
+  triggerOnEnter: boolean;
+  triggerOnExit: boolean;
+}
+const defaultConfig: GeofenceConfig = {
+  center: { lat: 0, lng: 0 },
+  radiusM: 100,
+  shape: 'circle',
+  triggerOnEnter: true,
+  triggerOnExit: true,
+};
 
 export function createGeofenceHandler(): TraitHandler<GeofenceConfig> {
-  return { name: 'geofence', defaultConfig,
-    onAttach(n: HSPlusNode, c: GeofenceConfig, ctx: TraitContext) { n.__geofenceState = { isInside: false, lastCheck: null }; ctx.emit?.('geofence:created', { radius: c.radiusM, shape: c.shape }); },
-    onDetach(n: HSPlusNode, _c: GeofenceConfig, ctx: TraitContext) { delete n.__geofenceState; ctx.emit?.('geofence:removed'); },
+  return {
+    name: 'geofence',
+    defaultConfig,
+    onAttach(n: HSPlusNode, c: GeofenceConfig, ctx: TraitContext) {
+      n.__geofenceState = { isInside: false, lastCheck: null };
+      ctx.emit?.('geofence:created', { radius: c.radiusM, shape: c.shape });
+    },
+    onDetach(n: HSPlusNode, _c: GeofenceConfig, ctx: TraitContext) {
+      delete n.__geofenceState;
+      ctx.emit?.('geofence:removed');
+    },
     onUpdate() {},
     onEvent(n: HSPlusNode, c: GeofenceConfig, ctx: TraitContext, e: TraitEvent) {
-      const s = n.__geofenceState as Record<string, unknown> | undefined; if (!s) return;
+      const s = n.__geofenceState as Record<string, unknown> | undefined;
+      if (!s) return;
       if (e.type === 'geofence:check') {
         const pos = e.payload as unknown as { lat: number; lng: number };
-        const dist = Math.sqrt(Math.pow(pos.lat - c.center.lat, 2) + Math.pow(pos.lng - c.center.lng, 2)) * 111320;
+        const dist =
+          Math.sqrt(Math.pow(pos.lat - c.center.lat, 2) + Math.pow(pos.lng - c.center.lng, 2)) *
+          111320;
         const inside = dist <= c.radiusM;
         const wasInside = s.isInside as boolean;
-        s.isInside = inside; s.lastCheck = Date.now();
+        s.isInside = inside;
+        s.lastCheck = Date.now();
         if (inside && !wasInside && c.triggerOnEnter) ctx.emit?.('geofence:entered');
         if (!inside && wasInside && c.triggerOnExit) ctx.emit?.('geofence:exited');
       }

package/src/traits/MapViewTrait.ts

@@ -1,18 +1,47 @@
 /** @map_view Trait — Interactive map display. @trait map_view */
 import type { TraitHandler, HSPlusNode, TraitContext, TraitEvent } from './types';
 
-export interface MapViewConfig { center: { lat: number; lng: number }; zoom: number; tileProvider: 'osm' | 'mapbox' | 'google' | 'custom'; style: 'streets' | 'satellite' | 'terrain' | 'dark'; maxZoom: number; minZoom: number; }
-const defaultConfig: MapViewConfig = { center: { lat: 0, lng: 0 }, zoom: 10, tileProvider: 'osm', style: 'streets', maxZoom: 18, minZoom: 1 };
+export interface MapViewConfig {
+  center: { lat: number; lng: number };
+  zoom: number;
+  tileProvider: 'osm' | 'mapbox' | 'google' | 'custom';
+  style: 'streets' | 'satellite' | 'terrain' | 'dark';
+  maxZoom: number;
+  minZoom: number;
+}
+const defaultConfig: MapViewConfig = {
+  center: { lat: 0, lng: 0 },
+  zoom: 10,
+  tileProvider: 'osm',
+  style: 'streets',
+  maxZoom: 18,
+  minZoom: 1,
+};
 
 export function createMapViewHandler(): TraitHandler<MapViewConfig> {
-  return { name: 'map_view', defaultConfig,
-    onAttach(n: HSPlusNode, c: MapViewConfig, ctx: TraitContext) { n.__mapState = { center: c.center, zoom: c.zoom, bounds: null }; ctx.emit?.('map:ready', { center: c.center }); },
-    onDetach(n: HSPlusNode, _c: MapViewConfig, ctx: TraitContext) { delete n.__mapState; ctx.emit?.('map:destroyed'); },
+  return {
+    name: 'map_view',
+    defaultConfig,
+    onAttach(n: HSPlusNode, c: MapViewConfig, ctx: TraitContext) {
+      n.__mapState = { center: c.center, zoom: c.zoom, bounds: null };
+      ctx.emit?.('map:ready', { center: c.center });
+    },
+    onDetach(n: HSPlusNode, _c: MapViewConfig, ctx: TraitContext) {
+      delete n.__mapState;
+      ctx.emit?.('map:destroyed');
+    },
     onUpdate() {},
     onEvent(n: HSPlusNode, _c: MapViewConfig, ctx: TraitContext, e: TraitEvent) {
-      const s = n.__mapState as Record<string, unknown> | undefined; if (!s) return;
-      if (e.type === 'map:pan') { s.center = e.payload?.center; ctx.emit?.('map:moved', { center: s.center }); }
-      if (e.type === 'map:zoom') { s.zoom = e.payload?.zoom; ctx.emit?.('map:zoomed', { zoom: s.zoom }); }
+      const s = n.__mapState as Record<string, unknown> | undefined;
+      if (!s) return;
+      if (e.type === 'map:pan') {
+        s.center = e.payload?.center;
+        ctx.emit?.('map:moved', { center: s.center });
+      }
+      if (e.type === 'map:zoom') {
+        s.zoom = e.payload?.zoom;
+        ctx.emit?.('map:zoomed', { zoom: s.zoom });
+      }
     },
   };
 }

package/src/traits/POITrait.ts

@@ -1,18 +1,41 @@
 /** @poi Trait — Point of Interest. @trait poi */
 import type { TraitHandler, HSPlusNode, TraitContext, TraitEvent } from './types';
 
-export interface POIConfig { name: string; lat: number; lng: number; category: string; icon?: string; description?: string; rating?: number; }
+export interface POIConfig {
+  name: string;
+  lat: number;
+  lng: number;
+  category: string;
+  icon?: string;
+  description?: string;
+  rating?: number;
+}
 const defaultConfig: POIConfig = { name: '', lat: 0, lng: 0, category: 'general' };
 
 export function createPOIHandler(): TraitHandler<POIConfig> {
-  return { name: 'poi', defaultConfig,
-    onAttach(n: HSPlusNode, c: POIConfig, ctx: TraitContext) { n.__poiState = { visible: true, selected: false }; ctx.emit?.('poi:added', { name: c.name, category: c.category }); },
-    onDetach(n: HSPlusNode, _c: POIConfig, ctx: TraitContext) { delete n.__poiState; ctx.emit?.('poi:removed'); },
+  return {
+    name: 'poi',
+    defaultConfig,
+    onAttach(n: HSPlusNode, c: POIConfig, ctx: TraitContext) {
+      n.__poiState = { visible: true, selected: false };
+      ctx.emit?.('poi:added', { name: c.name, category: c.category });
+    },
+    onDetach(n: HSPlusNode, _c: POIConfig, ctx: TraitContext) {
+      delete n.__poiState;
+      ctx.emit?.('poi:removed');
+    },
     onUpdate() {},
     onEvent(n: HSPlusNode, c: POIConfig, ctx: TraitContext, e: TraitEvent) {
-      const s = n.__poiState as Record<string, unknown> | undefined; if (!s) return;
-      if (e.type === 'poi:select') { s.selected = true; ctx.emit?.('poi:selected', { name: c.name }); }
-      if (e.type === 'poi:deselect') { s.selected = false; ctx.emit?.('poi:deselected'); }
+      const s = n.__poiState as Record<string, unknown> | undefined;
+      if (!s) return;
+      if (e.type === 'poi:select') {
+        s.selected = true;
+        ctx.emit?.('poi:selected', { name: c.name });
+      }
+      if (e.type === 'poi:deselect') {
+        s.selected = false;
+        ctx.emit?.('poi:deselected');
+      }
     },
   };
 }

package/src/traits/RouteTrait.ts

@@ -1,18 +1,58 @@
 /** @route Trait — Route planning and navigation. @trait route */
 import type { TraitHandler, HSPlusNode, TraitContext, TraitEvent } from './types';
 
-export interface Waypoint { lat: number; lng: number; label?: string; }
-export interface RouteConfig { origin: Waypoint; destination: Waypoint; waypoints: Waypoint[]; mode: 'driving' | 'walking' | 'cycling' | 'transit'; avoidTolls: boolean; avoidHighways: boolean; }
-const defaultConfig: RouteConfig = { origin: { lat: 0, lng: 0 }, destination: { lat: 0, lng: 0 }, waypoints: [], mode: 'driving', avoidTolls: false, avoidHighways: false };
+export interface Waypoint {
+  lat: number;
+  lng: number;
+  label?: string;
+}
+export interface RouteConfig {
+  origin: Waypoint;
+  destination: Waypoint;
+  waypoints: Waypoint[];
+  mode: 'driving' | 'walking' | 'cycling' | 'transit';
+  avoidTolls: boolean;
+  avoidHighways: boolean;
+}
+const defaultConfig: RouteConfig = {
+  origin: { lat: 0, lng: 0 },
+  destination: { lat: 0, lng: 0 },
+  waypoints: [],
+  mode: 'driving',
+  avoidTolls: false,
+  avoidHighways: false,
+};
 
 export function createRouteHandler(): TraitHandler<RouteConfig> {
-  return { name: 'route', defaultConfig,
-    onAttach(n: HSPlusNode, c: RouteConfig, ctx: TraitContext) { n.__routeState = { distanceKm: 0, durationMin: 0, isCalculating: false }; ctx.emit?.('route:created', { mode: c.mode }); },
-    onDetach(n: HSPlusNode, _c: RouteConfig, ctx: TraitContext) { delete n.__routeState; ctx.emit?.('route:cleared'); },
+  return {
+    name: 'route',
+    defaultConfig,
+    onAttach(n: HSPlusNode, c: RouteConfig, ctx: TraitContext) {
+      n.__routeState = { distanceKm: 0, durationMin: 0, isCalculating: false };
+      ctx.emit?.('route:created', { mode: c.mode });
+    },
+    onDetach(n: HSPlusNode, _c: RouteConfig, ctx: TraitContext) {
+      delete n.__routeState;
+      ctx.emit?.('route:cleared');
+    },
     onUpdate() {},
     onEvent(n: HSPlusNode, _c: RouteConfig, ctx: TraitContext, e: TraitEvent) {
-      if (e.type === 'route:calculate') { const s = n.__routeState as Record<string, unknown>; if (s) { s.isCalculating = true; ctx.emit?.('route:calculating'); } }
-      if (e.type === 'route:result') { const s = n.__routeState as Record<string, unknown>; if (s) { s.distanceKm = e.payload?.distanceKm; s.durationMin = e.payload?.durationMin; s.isCalculating = false; ctx.emit?.('route:calculated', e.payload); } }
+      if (e.type === 'route:calculate') {
+        const s = n.__routeState as Record<string, unknown>;
+        if (s) {
+          s.isCalculating = true;
+          ctx.emit?.('route:calculating');
+        }
+      }
+      if (e.type === 'route:result') {
+        const s = n.__routeState as Record<string, unknown>;
+        if (s) {
+          s.distanceKm = e.payload?.distanceKm;
+          s.durationMin = e.payload?.durationMin;
+          s.isCalculating = false;
+          ctx.emit?.('route:calculated', e.payload);
+        }
+      }
     },
   };
 }

package/src/traits/types.ts

@@ -1,4 +1,22 @@
-export interface HSPlusNode { id?: string; properties?: Record<string, unknown>; [key: string]: unknown; }
-export interface TraitContext { emit?: (event: string, payload?: unknown) => void; [key: string]: unknown; }
-export interface TraitEvent { type: string; payload?: Record<string, unknown>; [key: string]: unknown; }
-export interface TraitHandler<T = unknown> { name: string; defaultConfig: T; onAttach(n: HSPlusNode, c: T, ctx: TraitContext): void; onDetach(n: HSPlusNode, c: T, ctx: TraitContext): void; onUpdate(n: HSPlusNode, c: T, ctx: TraitContext, d: number): void; onEvent(n: HSPlusNode, c: T, ctx: TraitContext, e: TraitEvent): void; }
+export interface HSPlusNode {
+  id?: string;
+  properties?: Record<string, unknown>;
+  [key: string]: unknown;
+}
+export interface TraitContext {
+  emit?: (event: string, payload?: unknown) => void;
+  [key: string]: unknown;
+}
+export interface TraitEvent {
+  type: string;
+  payload?: Record<string, unknown>;
+  [key: string]: unknown;
+}
+export interface TraitHandler<T = unknown> {
+  name: string;
+  defaultConfig: T;
+  onAttach(n: HSPlusNode, c: T, ctx: TraitContext): void;
+  onDetach(n: HSPlusNode, c: T, ctx: TraitContext): void;
+  onUpdate(n: HSPlusNode, c: T, ctx: TraitContext, d: number): void;
+  onEvent(n: HSPlusNode, c: T, ctx: TraitContext, e: TraitEvent): void;
+}

package/tsconfig.json

@@ -1 +1,5 @@
-{ "extends": "../../../tsconfig.json", "compilerOptions": { "outDir": "dist", "rootDir": "src", "declaration": true }, "include": ["src"] }
+{
+  "extends": "../../../tsconfig.json",
+  "compilerOptions": { "outDir": "dist", "rootDir": "src", "declaration": true },
+  "include": ["src"]
+}

package/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2025-2026 HoloScript Contributors
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.