@ingissa/navcore-simulator 1.0.4 → 1.0.7

package/dist/core/src/geo/cumulative.js

@@ -0,0 +1,20 @@
+/**
+ * Pre-calculated cumulative distance caches.
+ */
+import { haversineDistance } from './haversine';
+/** Forward cumulative distances: result[i] = metres from route[0] to route[i]. O(n) build. */
+export function buildForwardCumulativeDistances(route) {
+    const cum = new Float64Array(route.length);
+    for (let i = 1; i < route.length; i++) {
+        cum[i] = cum[i - 1] + haversineDistance(route[i - 1][1], route[i - 1][0], route[i][1], route[i][0]);
+    }
+    return cum;
+}
+/** Reverse cumulative distances: result[i] = metres from vertex i to the end. O(1) reads. */
+export function buildReverseCumulativeDistances(route) {
+    const cum = new Float64Array(route.length);
+    for (let i = route.length - 2; i >= 0; i--) {
+        cum[i] = cum[i + 1] + haversineDistance(route[i][1], route[i][0], route[i + 1][1], route[i + 1][0]);
+    }
+    return cum;
+}

package/dist/core/src/geo/haversine.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Haversine geographic math utilities.
+ * ZERO dependencies — pure math.
+ */
+/** [longitude, latitude] coordinate */
+export type Coordinate = [number, number];
+/** Haversine distance between two points in metres */
+export declare function haversineDistance(lat1: number, lon1: number, lat2: number, lon2: number): number;
+/** Forward Haversine: compute destination given start, bearing (°), distance (m) */
+export declare function destinationPoint(lat: number, lon: number, brng: number, dist: number): Coordinate;
+/** Bearing between two [lng, lat] coordinates in degrees [0, 360) */
+export declare function getBearingBetweenPoints(c1: Coordinate, c2: Coordinate): number;
+//# sourceMappingURL=haversine.d.ts.map

package/dist/core/src/geo/haversine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"haversine.d.ts","sourceRoot":"","sources":["../../../../../core/src/geo/haversine.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,uCAAuC;AACvC,MAAM,MAAM,UAAU,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;AAI1C,sDAAsD;AACtD,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAShG;AAED,oFAAoF;AACpF,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,UAAU,CAgBjG;AAED,qEAAqE;AACrE,wBAAgB,uBAAuB,CAAC,EAAE,EAAE,UAAU,EAAE,EAAE,EAAE,UAAU,GAAG,MAAM,CAa9E"}

package/dist/core/src/geo/haversine.js

@@ -0,0 +1,39 @@
+/**
+ * Haversine geographic math utilities.
+ * ZERO dependencies — pure math.
+ */
+const R_EARTH = 6371000;
+/** Haversine distance between two points in metres */
+export function haversineDistance(lat1, lon1, lat2, lon2) {
+    const dLat = (lat2 - lat1) * (Math.PI / 180);
+    const dLon = (lon2 - lon1) * (Math.PI / 180);
+    const a = Math.sin(dLat / 2) * Math.sin(dLat / 2) +
+        Math.cos(lat1 * (Math.PI / 180)) * Math.cos(lat2 * (Math.PI / 180)) *
+            Math.sin(dLon / 2) * Math.sin(dLon / 2);
+    const c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
+    return R_EARTH * c;
+}
+/** Forward Haversine: compute destination given start, bearing (°), distance (m) */
+export function destinationPoint(lat, lon, brng, dist) {
+    const angularDist = dist / R_EARTH;
+    const brngRad = brng * (Math.PI / 180);
+    const latRad = lat * (Math.PI / 180);
+    const lonRad = lon * (Math.PI / 180);
+    const destLatRad = Math.asin(Math.sin(latRad) * Math.cos(angularDist) +
+        Math.cos(latRad) * Math.sin(angularDist) * Math.cos(brngRad));
+    const destLonRad = lonRad + Math.atan2(Math.sin(brngRad) * Math.sin(angularDist) * Math.cos(latRad), Math.cos(angularDist) - Math.sin(latRad) * Math.sin(destLatRad));
+    return [((destLonRad * 180 / Math.PI) + 540) % 360 - 180, destLatRad * 180 / Math.PI];
+}
+/** Bearing between two [lng, lat] coordinates in degrees [0, 360) */
+export function getBearingBetweenPoints(c1, c2) {
+    const lat1 = c1[1] * (Math.PI / 180);
+    const lon1 = c1[0] * (Math.PI / 180);
+    const lat2 = c2[1] * (Math.PI / 180);
+    const lon2 = c2[0] * (Math.PI / 180);
+    const y = Math.sin(lon2 - lon1) * Math.cos(lat2);
+    const x = Math.cos(lat1) * Math.sin(lat2) -
+        Math.sin(lat1) * Math.cos(lat2) * Math.cos(lon2 - lon1);
+    let brng = Math.atan2(y, x) * (180 / Math.PI);
+    brng = (brng + 360) % 360;
+    return brng;
+}

package/dist/core/src/geo/projection.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Vector projection utilities for coordinate snapping.
+ */
+import type { Coordinate } from './haversine';
+/** Project point p onto line segment [a, b]. Returns the projected coordinate. */
+export declare function projectPointOnSegment(p: Coordinate, a: Coordinate, b: Coordinate): Coordinate;
+//# sourceMappingURL=projection.d.ts.map

package/dist/core/src/geo/projection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"projection.d.ts","sourceRoot":"","sources":["../../../../../core/src/geo/projection.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAE9C,kFAAkF;AAClF,wBAAgB,qBAAqB,CAAC,CAAC,EAAE,UAAU,EAAE,CAAC,EAAE,UAAU,EAAE,CAAC,EAAE,UAAU,GAAG,UAAU,CAe7F"}

package/dist/core/src/geo/projection.js

@@ -0,0 +1,17 @@
+/**
+ * Vector projection utilities for coordinate snapping.
+ */
+/** Project point p onto line segment [a, b]. Returns the projected coordinate. */
+export function projectPointOnSegment(p, a, b) {
+    const [px, py] = p;
+    const [ax, ay] = a;
+    const [bx, by] = b;
+    const dx = bx - ax;
+    const dy = by - ay;
+    const lenSq = dx * dx + dy * dy;
+    if (lenSq === 0)
+        return a;
+    let t = ((px - ax) * dx + (py - ay) * dy) / lenSq;
+    t = Math.max(0, Math.min(1, t));
+    return [ax + t * dx, ay + t * dy];
+}

package/dist/core/src/geofencing/GeofencingEngine.d.ts

@@ -0,0 +1,93 @@
+/**
+ * GeofencingEngine
+ *
+ * Circular and polygon geofences — zero server dependency.
+ * Uses haversine distance for circles and ray-casting for polygons.
+ *
+ * FEATURE: GEOFENCING
+ *
+ * @example
+ * ```typescript
+ * const geo = new GeofencingEngine({ dwellThresholdMs: 5000 });
+ * geo.addCircle('school-zone', 'School Zone', [2.347, 48.859], 50, { speedLimit: 30 });
+ * geo.addPolygon('exam-area', 'Exam District', [[2.34, 48.85], [2.36, 48.85], [2.36, 48.87], [2.34, 48.87]]);
+ *
+ * engine.on('update', ({ snappedCoord }) => {
+ *   const events = geo.update(snappedCoord);
+ *   for (const evt of events) {
+ *     // evt.name is the human-readable zone name
+ *     console.log(`${evt.type}: ${evt.name} (${evt.id})`);
+ *   }
+ * });
+ * ```
+ */
+import type { Coordinate } from '../geo/haversine';
+export type GeofenceType = 'circle' | 'polygon';
+export type GeofenceEventType = 'enter' | 'exit' | 'dwell';
+export interface GeofenceEvent {
+    /** Geofence ID that triggered the event */
+    id: string;
+    /** Human-readable name of the geofence */
+    name: string;
+    type: GeofenceEventType;
+    /** Coordinate that triggered the event */
+    coord: Coordinate;
+    /** Milliseconds spent inside (for dwell events) */
+    dwellMs?: number;
+    /** Custom metadata passed at creation */
+    meta?: unknown;
+}
+export interface ZoneDefinition {
+    id: string;
+    name: string;
+    type: 'circle' | 'polygon';
+    center?: Coordinate;
+    radiusMeters?: number;
+    coords?: Coordinate[];
+    meta?: unknown;
+}
+export interface GeofencingOptions {
+    /**
+     * Milliseconds a vehicle must remain inside a geofence before a 'dwell' event fires.
+     * Default: 10000ms (10 seconds).
+     */
+    dwellThresholdMs?: number;
+    /** Initial zones to register on creation */
+    zones?: ZoneDefinition[];
+    /** Callback for all geofence events */
+    onEvent?: (event: GeofenceEvent) => void;
+}
+export declare class GeofencingEngine {
+    private fences;
+    private states;
+    private readonly options;
+    constructor(options?: GeofencingOptions);
+    /** Add a circular geofence. Returns the ID. */
+    addCircle(id: string, name: string, center: Coordinate, radiusM: number, meta?: unknown): string;
+    /**
+     * Add a polygon geofence. Coords are [lng, lat] pairs.
+     * The polygon is auto-closed (first == last not required).
+     */
+    addPolygon(id: string, name: string, coords: Coordinate[], meta?: unknown): string;
+    /** Remove a geofence by ID */
+    remove(id: string): void;
+    /** Remove all geofences */
+    clear(): void;
+    /** List all registered geofence IDs */
+    listIds(): string[];
+    /**
+     * Feed the current coordinate and receive a (possibly empty) list of events.
+     * Call this on every NavCore state update.
+     */
+    update(coord: Coordinate): GeofenceEvent[];
+    /** Check if a coordinate is currently inside a named geofence */
+    isInside(id: string, coord: Coordinate): boolean;
+    private contains;
+    /**
+     * Ray-casting point-in-polygon algorithm.
+     * Works in [lng, lat] space (sufficient for small areas; use projected
+     * coords for very large polygons spanning many degrees).
+     */
+    private pointInPolygon;
+}
+//# sourceMappingURL=GeofencingEngine.d.ts.map

package/dist/core/src/geofencing/GeofencingEngine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GeofencingEngine.d.ts","sourceRoot":"","sources":["../../../../../core/src/geofencing/GeofencingEngine.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAKnD,MAAM,MAAM,YAAY,GAAG,QAAQ,GAAG,SAAS,CAAC;AAChD,MAAM,MAAM,iBAAiB,GAAG,OAAO,GAAG,MAAM,GAAG,OAAO,CAAC;AAE3D,MAAM,WAAW,aAAa;IAC5B,2CAA2C;IAC3C,EAAE,EAAE,MAAM,CAAC;IACX,0CAA0C;IAC1C,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,iBAAiB,CAAC;IACxB,0CAA0C;IAC1C,KAAK,EAAE,UAAU,CAAC;IAClB,mDAAmD;IACnD,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,yCAAyC;IACzC,IAAI,CAAC,EAAE,OAAO,CAAC;CAChB;AAqBD,MAAM,WAAW,cAAc;IAC7B,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,QAAQ,GAAG,SAAS,CAAC;IAC3B,MAAM,CAAC,EAAE,UAAU,CAAC;IACpB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,MAAM,CAAC,EAAE,UAAU,EAAE,CAAC;IACtB,IAAI,CAAC,EAAE,OAAO,CAAC;CAChB;AAOD,MAAM,WAAW,iBAAiB;IAChC;;;OAGG;IACH,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,4CAA4C;IAC5C,KAAK,CAAC,EAAE,cAAc,EAAE,CAAC;IACzB,uCAAuC;IACvC,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,aAAa,KAAK,IAAI,CAAC;CAC1C;AAMD,qBAAa,gBAAgB;IAC3B,OAAO,CAAC,MAAM,CAA+B;IAC7C,OAAO,CAAC,MAAM,CAAoC;IAClD,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAsC;gBAElD,OAAO,CAAC,EAAE,iBAAiB;IAgBvC,+CAA+C;IAC/C,SAAS,CAAC,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,OAAO,GAAG,MAAM;IAMhG;;;OAGG;IACH,UAAU,CAAC,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE,EAAE,IAAI,CAAC,EAAE,OAAO,GAAG,MAAM;IAOlF,8BAA8B;IAC9B,MAAM,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI;IAKxB,2BAA2B;IAC3B,KAAK,IAAI,IAAI;IAKb,uCAAuC;IACvC,OAAO,IAAI,MAAM,EAAE;IAMnB;;;OAGG;IACH,MAAM,CAAC,KAAK,EAAE,UAAU,GAAG,aAAa,EAAE;IA2C1C,iEAAiE;IACjE,QAAQ,CAAC,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE,UAAU,GAAG,OAAO;IAQhD,OAAO,CAAC,QAAQ;IAWhB;;;;OAIG;IACH,OAAO,CAAC,cAAc;CAkBvB"}

package/dist/core/src/geofencing/GeofencingEngine.js

@@ -0,0 +1,154 @@
+/**
+ * GeofencingEngine
+ *
+ * Circular and polygon geofences — zero server dependency.
+ * Uses haversine distance for circles and ray-casting for polygons.
+ *
+ * FEATURE: GEOFENCING
+ *
+ * @example
+ * ```typescript
+ * const geo = new GeofencingEngine({ dwellThresholdMs: 5000 });
+ * geo.addCircle('school-zone', 'School Zone', [2.347, 48.859], 50, { speedLimit: 30 });
+ * geo.addPolygon('exam-area', 'Exam District', [[2.34, 48.85], [2.36, 48.85], [2.36, 48.87], [2.34, 48.87]]);
+ *
+ * engine.on('update', ({ snappedCoord }) => {
+ *   const events = geo.update(snappedCoord);
+ *   for (const evt of events) {
+ *     // evt.name is the human-readable zone name
+ *     console.log(`${evt.type}: ${evt.name} (${evt.id})`);
+ *   }
+ * });
+ * ```
+ */
+import { haversineDistance } from '../geo/haversine';
+const DEFAULTS = {
+    dwellThresholdMs: 10000,
+};
+export class GeofencingEngine {
+    constructor(options) {
+        this.fences = new Map();
+        this.states = new Map();
+        this.options = { ...DEFAULTS, ...options };
+        if (this.options.zones) {
+            for (const z of this.options.zones) {
+                if (z.type === 'circle' && z.center && z.radiusMeters) {
+                    this.addCircle(z.id, z.name, z.center, z.radiusMeters, z.meta);
+                }
+                else if (z.type === 'polygon' && z.coords) {
+                    this.addPolygon(z.id, z.name, z.coords, z.meta);
+                }
+            }
+        }
+    }
+    // ── Registration ────────────────────────────────────────────────────────────
+    /** Add a circular geofence. Returns the ID. */
+    addCircle(id, name, center, radiusM, meta) {
+        this.fences.set(id, { kind: 'circle', id, name, center, radiusM, meta });
+        this.states.set(id, { inside: false, enteredAtMs: null });
+        return id;
+    }
+    /**
+     * Add a polygon geofence. Coords are [lng, lat] pairs.
+     * The polygon is auto-closed (first == last not required).
+     */
+    addPolygon(id, name, coords, meta) {
+        if (coords.length < 3)
+            throw new Error('[Geofencing] Polygon requires at least 3 coordinates');
+        this.fences.set(id, { kind: 'polygon', id, name, coords, meta });
+        this.states.set(id, { inside: false, enteredAtMs: null });
+        return id;
+    }
+    /** Remove a geofence by ID */
+    remove(id) {
+        this.fences.delete(id);
+        this.states.delete(id);
+    }
+    /** Remove all geofences */
+    clear() {
+        this.fences.clear();
+        this.states.clear();
+    }
+    /** List all registered geofence IDs */
+    listIds() {
+        return Array.from(this.fences.keys());
+    }
+    // ── Update ──────────────────────────────────────────────────────────────────
+    /**
+     * Feed the current coordinate and receive a (possibly empty) list of events.
+     * Call this on every NavCore state update.
+     */
+    update(coord) {
+        if (!coord)
+            return [];
+        const events = [];
+        const now = Date.now();
+        for (const [id, fence] of this.fences) {
+            const state = this.states.get(id);
+            const isNowInside = this.contains(fence, coord);
+            if (!state.inside && isNowInside) {
+                // Enter
+                state.inside = true;
+                state.enteredAtMs = now;
+                const event = { id, name: fence.name, type: 'enter', coord, meta: fence.meta };
+                events.push(event);
+                this.options.onEvent?.(event);
+            }
+            else if (state.inside && !isNowInside) {
+                // Exit
+                state.inside = false;
+                const dwellMs = state.enteredAtMs ? now - state.enteredAtMs : 0;
+                state.enteredAtMs = null;
+                const event = { id, name: fence.name, type: 'exit', coord, dwellMs, meta: fence.meta };
+                events.push(event);
+                this.options.onEvent?.(event);
+            }
+            else if (state.inside && state.enteredAtMs !== null) {
+                // Dwell check
+                const dwellMs = now - state.enteredAtMs;
+                if (dwellMs >= this.options.dwellThresholdMs) {
+                    const event = { id, name: fence.name, type: 'dwell', coord, dwellMs, meta: fence.meta };
+                    events.push(event);
+                    this.options.onEvent?.(event);
+                    // Reset so dwell fires every threshold interval
+                    state.enteredAtMs = now;
+                }
+            }
+        }
+        return events;
+    }
+    /** Check if a coordinate is currently inside a named geofence */
+    isInside(id, coord) {
+        const fence = this.fences.get(id);
+        if (!fence)
+            return false;
+        return this.contains(fence, coord);
+    }
+    // ── Geometry ────────────────────────────────────────────────────────────────
+    contains(fence, coord) {
+        if (fence.kind === 'circle') {
+            const distM = haversineDistance(coord[1], coord[0], fence.center[1], fence.center[0]);
+            return distM <= fence.radiusM;
+        }
+        return this.pointInPolygon(coord, fence.coords);
+    }
+    /**
+     * Ray-casting point-in-polygon algorithm.
+     * Works in [lng, lat] space (sufficient for small areas; use projected
+     * coords for very large polygons spanning many degrees).
+     */
+    pointInPolygon(point, polygon) {
+        const [px, py] = point;
+        let inside = false;
+        const n = polygon.length;
+        for (let i = 0, j = n - 1; i < n; j = i++) {
+            const [xi, yi] = polygon[i];
+            const [xj, yj] = polygon[j];
+            const intersects = yi > py !== yj > py &&
+                px < ((xj - xi) * (py - yi)) / (yj - yi) + xi;
+            if (intersects)
+                inside = !inside;
+        }
+        return inside;
+    }
+}

package/dist/core/src/index.d.ts

@@ -0,0 +1,66 @@
+/**
+ * @navcore/core — Navigation Engine
+ *
+ * Navigation logic is pure TypeScript; license verification includes a portable P-256 fallback.
+ * Works in Node.js, browsers, React Native, and CI/CD.
+ *
+ * Tier model:
+ *   CORE — free / MIT.  Import from '@ingissa/navcore-core/core'
+ *   PRO  — commercial.  Import from '@ingissa/navcore-core/pro'
+ *   Full engine (NavCore class) — available from '@ingissa/navcore-core'
+ *
+ * @packageDocumentation
+ */
+export { haversineDistance, destinationPoint, getBearingBetweenPoints as geoGetBearing } from './geo/haversine';
+export { normalizeAngle, getBearingBetweenPoints, interpolatePoint } from './geo/bearing';
+export { projectPointOnSegment } from './geo/projection';
+export { buildForwardCumulativeDistances, buildReverseCumulativeDistances } from './geo/cumulative';
+export { KalmanFilter2D, kalmanUpdate2D } from './kalman/KalmanFilter2D';
+export type { Kalman2DState } from './kalman/KalmanFilter2D';
+export { RouteSnapper } from './snapper/RouteSnapper';
+export type { SnapResult, SnapperOptions } from './snapper/RouteSnapper';
+export { ParallelRoadResolver } from './snapper/ParallelRoadResolver';
+export type { SnapCandidate, ResolvedCandidate, ParallelRoadResolverOptions, } from './snapper/ParallelRoadResolver';
+export { DeadReckoningEngine, computeDeadReckoningOnRoute } from './dead-reckoning/DeadReckoning';
+export { DeviationDetector } from './corridor/DeviationDetector';
+export { calculateDynamicCorridor } from './corridor/DynamicCorridor';
+export { calculateRobustBearing, blendBearing, getSpeedAdaptiveAlpha, applyBearingSmoothing, } from './bearing/BearingEngine';
+export { validateProgressUpdate } from './progress/ProgressTracker';
+export { resolveNextInstruction } from './progress/InstructionResolver';
+export type { NavInstruction } from './progress/InstructionResolver';
+export { InstructionEditor } from './progress/InstructionEditor';
+export type { RichInstruction, InstructionType } from './progress/InstructionEditor';
+export { advancePredictor, applyGpsCorrection, pointAtOffset } from './predictor/RouteOffsetPredictor';
+export { NavigationFSM } from './off-route/NavigationFSM';
+export type { NavLifecycleState, LifecycleEvent, LifecycleContext } from './off-route/NavigationFSM';
+export { OffRouteFSM } from './off-route/OffRouteFSM';
+export type { OffRouteState, OffRouteEvent, OffRouteContext, TempRoute, RejoinTarget } from './off-route/OffRouteFSM';
+export { CustomRouteBuilder } from './route-builder/CustomRouteBuilder';
+export type { CustomWaypoint, WaypointOptions, BuildOptions } from './route-builder/CustomRouteBuilder';
+export type { DirectionsProvider, DirectionsOptions, DirectionsResult, DirectionsLeg, DirectionsStep, DirectionsManeuver, } from './directions/DirectionsProvider';
+export { OSRMDirectionsProvider } from './directions/OSRMDirectionsProvider';
+export type { OSRMConfig } from './directions/OSRMDirectionsProvider';
+export { ValhallaDirectionsProvider } from './directions/ValhallaDirectionsProvider';
+export type { ValhallaConfig, ValhallaCostingModel } from './directions/ValhallaDirectionsProvider';
+export { OpenRouteServiceProvider } from './directions/OpenRouteServiceProvider';
+export type { ORSConfig, ORSProfile } from './directions/OpenRouteServiceProvider';
+export { createRoutePlan } from './route-plan/RoutePlan';
+export type { RoutePlan, CreateRoutePlanOptions } from './route-plan/RoutePlan';
+export { NavigationSession, createNavigationSession } from './session/NavigationSession';
+export type { NavigationSessionOptions, NavigationSessionEventMap, NavigationRequest, OriginDestinationNavigationRequest, CoordinatesNavigationRequest, } from './session/NavigationSession';
+export type { MapRendererAdapter, RouteStyle, VehicleStyle, CameraOptions, } from './renderer/MapRendererAdapter';
+export { VoiceTriggerEngine } from './voice/VoiceTriggerEngine';
+export type { VoiceCue, VoicePriority, VoiceTriggerOptions } from './voice/VoiceTriggerEngine';
+export { ETAEngine } from './eta/ETAEngine';
+export type { ETAResult, ETAOptions } from './eta/ETAEngine';
+export { GeofencingEngine } from './geofencing/GeofencingEngine';
+export type { GeofenceEvent, GeofenceEventType, GeofenceType, GeofencingOptions, ZoneDefinition, } from './geofencing/GeofencingEngine';
+export { LicenseManager } from './license/LicenseManager';
+export type { LicenseStatus, LicensePayload } from './license/LicenseManager';
+export * as Constants from './constants';
+export { FEATURES } from './features';
+export type { FeatureKey } from './features';
+export { NavCore } from './NavCore';
+export type { NavCoreOptions, NavGpsUpdate, NavCoreState } from './NavCore';
+export type { Coordinate } from './geo/haversine';
+//# sourceMappingURL=index.d.ts.map

package/dist/core/src/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../core/src/index.ts"],"names":[],"mappings":"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"}

package/dist/core/src/index.js

@@ -0,0 +1,62 @@
+/**
+ * @navcore/core — Navigation Engine
+ *
+ * Navigation logic is pure TypeScript; license verification includes a portable P-256 fallback.
+ * Works in Node.js, browsers, React Native, and CI/CD.
+ *
+ * Tier model:
+ *   CORE — free / MIT.  Import from '@ingissa/navcore-core/core'
+ *   PRO  — commercial.  Import from '@ingissa/navcore-core/pro'
+ *   Full engine (NavCore class) — available from '@ingissa/navcore-core'
+ *
+ * @packageDocumentation
+ */
+// ── CORE — Geo Utilities (free) ───────────────────────────────────────────────
+export { haversineDistance, destinationPoint, getBearingBetweenPoints as geoGetBearing } from './geo/haversine';
+export { normalizeAngle, getBearingBetweenPoints, interpolatePoint } from './geo/bearing';
+export { projectPointOnSegment } from './geo/projection';
+export { buildForwardCumulativeDistances, buildReverseCumulativeDistances } from './geo/cumulative';
+// ── CORE — Kalman Filter (free) ───────────────────────────────────────────────
+export { KalmanFilter2D, kalmanUpdate2D } from './kalman/KalmanFilter2D';
+// ── CORE — Basic Route Snapper (free) ─────────────────────────────────────────
+export { RouteSnapper } from './snapper/RouteSnapper';
+// ── PRO — Parallel Road Resolver (license required) ───────────────────────────
+export { ParallelRoadResolver } from './snapper/ParallelRoadResolver';
+// ── PRO — Dead Reckoning (license required) ───────────────────────────────────
+export { DeadReckoningEngine, computeDeadReckoningOnRoute } from './dead-reckoning/DeadReckoning';
+// ── PRO — Corridor & Deviation (license required) ─────────────────────────────
+export { DeviationDetector } from './corridor/DeviationDetector';
+export { calculateDynamicCorridor } from './corridor/DynamicCorridor';
+// ── PRO — Bearing Engine (license required) ───────────────────────────────────
+export { calculateRobustBearing, blendBearing, getSpeedAdaptiveAlpha, applyBearingSmoothing, } from './bearing/BearingEngine';
+// ── PRO — Progress & Instructions (license required) ──────────────────────────
+export { validateProgressUpdate } from './progress/ProgressTracker';
+export { resolveNextInstruction } from './progress/InstructionResolver';
+// ── PRO — Instruction Editor (license required) ───────────────────────────────
+export { InstructionEditor } from './progress/InstructionEditor';
+// ── PRO — Route Offset Predictor (license required) ───────────────────────────
+export { advancePredictor, applyGpsCorrection, pointAtOffset } from './predictor/RouteOffsetPredictor';
+// ── PRO — Navigation FSM (license required) ───────────────────────────────────
+export { NavigationFSM } from './off-route/NavigationFSM';
+export { OffRouteFSM } from './off-route/OffRouteFSM';
+// ── CORE — Route Builder (free) ───────────────────────────────────────────────
+export { CustomRouteBuilder } from './route-builder/CustomRouteBuilder';
+export { OSRMDirectionsProvider } from './directions/OSRMDirectionsProvider';
+export { ValhallaDirectionsProvider } from './directions/ValhallaDirectionsProvider';
+export { OpenRouteServiceProvider } from './directions/OpenRouteServiceProvider';
+// ── Route Plan — provider response → navigation-ready engine input ───────────
+export { createRoutePlan } from './route-plan/RoutePlan';
+// ── Navigation Session — ergonomic provider → engine workflow ───────────────
+export { NavigationSession, createNavigationSession } from './session/NavigationSession';
+// ── PRO — Voice Trigger Engine (license required) ─────────────────────────────
+export { VoiceTriggerEngine } from './voice/VoiceTriggerEngine';
+// ── PRO — ETA Engine (license required) ───────────────────────────────────────
+export { ETAEngine } from './eta/ETAEngine';
+// ── PRO — Geofencing Engine (license required) ────────────────────────────────
+export { GeofencingEngine } from './geofencing/GeofencingEngine';
+export { LicenseManager } from './license/LicenseManager';
+// ── CORE — Constants & Features (free) ────────────────────────────────────────
+export * as Constants from './constants';
+export { FEATURES } from './features';
+// ── Main Orchestrator (full engine — license-gated internally) ────────────────
+export { NavCore } from './NavCore';

package/dist/core/src/kalman/KalmanFilter2D.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Module 1: KalmanFilter2D
+ * GPS noise reduction using a 2D Kalman filter.
+ * ZERO dependencies — pure math.
+ */
+export interface Kalman2DState {
+    x: number;
+    y: number;
+    vx: number;
+    vy: number;
+    P: number;
+}
+/**
+ * Perform a single Kalman update step.
+ *
+ * @param state   Current state (mutated in place for perf)
+ * @param measX   Measured longitude
+ * @param measY   Measured latitude
+ * @param accuracy GPS accuracy in metres (used to scale R)
+ * @param dt      Time delta in seconds
+ * @param Q       Process noise (default 0.00001)
+ * @param rBase   Measurement noise base (default 0.00005)
+ * @returns Updated state
+ */
+export declare function kalmanUpdate2D(state: Kalman2DState, measX: number, measY: number, accuracy: number, dt: number, Q?: number, rBase?: number): Kalman2DState;
+/**
+ * KalmanFilter2D class wrapper for stateful usage.
+ */
+export declare class KalmanFilter2D {
+    private state;
+    private readonly Q;
+    private readonly rBase;
+    private lastTimestamp;
+    constructor(Q?: number, rBase?: number);
+    /** Initialize with a known position */
+    init(lng: number, lat: number, timestamp: number): void;
+    /** Process a GPS measurement, returns filtered [lng, lat] */
+    update(lng: number, lat: number, accuracy: number, timestamp: number): [number, number];
+    /** Get current filtered position */
+    getPosition(): [number, number];
+    /** Get the internal state for inspection/serialization */
+    getState(): Kalman2DState;
+    /** Reset the filter */
+    reset(): void;
+}
+//# sourceMappingURL=KalmanFilter2D.d.ts.map

package/dist/core/src/kalman/KalmanFilter2D.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"KalmanFilter2D.d.ts","sourceRoot":"","sources":["../../../../../core/src/kalman/KalmanFilter2D.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,MAAM,WAAW,aAAa;IAC5B,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,CAAC,EAAE,MAAM,CAAC;CACX;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,cAAc,CAC5B,KAAK,EAAE,aAAa,EACpB,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,MAAM,EACb,QAAQ,EAAE,MAAM,EAChB,EAAE,EAAE,MAAM,EACV,CAAC,GAAE,MAAgB,EACnB,KAAK,GAAE,MAAgB,GACtB,aAAa,CAyBf;AAED;;GAEG;AACH,qBAAa,cAAc;IACzB,OAAO,CAAC,KAAK,CAAgB;IAC7B,OAAO,CAAC,QAAQ,CAAC,CAAC,CAAS;IAC3B,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAS;IAC/B,OAAO,CAAC,aAAa,CAAa;gBAEtB,CAAC,GAAE,MAAgB,EAAE,KAAK,GAAE,MAAgB;IAMxD,uCAAuC;IACvC,IAAI,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,IAAI;IAKvD,6DAA6D;IAC7D,MAAM,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC;IAavF,oCAAoC;IACpC,WAAW,IAAI,CAAC,MAAM,EAAE,MAAM,CAAC;IAI/B,0DAA0D;IAC1D,QAAQ,IAAI,aAAa;IAIzB,uBAAuB;IACvB,KAAK,IAAI,IAAI;CAId"}

package/dist/core/src/kalman/KalmanFilter2D.js

@@ -0,0 +1,77 @@
+/**
+ * Module 1: KalmanFilter2D
+ * GPS noise reduction using a 2D Kalman filter.
+ * ZERO dependencies — pure math.
+ */
+/**
+ * Perform a single Kalman update step.
+ *
+ * @param state   Current state (mutated in place for perf)
+ * @param measX   Measured longitude
+ * @param measY   Measured latitude
+ * @param accuracy GPS accuracy in metres (used to scale R)
+ * @param dt      Time delta in seconds
+ * @param Q       Process noise (default 0.00001)
+ * @param rBase   Measurement noise base (default 0.00005)
+ * @returns Updated state
+ */
+export function kalmanUpdate2D(state, measX, measY, accuracy, dt, Q = 0.00001, rBase = 0.00005) {
+    // Predict
+    state.x += state.vx * dt;
+    state.y += state.vy * dt;
+    state.P += Q;
+    // Measurement noise: higher accuracy = lower R
+    const R = rBase * Math.max(1, accuracy / 5);
+    // Update
+    const K = state.P / (state.P + R);
+    const innovX = measX - state.x;
+    const innovY = measY - state.y;
+    state.x += K * innovX;
+    state.y += K * innovY;
+    if (dt > 0) {
+        state.vx = innovX / dt * K;
+        state.vy = innovY / dt * K;
+    }
+    state.P = (1 - K) * state.P;
+    return state;
+}
+/**
+ * KalmanFilter2D class wrapper for stateful usage.
+ */
+export class KalmanFilter2D {
+    constructor(Q = 0.00001, rBase = 0.00005) {
+        this.lastTimestamp = 0;
+        this.Q = Q;
+        this.rBase = rBase;
+        this.state = { x: 0, y: 0, vx: 0, vy: 0, P: 1 };
+    }
+    /** Initialize with a known position */
+    init(lng, lat, timestamp) {
+        this.state = { x: lng, y: lat, vx: 0, vy: 0, P: 1 };
+        this.lastTimestamp = timestamp;
+    }
+    /** Process a GPS measurement, returns filtered [lng, lat] */
+    update(lng, lat, accuracy, timestamp) {
+        if (this.lastTimestamp === 0) {
+            this.init(lng, lat, timestamp);
+            return [lng, lat];
+        }
+        const dt = Math.max(0.001, (timestamp - this.lastTimestamp) / 1000);
+        this.lastTimestamp = timestamp;
+        kalmanUpdate2D(this.state, lng, lat, accuracy, dt, this.Q, this.rBase);
+        return [this.state.x, this.state.y];
+    }
+    /** Get current filtered position */
+    getPosition() {
+        return [this.state.x, this.state.y];
+    }
+    /** Get the internal state for inspection/serialization */
+    getState() {
+        return { ...this.state };
+    }
+    /** Reset the filter */
+    reset() {
+        this.state = { x: 0, y: 0, vx: 0, vy: 0, P: 1 };
+        this.lastTimestamp = 0;
+    }
+}