@ingissa/navcore-react-native 1.0.8 → 1.0.9

package/dist/core/src/NavCore.js

@@ -1,390 +0,0 @@
-/**
- * NavCore — Main Orchestrator
- *
- * Fuses all extracted modules into a single engine class.
- * Framework-agnostic; license verification does not require platform crypto APIs.
- *
- * Usage:
- *   const engine = new NavCore({ licenseKey: '...' });
- *   engine.setRoute(routeCoords, instructions);
- *   engine.update(gpsUpdate);
- *   const state = engine.getState();
- */
-import { haversineDistance } from './geo/haversine';
-import { buildForwardCumulativeDistances, buildReverseCumulativeDistances } from './geo/cumulative';
-import { KalmanFilter2D } from './kalman/KalmanFilter2D';
-import { RouteSnapper } from './snapper/RouteSnapper';
-import { DeadReckoningEngine } from './dead-reckoning/DeadReckoning';
-import { calculateDynamicCorridor } from './corridor/DynamicCorridor';
-import { DeviationDetector, findClosestSegment } from './corridor/DeviationDetector';
-import { applyBearingSmoothing } from './bearing/BearingEngine';
-import { validateProgressUpdate } from './progress/ProgressTracker';
-import { resolveNextInstruction } from './progress/InstructionResolver';
-import { advancePredictor, applyGpsCorrection } from './predictor/RouteOffsetPredictor';
-import { NavigationFSM } from './off-route/NavigationFSM';
-import { OffRouteFSM } from './off-route/OffRouteFSM';
-import { LicenseManager } from './license/LicenseManager';
-import * as C from './constants';
-import { FEATURES } from './features';
-// ── NavCore class ─────────────────────────────────────────────
-export class NavCore {
-    constructor(options) {
-        // ── Route data ───────────────────────────────────────────────
-        this.route = [];
-        this.instructions = [];
-        this.forwardCum = new Float64Array(0);
-        this.reverseCum = new Float64Array(0);
-        // ── State ────────────────────────────────────────────────────
-        this.snappedCoord = null;
-        this.ghostCoord = null;
-        this.rawGpsCoord = null;
-        this.bearing = 0;
-        this.rawGpsBearing = null;
-        this.routeIndex = 0;
-        this.maxProgressIdx = 0;
-        this.prevSegment = null;
-        this.distanceToRoute = 0;
-        this.corridor = C.BASE_CORRIDOR_METERS;
-        this.prevDistToNext = null;
-        this.currentSpeed = 0;
-        this.lastGpsTimestamp = 0;
-        this.instrIdx = 0;
-        this.linearOffset = 0;
-        this.hasArrived = false;
-        // ── Events ───────────────────────────────────────────────────
-        this.listeners = new Map();
-        this.options = {
-            licenseKey: options?.licenseKey ?? '',
-            isDev: options?.isDev ?? false,
-            isCircuit: options?.isCircuit ?? false,
-            kalmanQ: options?.kalmanQ ?? 0.00001,
-            kalmanRBase: options?.kalmanRBase ?? 0.00005,
-            baseCorridorMeters: options?.baseCorridorMeters ?? C.BASE_CORRIDOR_METERS,
-            maxCorridorMeters: options?.maxCorridorMeters ?? C.MAX_CORRIDOR_METERS,
-            arrivalThresholdMeters: options?.arrivalThresholdMeters ?? C.ARRIVAL_THRESHOLD_METERS,
-            bearingSmoothingAlpha: options?.bearingSmoothingAlpha ?? C.BEARING_SMOOTHING_ALPHA,
-        };
-        this.kalman = new KalmanFilter2D(this.options.kalmanQ, this.options.kalmanRBase);
-        this.snapper = new RouteSnapper({ useBearingPenalty: true, useInertiaPenalty: true });
-        this.deadReckoning = new DeadReckoningEngine();
-        this.deviationDetector = new DeviationDetector();
-        this.lifecycleFSM = new NavigationFSM();
-        this.offRouteFSM = new OffRouteFSM();
-        this.license = new LicenseManager(this.options.licenseKey, this.options.isDev);
-    }
-    // ── License gate helper ──────────────────────────────────────
-    /**
-     * Returns true if the feature is unlocked (dev mode OR valid license).
-     * Emits a one-time console warning when a Pro feature is blocked.
-     */
-    has(feature) {
-        const ok = this.license.hasFeature(feature);
-        if (!ok)
-            this.license.warnOnce(feature);
-        return ok;
-    }
-    // ── Public API ───────────────────────────────────────────────
-    /** Load route geometry and instructions */
-    setRoute(route, instructions) {
-        // Keep engine state isolated from consumer-owned provider responses.
-        this.route = route.map((coord) => [coord[0], coord[1]]);
-        this.instructions = (instructions ?? []).map((instruction) => ({
-            ...instruction,
-            location: [instruction.location[0], instruction.location[1]],
-        }));
-        this.forwardCum = buildForwardCumulativeDistances(this.route);
-        this.reverseCum = buildReverseCumulativeDistances(this.route);
-        this.routeIndex = 0;
-        this.maxProgressIdx = 0;
-        this.prevSegment = null;
-        this.instrIdx = 0;
-        this.linearOffset = 0;
-        this.hasArrived = false;
-        this.snappedCoord = null;
-        this.prevDistToNext = null;
-        this.lifecycleFSM.dispatch({ type: 'ROUTE_LOADED' });
-        // Auto-fill missing cumulative offsets for instructions
-        for (const instr of this.instructions) {
-            if (instr.cumulativeOffset === undefined && instr.geometryIndex < this.forwardCum.length) {
-                instr.cumulativeOffset = this.forwardCum[instr.geometryIndex];
-            }
-        }
-        this.emit('routeLoaded', { routeLength: this.route.length });
-    }
-    /** Load a provider-normalized route plan without exposing mutable route state. */
-    loadRoute(plan) {
-        this.setRoute(plan.geometry, plan.instructions);
-    }
-    /** Start navigation */
-    startNavigation() {
-        this.lifecycleFSM.dispatch({ type: 'USER_START_NAVIGATION' });
-        this.emit('navigationStarted');
-    }
-    /** Process a GPS update — the main engine tick */
-    update(gps) {
-        this.rawGpsCoord = gps.coord;
-        this.rawGpsBearing = gps.bearing;
-        this.currentSpeed = gps.speed;
-        this.lastGpsTimestamp = gps.timestamp;
-        if (this.route.length < 2)
-            return this.getState();
-        // 1. Kalman filter
-        const [filteredLng, filteredLat] = this.kalman.update(gps.coord[0], gps.coord[1], gps.accuracy ?? 10, gps.timestamp);
-        const filteredCoord = [filteredLng, filteredLat];
-        // 2. Snap to route
-        const startIdx = Math.max(0, this.routeIndex - 2);
-        const snap = this.snapper.snap(filteredCoord, this.route, startIdx, C.SNAP_WINDOW_SIZE, this.options.isCircuit, this.maxProgressIdx, this.routeIndex, gps.bearing, this.prevSegment);
-        this.ghostCoord = snap.proj;
-        // Look ahead to upcoming maneuver for dynamic corridor widening
-        let distToUpcomingManeuver = null;
-        if (this.instructions.length > 0 && this.instrIdx < this.instructions.length) {
-            const upcoming = this.instructions[this.instrIdx];
-            distToUpcomingManeuver = upcoming.cumulativeOffset !== undefined
-                ? Math.max(0, upcoming.cumulativeOffset - this.linearOffset)
-                : haversineDistance(filteredCoord[1], filteredCoord[0], upcoming.location[1], upcoming.location[0]);
-        }
-        // 3. Dynamic corridor
-        this.corridor = calculateDynamicCorridor(gps.speed, gps.accuracy, this.options.baseCorridorMeters, this.options.maxCorridorMeters, C.SPEED_CORRIDOR_FACTOR, C.GPS_ACCURACY_FACTOR, distToUpcomingManeuver);
-        // 4. Progress validation
-        const validatedIdx = validateProgressUpdate(this.routeIndex, snap.idx, this.route, snap.dist, C.MAX_SNAP_DISTANCE);
-        this.prevSegment = this.routeIndex;
-        this.routeIndex = validatedIdx;
-        this.maxProgressIdx = Math.max(this.maxProgressIdx, validatedIdx);
-        this.snappedCoord = snap.proj;
-        this.distanceToRoute = snap.dist;
-        // 5. Linear offset update
-        if (this.forwardCum.length > validatedIdx) {
-            const measuredOffset = this.forwardCum[validatedIdx] ?? 0;
-            this.linearOffset = applyGpsCorrection(this.linearOffset, measuredOffset, C.BETA_CORRECTION);
-        }
-        // 6. Bearing smoothing (PRO: ADVANCED_BEARING)
-        if (this.has(FEATURES.ADVANCED_BEARING)) {
-            this.bearing = applyBearingSmoothing(this.bearing, this.route, this.routeIndex, gps.speed, gps.bearing, this.options.bearingSmoothingAlpha);
-        }
-        else if (gps.bearing !== null) {
-            this.bearing = gps.bearing;
-        }
-        // 7. Deviation detection & Route Rejoin Handling
-        const isProDeviation = this.has(FEATURES.COMPOUND_DEVIATION);
-        if (this.offRouteFSM.state === 'ON_ROUTE' || this.offRouteFSM.state === 'DEVIATING') {
-            if (isProDeviation) {
-                const closest = findClosestSegment(filteredCoord, this.route, startIdx, C.SNAP_WINDOW_SIZE);
-                const signals = this.deviationDetector.evaluate(filteredCoord, gps.bearing, gps.speed, closest, this.route, this.corridor, this.prevDistToNext);
-                // Update moving-away tracker
-                if (closest.segmentIndex < this.route.length - 1) {
-                    const nextEnd = this.route[Math.min(closest.segmentIndex + 2, this.route.length - 1)];
-                    this.prevDistToNext = haversineDistance(filteredCoord[1], filteredCoord[0], nextEnd[1], nextEnd[0]);
-                }
-                if (signals.confirmed) {
-                    if (this.offRouteFSM.state === 'ON_ROUTE') {
-                        this.offRouteFSM.dispatch({
-                            type: 'DEVIATION_SUSPECTED',
-                            deviationSegmentIdx: closest.segmentIndex
-                        });
-                    }
-                    else if (this.offRouteFSM.isDeviationConfirmed()) {
-                        this.offRouteFSM.dispatch({
-                            type: 'DEVIATION_CONFIRMED',
-                            deviationSegmentIdx: closest.segmentIndex
-                        });
-                        this.emit('deviation', {
-                            anchorIndex: closest.segmentIndex,
-                            ghostCoord: snap.proj,
-                        });
-                    }
-                }
-                else if (this.offRouteFSM.state === 'DEVIATING') {
-                    this.offRouteFSM.dispatch({ type: 'RESUME' });
-                }
-            }
-            else {
-                // Core fallback: simple distance-based off-route check
-                if (snap.dist > this.corridor && this.offRouteFSM.state === 'ON_ROUTE') {
-                    this.offRouteFSM.dispatch({ type: 'DEVIATION_SUSPECTED', deviationSegmentIdx: snap.idx });
-                    this.emit('deviation', { anchorIndex: snap.idx, ghostCoord: snap.proj });
-                }
-                else if (snap.dist <= this.corridor && this.offRouteFSM.state === 'DEVIATING') {
-                    this.offRouteFSM.dispatch({ type: 'RESUME' });
-                }
-            }
-        }
-        else {
-            // Vehicle is in OFF_ROUTE, REJOINING, or REJOINED state.
-            // If the vehicle re-enters the valid corridor, resume ON_ROUTE and emit 'rejoined'.
-            if (snap.dist <= this.corridor) {
-                const wasOffRoute = this.offRouteFSM.state === 'OFF_ROUTE' ||
-                    this.offRouteFSM.state === 'REJOINING' ||
-                    this.offRouteFSM.state === 'REJOINED';
-                this.offRouteFSM.dispatch({ type: 'RESUME' });
-                if (wasOffRoute) {
-                    this.emit('rejoined', { resumeIndex: snap.idx });
-                }
-            }
-        }
-        // 8. Lifecycle join detection
-        if (this.lifecycleFSM.state === 'APPROACHING_ROUTE' && snap.dist < this.corridor) {
-            this.lifecycleFSM.dispatch({ type: 'ROUTE_JOINED', data: { index: snap.idx } });
-        }
-        // 9. Instruction resolution
-        if (this.instructions.length > 0) {
-            const instrResult = resolveNextInstruction(this.routeIndex, this.instructions, this.instrIdx, this.route, filteredCoord, gps.bearing, this.linearOffset, gps.speed, this.options.isCircuit);
-            if (instrResult.nextIdx !== this.instrIdx) {
-                this.instrIdx = instrResult.nextIdx;
-            }
-            if (instrResult.wasTriggered && instrResult.instruction) {
-                this.emit('instruction', instrResult.instruction);
-                this.instrIdx = instrResult.nextIdx + 1;
-            }
-        }
-        // 10. Arrival detection
-        if (!this.hasArrived && this.route.length > 0) {
-            const dest = this.route[this.route.length - 1];
-            const distToDest = haversineDistance(filteredCoord[1], filteredCoord[0], dest[1], dest[0]);
-            // Prevent immediate arrival on circuits by ensuring we've traversed at least 80% of the waypoints
-            const hasTraveledFarEnough = this.options.isCircuit ?
-                (this.routeIndex >= this.route.length * 0.8) : true;
-            if (distToDest < this.options.arrivalThresholdMeters && hasTraveledFarEnough) {
-                this.hasArrived = true;
-                this.lifecycleFSM.dispatch({ type: 'NAVIGATION_FINISHED' });
-                this.emit('arrival');
-            }
-        }
-        // 11. Dead reckoning anchor (PRO: DEAD_RECKONING)
-        if (this.has(FEATURES.DEAD_RECKONING)) {
-            this.deadReckoning.setAnchor(snap.proj, snap.idx, gps.timestamp);
-        }
-        const state = this.getState();
-        this.emit('update', state);
-        return state;
-    }
-    /** Time-advance tick for dead reckoning (call at RAF rate) */
-    tick(nowMs) {
-        if (this.has(FEATURES.DEAD_RECKONING)) {
-            const dr = this.deadReckoning.predict(this.currentSpeed, this.bearing, nowMs);
-            if (dr.isActive) {
-                this.snappedCoord = dr.predictedCoord;
-            }
-        }
-        // Advance linear offset predictor
-        if (this.lastGpsTimestamp > 0) {
-            const dt = (nowMs - this.lastGpsTimestamp) / 1000;
-            if (dt > 0 && dt < C.GPS_AGE_CAP_SECONDS) {
-                this.linearOffset = advancePredictor(this.linearOffset, this.currentSpeed, dt);
-            }
-        }
-        const state = this.getState();
-        this.emit('update', state);
-        return state;
-    }
-    /** Get the current engine state snapshot */
-    getState() {
-        const distToDest = this.route.length > 0 && this.reverseCum.length > this.routeIndex
-            ? (this.reverseCum[this.routeIndex] ?? null)
-            : null;
-        const distToNextInstr = this.instrIdx < this.instructions.length
-            ? (() => {
-                const instr = this.instructions[this.instrIdx];
-                return instr.cumulativeOffset !== undefined
-                    ? Math.max(0, instr.cumulativeOffset - this.linearOffset)
-                    : null;
-            })()
-            : null;
-        const gpsAgeMs = this.lastGpsTimestamp > 0 ? Date.now() - this.lastGpsTimestamp : 0;
-        const confidence = Math.max(0, Math.min(1, 1 - (this.distanceToRoute / Math.max(1, this.corridor))));
-        const alertState = this.offRouteFSM.state === 'DEVIATING' ? 'DEVIATING' :
-            this.offRouteFSM.state === 'OFF_ROUTE' || this.offRouteFSM.state === 'REROUTING' ? 'RECALCULATING' :
-                this.offRouteFSM.state === 'REJOINING' ? 'REJOINING' :
-                    this.offRouteFSM.state === 'REJOINED' ? 'REJOINED' : 'NONE';
-        const isOff = this.offRouteFSM.state !== 'ON_ROUTE' && this.offRouteFSM.state !== 'DEVIATING';
-        const detourMode = this.offRouteFSM.state === 'OFF_ROUTE' || this.offRouteFSM.state === 'REROUTING' ? 'FREE' : 'NONE';
-        const detourCommitProgress = this.offRouteFSM.state === 'OFF_ROUTE' ? 1.0 : 0.0;
-        const rejoinCandidate = this.offRouteFSM.context.rejoinTarget
-            ? {
-                coord: this.offRouteFSM.context.rejoinTarget.coordinates,
-                index: this.offRouteFSM.context.rejoinTarget.index,
-            }
-            : null;
-        const confidenceCone = this.snappedCoord
-            ? {
-                center: this.snappedCoord,
-                bearing: this.bearing,
-                angle: 30,
-                length: Math.max(10, Math.min(50, this.currentSpeed * 3)),
-            }
-            : null;
-        const nextIdx = this.instrIdx < this.instructions.length ? this.instrIdx : null;
-        return {
-            snappedCoord: this.snappedCoord,
-            ghostCoord: this.ghostCoord ?? this.snappedCoord,
-            rawGpsCoord: this.rawGpsCoord,
-            bearing: this.bearing,
-            rawGpsBearing: this.rawGpsBearing,
-            routeIndex: this.routeIndex,
-            anchorRouteIndex: this.prevSegment ?? this.routeIndex,
-            distanceToRoute: this.distanceToRoute,
-            corridor: this.corridor,
-            confidence,
-            isOffRoute: isOff,
-            navFsmState: this.lifecycleFSM.state,
-            progressIndex: this.routeIndex,
-            hasArrived: this.hasArrived,
-            rejoinCandidate,
-            confidenceCone,
-            alertState,
-            detourMode,
-            detourCommitProgress,
-            distanceToDestination: distToDest,
-            distanceToNextInstruction: distToNextInstr,
-            nextInstrIdx: nextIdx,
-            nextInstructionIndex: nextIdx,
-            currentSpeed: this.currentSpeed,
-            isGpsStale: gpsAgeMs > C.GPS_STALE_MS,
-            gpsAgeMs,
-            licenseStatus: this.license.getStatus(),
-            offRouteState: this.offRouteFSM.state,
-            lifecycleState: this.lifecycleFSM.state,
-        };
-    }
-    /** Destroy the engine */
-    destroy() {
-        this.listeners.clear();
-        this.route = [];
-        this.instructions = [];
-        this.snappedCoord = null;
-        this.ghostCoord = null;
-        this.rawGpsCoord = null;
-        this.kalman.reset();
-        this.deadReckoning.clearAnchor();
-        this.lifecycleFSM.reset();
-        this.offRouteFSM.reset();
-    }
-    // ── Event system ─────────────────────────────────────────────
-    on(event, handler) {
-        if (!this.listeners.has(event)) {
-            this.listeners.set(event, []);
-        }
-        this.listeners.get(event).push(handler);
-    }
-    off(event, handler) {
-        const handlers = this.listeners.get(event);
-        if (handlers) {
-            const idx = handlers.indexOf(handler);
-            if (idx >= 0)
-                handlers.splice(idx, 1);
-        }
-    }
-    emit(event, ...args) {
-        const handlers = this.listeners.get(event);
-        if (handlers) {
-            for (const handler of handlers) {
-                handler(...args);
-            }
-        }
-    }
-    // ── Getters ──────────────────────────────────────────────────
-    getLicenseManager() { return this.license; }
-    getRoute() { return this.route; }
-    getInstructions() { return this.instructions; }
-    getOffRouteFSM() { return this.offRouteFSM; }
-    getLifecycleFSM() { return this.lifecycleFSM; }
-}

package/dist/core/src/bearing/BearingEngine.d.ts

@@ -1,24 +0,0 @@
-/**
- * Module 5: BearingEngine
- * Speed-adaptive IIR bearing smoothing.
- */
-import { type Coordinate } from '../geo/haversine';
-/**
- * Calculate speed-adaptive smoothing factor.
- * Higher speed → less smoothing (alpha closer to 1).
- * Lower speed → more smoothing (alpha closer to base value).
- */
-export declare function getSpeedAdaptiveAlpha(speedMps: number, baseAlpha?: number): number;
-/**
- * Compute bearing from the route geometry at the current segment.
- */
-export declare function calculateRobustBearing(route: Coordinate[], currentIdx: number, lookAhead?: number): number;
-/**
- * Blend two bearings using the shortest angular path.
- */
-export declare function blendBearing(current: number, target: number, alpha: number): number;
-/**
- * Full bearing smoothing pipeline: route bearing → IIR blend → output.
- */
-export declare function applyBearingSmoothing(currentBearing: number, route: Coordinate[], routeIdx: number, speedMps: number, gpsBearing: number | null, baseAlpha?: number): number;
-//# sourceMappingURL=BearingEngine.d.ts.map

package/dist/core/src/bearing/BearingEngine.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"BearingEngine.d.ts","sourceRoot":"","sources":["../../../../../core/src/bearing/BearingEngine.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,KAAK,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAOnD;;;;GAIG;AACH,wBAAgB,qBAAqB,CACnC,QAAQ,EAAE,MAAM,EAChB,SAAS,GAAE,MAAgC,GAC1C,MAAM,CAIR;AAED;;GAEG;AACH,wBAAgB,sBAAsB,CACpC,KAAK,EAAE,UAAU,EAAE,EACnB,UAAU,EAAE,MAAM,EAClB,SAAS,GAAE,MAAU,GACpB,MAAM,CAQR;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAGnF;AAED;;GAEG;AACH,wBAAgB,qBAAqB,CACnC,cAAc,EAAE,MAAM,EACtB,KAAK,EAAE,UAAU,EAAE,EACnB,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,MAAM,EAChB,UAAU,EAAE,MAAM,GAAG,IAAI,EACzB,SAAS,GAAE,MAAgC,GAC1C,MAAM,CAWR"}

package/dist/core/src/bearing/BearingEngine.js

@@ -1,50 +0,0 @@
-/**
- * Module 5: BearingEngine
- * Speed-adaptive IIR bearing smoothing.
- */
-import { getBearingBetweenPoints, normalizeAngle } from '../geo/bearing';
-import { BEARING_SMOOTHING_ALPHA, BEARING_MIN_SPEED_MPS, } from '../constants';
-/**
- * Calculate speed-adaptive smoothing factor.
- * Higher speed → less smoothing (alpha closer to 1).
- * Lower speed → more smoothing (alpha closer to base value).
- */
-export function getSpeedAdaptiveAlpha(speedMps, baseAlpha = BEARING_SMOOTHING_ALPHA) {
-    if (speedMps < BEARING_MIN_SPEED_MPS)
-        return baseAlpha * 0.5;
-    if (speedMps > 20)
-        return Math.min(0.9, baseAlpha * 2);
-    return baseAlpha;
-}
-/**
- * Compute bearing from the route geometry at the current segment.
- */
-export function calculateRobustBearing(route, currentIdx, lookAhead = 3) {
-    const endIdx = Math.min(currentIdx + lookAhead, route.length - 1);
-    if (currentIdx >= route.length - 1 || currentIdx === endIdx) {
-        return currentIdx > 0
-            ? getBearingBetweenPoints(route[currentIdx - 1], route[currentIdx])
-            : 0;
-    }
-    return getBearingBetweenPoints(route[currentIdx], route[endIdx]);
-}
-/**
- * Blend two bearings using the shortest angular path.
- */
-export function blendBearing(current, target, alpha) {
-    const diff = normalizeAngle(target - current);
-    return (current + alpha * diff + 360) % 360;
-}
-/**
- * Full bearing smoothing pipeline: route bearing → IIR blend → output.
- */
-export function applyBearingSmoothing(currentBearing, route, routeIdx, speedMps, gpsBearing, baseAlpha = BEARING_SMOOTHING_ALPHA) {
-    const alpha = getSpeedAdaptiveAlpha(speedMps, baseAlpha);
-    const routeBearing = calculateRobustBearing(route, routeIdx);
-    // Use GPS bearing if available and speed is sufficient, blend with route bearing
-    if (gpsBearing !== null && speedMps > BEARING_MIN_SPEED_MPS) {
-        const gpsBlended = blendBearing(currentBearing, gpsBearing, alpha * 0.3);
-        return blendBearing(gpsBlended, routeBearing, alpha);
-    }
-    return blendBearing(currentBearing, routeBearing, alpha);
-}

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

@@ -1,34 +0,0 @@
-/**
- * Engine constants — centralized tuning parameters.
- * Extracted from packages/nav-sdk/src/shared/constants.ts
- */
-export declare const BASE_CORRIDOR_METERS = 25;
-export declare const MAX_CORRIDOR_METERS = 60;
-export declare const SPEED_CORRIDOR_FACTOR = 1.2;
-export declare const GPS_ACCURACY_FACTOR = 0.5;
-export declare const TURN_LOOKAHEAD_DISTANCE_METERS = 40;
-export declare const TURN_CORRIDOR_MULTIPLIER = 1.4;
-export declare const MAX_SNAP_DISTANCE = 80;
-export declare const BEARING_MISMATCH_THRESHOLD = 90;
-export declare const BEARING_MISMATCH_PENALTY = 500;
-export declare const INERTIA_PENALTY = 200;
-export declare const INERTIA_SEGMENT_DIST = 5;
-export declare const SNAP_WINDOW_SIZE = 25;
-export declare const BEARING_SMOOTHING_ALPHA = 0.3;
-export declare const BEARING_MIN_SPEED_MPS = 1.5;
-export declare const BEARING_ALIGNMENT_THRESHOLD = 55;
-export declare const DR_MAX_AGE_MS = 5000;
-export declare const OFF_ROUTE_CONFIRM_MS = 2000;
-export declare const REJOIN_CONFIRM_MS = 1500;
-export declare const REJOIN_COOLDOWN_MS = 12000;
-export declare const STARTUP_GRACE_MS = 3000;
-export declare const DETOUR_COMMIT_MS = 4000;
-export declare const GPS_STALE_MS = 3000;
-export declare const GPS_AGE_CAP_SECONDS = 10;
-export declare const MANEUVER_TRIGGER_DIST = 25;
-export declare const BETA_CORRECTION = 0.15;
-export declare const LOOK_AHEAD_SECONDS = 3;
-export declare const MIN_LOOK_AHEAD_METERS = 20;
-export declare const MAX_LOOK_AHEAD_METERS = 100;
-export declare const ARRIVAL_THRESHOLD_METERS = 30;
-//# sourceMappingURL=constants.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../../../core/src/constants.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,eAAO,MAAM,oBAAoB,KAAK,CAAC;AACvC,eAAO,MAAM,mBAAmB,KAAK,CAAC;AACtC,eAAO,MAAM,qBAAqB,MAAM,CAAC;AACzC,eAAO,MAAM,mBAAmB,MAAM,CAAC;AACvC,eAAO,MAAM,8BAA8B,KAAK,CAAC;AACjD,eAAO,MAAM,wBAAwB,MAAM,CAAC;AAG5C,eAAO,MAAM,iBAAiB,KAAK,CAAC;AACpC,eAAO,MAAM,0BAA0B,KAAK,CAAC;AAC7C,eAAO,MAAM,wBAAwB,MAAM,CAAC;AAC5C,eAAO,MAAM,eAAe,MAAM,CAAC;AACnC,eAAO,MAAM,oBAAoB,IAAI,CAAC;AACtC,eAAO,MAAM,gBAAgB,KAAK,CAAC;AAGnC,eAAO,MAAM,uBAAuB,MAAM,CAAC;AAC3C,eAAO,MAAM,qBAAqB,MAAM,CAAC;AACzC,eAAO,MAAM,2BAA2B,KAAK,CAAC;AAG9C,eAAO,MAAM,aAAa,OAAO,CAAC;AAGlC,eAAO,MAAM,oBAAoB,OAAO,CAAC;AACzC,eAAO,MAAM,iBAAiB,OAAO,CAAC;AACtC,eAAO,MAAM,kBAAkB,QAAQ,CAAC;AACxC,eAAO,MAAM,gBAAgB,OAAO,CAAC;AACrC,eAAO,MAAM,gBAAgB,OAAO,CAAC;AACrC,eAAO,MAAM,YAAY,OAAO,CAAC;AACjC,eAAO,MAAM,mBAAmB,KAAK,CAAC;AAGtC,eAAO,MAAM,qBAAqB,KAAK,CAAC;AAGxC,eAAO,MAAM,eAAe,OAAO,CAAC;AACpC,eAAO,MAAM,kBAAkB,IAAI,CAAC;AACpC,eAAO,MAAM,qBAAqB,KAAK,CAAC;AACxC,eAAO,MAAM,qBAAqB,MAAM,CAAC;AAGzC,eAAO,MAAM,wBAAwB,KAAK,CAAC"}

package/dist/core/src/constants.js

@@ -1,41 +0,0 @@
-/**
- * Engine constants — centralized tuning parameters.
- * Extracted from packages/nav-sdk/src/shared/constants.ts
- */
-// ── Corridor ──────────────────────────────────────────────────
-export const BASE_CORRIDOR_METERS = 25;
-export const MAX_CORRIDOR_METERS = 60;
-export const SPEED_CORRIDOR_FACTOR = 1.2;
-export const GPS_ACCURACY_FACTOR = 0.5;
-export const TURN_LOOKAHEAD_DISTANCE_METERS = 40;
-export const TURN_CORRIDOR_MULTIPLIER = 1.4;
-// ── Snapping ──────────────────────────────────────────────────
-export const MAX_SNAP_DISTANCE = 80;
-export const BEARING_MISMATCH_THRESHOLD = 90;
-export const BEARING_MISMATCH_PENALTY = 500;
-export const INERTIA_PENALTY = 200;
-export const INERTIA_SEGMENT_DIST = 5;
-export const SNAP_WINDOW_SIZE = 25;
-// ── Bearing ───────────────────────────────────────────────────
-export const BEARING_SMOOTHING_ALPHA = 0.3;
-export const BEARING_MIN_SPEED_MPS = 1.5;
-export const BEARING_ALIGNMENT_THRESHOLD = 55;
-// ── Dead Reckoning ────────────────────────────────────────────
-export const DR_MAX_AGE_MS = 5000;
-// ── Timing ────────────────────────────────────────────────────
-export const OFF_ROUTE_CONFIRM_MS = 2000;
-export const REJOIN_CONFIRM_MS = 1500;
-export const REJOIN_COOLDOWN_MS = 12000;
-export const STARTUP_GRACE_MS = 3000;
-export const DETOUR_COMMIT_MS = 4000;
-export const GPS_STALE_MS = 3000;
-export const GPS_AGE_CAP_SECONDS = 10;
-// ── Instruction ───────────────────────────────────────────────
-export const MANEUVER_TRIGGER_DIST = 25;
-// ── Predictor ─────────────────────────────────────────────────
-export const BETA_CORRECTION = 0.15;
-export const LOOK_AHEAD_SECONDS = 3;
-export const MIN_LOOK_AHEAD_METERS = 20;
-export const MAX_LOOK_AHEAD_METERS = 100;
-// ── Arrival ───────────────────────────────────────────────────
-export const ARRIVAL_THRESHOLD_METERS = 30;

package/dist/core/src/corridor/DeviationDetector.d.ts

@@ -1,33 +0,0 @@
-/**
- * Module 4b: DeviationDetector
- * Compound deviation detection using distance, bearing, and movement signals.
- */
-import { type Coordinate } from '../geo/haversine';
-export interface DeviationSignals {
-    /** Distance from GPS to nearest route segment (metres) */
-    distanceToRoute: number;
-    /** Whether the distance exceeds the dynamic corridor */
-    outsideCorridor: boolean;
-    /** Whether the vehicle bearing diverges from the route bearing */
-    bearingMismatch: boolean;
-    /** Whether the vehicle is moving away from the next segment */
-    movingAway: boolean;
-    /** Compound confirmed: outsideCorridor AND (bearingMismatch OR movingAway) */
-    confirmed: boolean;
-}
-export interface ClosestSegment {
-    segmentIndex: number;
-    distance: number;
-    projection: Coordinate;
-}
-/**
- * Find the closest segment to a GPS point within a search window.
- */
-export declare function findClosestSegment(gps: Coordinate, route: Coordinate[], startIdx: number, windowSize: number, routeFlowBearing?: number | null): ClosestSegment;
-export declare class DeviationDetector {
-    /**
-     * Evaluate deviation signals for the current GPS position.
-     */
-    evaluate(gps: Coordinate, gpsBearing: number | null, speedMps: number, closest: ClosestSegment, route: Coordinate[], corridor: number, prevDistToNextSegment: number | null): DeviationSignals;
-}
-//# sourceMappingURL=DeviationDetector.d.ts.map

package/dist/core/src/corridor/DeviationDetector.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"DeviationDetector.d.ts","sourceRoot":"","sources":["../../../../../core/src/corridor/DeviationDetector.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,KAAK,UAAU,EAAqB,MAAM,kBAAkB,CAAC;AAKtE,MAAM,WAAW,gBAAgB;IAC/B,0DAA0D;IAC1D,eAAe,EAAE,MAAM,CAAC;IACxB,wDAAwD;IACxD,eAAe,EAAE,OAAO,CAAC;IACzB,kEAAkE;IAClE,eAAe,EAAE,OAAO,CAAC;IACzB,+DAA+D;IAC/D,UAAU,EAAE,OAAO,CAAC;IACpB,8EAA8E;IAC9E,SAAS,EAAE,OAAO,CAAC;CACpB;AAED,MAAM,WAAW,cAAc;IAC7B,YAAY,EAAE,MAAM,CAAC;IACrB,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,EAAE,UAAU,CAAC;CACxB;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAChC,GAAG,EAAE,UAAU,EACf,KAAK,EAAE,UAAU,EAAE,EACnB,QAAQ,EAAE,MAAM,EAChB,UAAU,EAAE,MAAM,EAClB,gBAAgB,GAAE,MAAM,GAAG,IAAW,GACrC,cAAc,CA8ChB;AAED,qBAAa,iBAAiB;IAC5B;;OAEG;IACH,QAAQ,CACN,GAAG,EAAE,UAAU,EACf,UAAU,EAAE,MAAM,GAAG,IAAI,EACzB,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,cAAc,EACvB,KAAK,EAAE,UAAU,EAAE,EACnB,QAAQ,EAAE,MAAM,EAChB,qBAAqB,EAAE,MAAM,GAAG,IAAI,GACnC,gBAAgB;CAiCpB"}