refactor: unify core models and finish org.terst.nav migration

18 files changed, 0 insertions, 1144 deletions

diff --git a/android-app/app/src/main/kotlin/com/example/androidapp/data/model/SensorData.kt b/android-app/app/src/main/kotlin/com/example/androidapp/data/model/SensorData.kt
deleted file mode 100644
index d427a5d..0000000
--- a/android-app/app/src/main/kotlin/com/example/androidapp/data/model/SensorData.kt
+++ /dev/null
@@ -1,10 +0,0 @@
-package com.example.androidapp.data.model
-
-data class SensorData(
-    val latitude: Double? = null,
-    val longitude: Double? = null,
-    val headingTrueDeg: Double? = null,
-    val apparentWindSpeedKt: Double? = null,
-    val apparentWindAngleDeg: Double? = null,
-    val speedOverGroundKt: Double? = null
-)
diff --git a/android-app/app/src/main/kotlin/com/example/androidapp/data/storage/GribFileManager.kt b/android-app/app/src/main/kotlin/com/example/androidapp/data/storage/GribFileManager.kt
deleted file mode 100644
index d6f685a..0000000
--- a/android-app/app/src/main/kotlin/com/example/androidapp/data/storage/GribFileManager.kt
+++ /dev/null
@@ -1,24 +0,0 @@
-package com.example.androidapp.data.storage
-
-import org.terst.nav.data.model.GribFile
-import org.terst.nav.data.model.GribRegion
-import java.time.Instant
-
-interface GribFileManager {
-    fun saveMetadata(file: GribFile)
-    fun listFiles(region: GribRegion): List<GribFile>
-    fun latestFile(region: GribRegion): GribFile?
-    fun delete(file: GribFile): Boolean
-    fun purgeOlderThan(before: Instant): Int
-    fun totalSizeBytes(): Long
-}
-
-class InMemoryGribFileManager : GribFileManager {
-    private val files = mutableListOf<GribFile>()
-    override fun saveMetadata(file: GribFile) { files.add(file) }
-    override fun listFiles(region: GribRegion): List<GribFile> = files.filter { it.region.name == region.name }.sortedByDescending { it.downloadedAt }
-    override fun latestFile(region: GribRegion): GribFile? = listFiles(region).firstOrNull()
-    override fun delete(file: GribFile): Boolean = files.remove(file)
-    override fun purgeOlderThan(before: Instant): Int { val toRemove = files.filter { it.downloadedAt.isBefore(before) }; files.removeAll(toRemove); return toRemove.size }
-    override fun totalSizeBytes(): Long = files.sumOf { it.sizeBytes }
-}
diff --git a/android-app/app/src/main/kotlin/com/example/androidapp/data/weather/GribStalenessChecker.kt b/android-app/app/src/main/kotlin/com/example/androidapp/data/weather/GribStalenessChecker.kt
deleted file mode 100644
index 70f36d9..0000000
--- a/android-app/app/src/main/kotlin/com/example/androidapp/data/weather/GribStalenessChecker.kt
+++ /dev/null
@@ -1,36 +0,0 @@
-package com.example.androidapp.data.weather
-
-import org.terst.nav.data.model.GribFile
-import com.example.androidapp.data.storage.GribFileManager
-import org.terst.nav.data.model.GribRegion
-import java.time.Instant
-
-/** Outcome of a freshness check. */
-sealed class FreshnessResult {
-    /** Data is current; no user action needed. */
-    object Fresh : FreshnessResult()
-    /** Data is stale; user should re-download. [message] is shown in the UI badge. */
-    data class Stale(val file: GribFile, val message: String) : FreshnessResult()
-    /** No local GRIB data exists for this region. */
-    object NoData : FreshnessResult()
-}
-
-/**
- * Checks whether locally-stored GRIB data for a region is fresh or stale.
- * Per design doc §6.3: GRIB weather valid until model run + forecast hour; stale after.
- */
-class GribStalenessChecker(private val manager: GribFileManager) {
-
-    /**
-     * Check freshness of the most-recent GRIB file for [region] relative to [now].
-     */
-    fun check(region: GribRegion, now: Instant = Instant.now()): FreshnessResult {
-        val latest = manager.latestFile(region) ?: return FreshnessResult.NoData
-        return if (latest.isStale(now)) {
-            val hoursAgo = (now.epochSecond - latest.validUntil().epochSecond) / 3600
-            FreshnessResult.Stale(latest, "Weather data outdated by ${hoursAgo}h — tap to refresh")
-        } else {
-            FreshnessResult.Fresh
-        }
-    }
-}
diff --git a/android-app/app/src/main/kotlin/com/example/androidapp/data/weather/SatelliteGribDownloader.kt b/android-app/app/src/main/kotlin/com/example/androidapp/data/weather/SatelliteGribDownloader.kt
deleted file mode 100644
index 6e565b7..0000000
--- a/android-app/app/src/main/kotlin/com/example/androidapp/data/weather/SatelliteGribDownloader.kt
+++ /dev/null
@@ -1,134 +0,0 @@
-package com.example.androidapp.data.weather
-
-import org.terst.nav.data.model.GribFile
-import org.terst.nav.data.model.GribParameter
-import org.terst.nav.data.model.GribRegion
-import org.terst.nav.data.model.SatelliteDownloadRequest
-import com.example.androidapp.data.storage.GribFileManager
-import java.time.Instant
-import kotlin.math.ceil
-import kotlin.math.floor
-
-/**
- * Downloads GRIB weather data over bandwidth-constrained satellite links (§9.1).
- *
- * Provides size and time estimates before fetching, and aborts if the download
- * would exceed the configured size limit (default 2 MB — the upper bound stated
- * in §9.1 for typical offshore GRIBs on satellite).
- *
- * The actual network fetch is supplied as a [fetcher] lambda so the class remains
- * testable without network access.
- */
-class SatelliteGribDownloader(private val fileManager: GribFileManager) {
-
-    companion object {
-        /** Iridium data link speed in bits per second. */
-        const val SATELLITE_BANDWIDTH_BPS = 2400L
-
-        /** GRIB2 packed grid value: ~2 bytes per grid point after packing. */
-        private const val BYTES_PER_GRID_POINT = 2L
-
-        /** Per-message header overhead in GRIB2 format (section 0-4). */
-        private const val HEADER_BYTES_PER_MESSAGE = 100L
-
-        /** Forecast time step used for size estimation (3-hourly is standard GFS output). */
-        private const val TIME_STEP_HOURS = 3
-
-        /** Default maximum download size; abort if estimate exceeds this. */
-        const val DEFAULT_SIZE_LIMIT_BYTES = 2_000_000L
-    }
-
-    /**
-     * Estimates the GRIB file size in bytes for [request].
-     *
-     * Formula: (gridPoints × timeSteps × paramCount × bytesPerPoint) + headerOverhead
-     * where gridPoints = ceil(latSpan/resolution + 1) × ceil(lonSpan/resolution + 1).
-     */
-    fun estimateSizeBytes(request: SatelliteDownloadRequest): Long {
-        val latPoints = floor((request.region.latMax - request.region.latMin) / request.resolutionDeg).toLong() + 1
-        val lonPoints = floor((request.region.lonMax - request.region.lonMin) / request.resolutionDeg).toLong() + 1
-        val gridPoints = latPoints * lonPoints
-        val timeSteps = ceil(request.forecastHours.toDouble() / TIME_STEP_HOURS).toLong()
-        val paramCount = request.parameters.size.toLong()
-        val dataBytes = gridPoints * timeSteps * paramCount * BYTES_PER_GRID_POINT
-        val headerBytes = paramCount * timeSteps * HEADER_BYTES_PER_MESSAGE
-        return dataBytes + headerBytes
-    }
-
-    /**
-     * Estimates how many seconds the download will take at [bandwidthBps] bits/second.
-     */
-    fun estimatedDownloadSeconds(
-        request: SatelliteDownloadRequest,
-        bandwidthBps: Long = SATELLITE_BANDWIDTH_BPS
-    ): Long = ceil(estimateSizeBytes(request) * 8.0 / bandwidthBps).toLong()
-
-    /**
-     * Convenience builder: creates a [SatelliteDownloadRequest] using the minimal
-     * satellite parameter set (wind speed + direction + surface pressure only).
-     */
-    fun buildMinimalRequest(
-        region: GribRegion,
-        forecastHours: Int,
-        resolutionDeg: Double = 1.0
-    ): SatelliteDownloadRequest = SatelliteDownloadRequest(
-        region = region,
-        parameters = GribParameter.SATELLITE_MINIMAL,
-        forecastHours = forecastHours,
-        resolutionDeg = resolutionDeg
-    )
-
-    /** Result of a satellite GRIB download attempt. */
-    sealed class DownloadResult {
-        /** Download succeeded; [file] metadata has been saved to [GribFileManager]. */
-        data class Success(val file: GribFile) : DownloadResult()
-        /** The [fetcher] returned no data or an unexpected error occurred. */
-        data class Failed(val reason: String) : DownloadResult()
-        /**
-         * Download was aborted before starting because the estimated size
-         * [estimatedBytes] exceeds the configured limit.
-         */
-        data class Aborted(val reason: String, val estimatedBytes: Long) : DownloadResult()
-    }
-
-    /**
-     * Downloads GRIB data for [request].
-     *
-     * 1. Estimates size; returns [DownloadResult.Aborted] if > [sizeLimitBytes].
-     * 2. Calls [fetcher] to retrieve raw bytes.
-     * 3. On success, saves metadata via [fileManager] and returns [DownloadResult.Success].
-     *
-     * @param request       The bandwidth-optimised download request.
-     * @param fetcher       Supplies raw GRIB bytes for the request; returns null on failure.
-     * @param outputPath    Local file path where the caller will persist the bytes.
-     * @param sizeLimitBytes Abort threshold (default [DEFAULT_SIZE_LIMIT_BYTES]).
-     * @param now           Timestamp injected for testing.
-     */
-    fun download(
-        request: SatelliteDownloadRequest,
-        fetcher: (SatelliteDownloadRequest) -> ByteArray?,
-        outputPath: String,
-        sizeLimitBytes: Long = DEFAULT_SIZE_LIMIT_BYTES,
-        now: Instant = Instant.now()
-    ): DownloadResult {
-        val estimated = estimateSizeBytes(request)
-        if (estimated > sizeLimitBytes) {
-            return DownloadResult.Aborted(
-                "Estimated size ${estimated / 1024}KB exceeds limit ${sizeLimitBytes / 1024}KB — " +
-                        "reduce region, resolution, or forecast hours",
-                estimated
-            )
-        }
-        val bytes = fetcher(request) ?: return DownloadResult.Failed("Fetcher returned no data")
-        val gribFile = GribFile(
-            region = request.region,
-            modelRunTime = now,
-            forecastHours = request.forecastHours,
-            downloadedAt = now,
-            filePath = outputPath,
-            sizeBytes = bytes.size.toLong()
-        )
-        fileManager.saveMetadata(gribFile)
-        return DownloadResult.Success(gribFile)
-    }
-}
diff --git a/android-app/app/src/main/kotlin/com/example/androidapp/gps/GpsPosition.kt b/android-app/app/src/main/kotlin/com/example/androidapp/gps/GpsPosition.kt
deleted file mode 100644
index cbe5c84..0000000
--- a/android-app/app/src/main/kotlin/com/example/androidapp/gps/GpsPosition.kt
+++ /dev/null
@@ -1,10 +0,0 @@
-package com.example.androidapp.gps
-
-data class GpsPosition(
-    val latitude: Double,           // degrees, positive = North
-    val longitude: Double,          // degrees, positive = East
-    val sog: Double,                // Speed Over Ground in knots
-    val cog: Double,                // Course Over Ground in degrees true (0-360)
-    val timestampMs: Long,          // Unix millis UTC
-    val accuracyMeters: Double? = null  // estimated horizontal accuracy (1-sigma); null = unknown
-)
diff --git a/android-app/app/src/main/kotlin/com/example/androidapp/gps/LocationService.kt b/android-app/app/src/main/kotlin/com/example/androidapp/gps/LocationService.kt
deleted file mode 100644
index 0a315d4..0000000
--- a/android-app/app/src/main/kotlin/com/example/androidapp/gps/LocationService.kt
+++ /dev/null
@@ -1,216 +0,0 @@
-package com.example.androidapp.gps
-
-import com.example.androidapp.data.model.SensorData
-import com.example.androidapp.wind.TrueWindCalculator
-import com.example.androidapp.wind.ApparentWind
-import com.example.androidapp.wind.TrueWindData
-import kotlinx.coroutines.flow.MutableStateFlow
-import kotlinx.coroutines.flow.StateFlow
-import kotlinx.coroutines.flow.asStateFlow
-
-/** Source of the currently active GPS fix. */
-enum class GpsSource { NONE, NMEA, ANDROID }
-
-/**
- * Aggregates real-time location and environmental sensor data for use throughout
- * the safety subsystem (Section 4.6 of COMPONENT_DESIGN.md).
- *
- * ## GPS sensor fusion
- * The service accepts fixes from two independent sources:
- *  - **NMEA GPS** — dedicated marine GPS received via [updateNmeaGps] (higher priority)
- *  - **Android GPS** — device built-in location via [updateAndroidGps] (fallback)
- *
- * Selection policy (evaluated on every new fix):
- *  1. Prefer NMEA when its most recent fix is no older than [nmeaStalenessThresholdMs].
- *  2. When NMEA is marginally stale (older than [nmeaStalenessThresholdMs] but within
- *     [nmeaExtendedThresholdMs]) **and** Android GPS is also available, compare
- *     [GpsPosition.accuracyMeters]: keep NMEA if its reported accuracy is strictly better
- *     (lower metres).  Fall back to Android when accuracy is unavailable or Android wins.
- *  3. Fall back to Android GPS when NMEA is very stale (beyond [nmeaExtendedThresholdMs]).
- *  4. Use stale NMEA only when Android GPS has never provided a fix.
- *  5. [bestPosition] is null until at least one source has reported.
- *
- * Call [updateSensorData] whenever new NMEA or Signal K sensor data arrives and
- * [updateCurrentConditions] when a fresh marine-forecast response is received.
- * Use [snapshot] to capture a point-in-time reading at safety-critical moments
- * such as MOB activation.
- *
- * @param nmeaStalenessThresholdMs Maximum age (ms) of an NMEA fix before it enters the
- *        quality-comparison zone.  Default: 5 000 ms.
- * @param nmeaExtendedThresholdMs Maximum age (ms) up to which a marginally-stale NMEA fix
- *        can still win over Android if its [GpsPosition.accuracyMeters] is strictly better.
- *        Must be ≥ [nmeaStalenessThresholdMs].  Default: 10 000 ms.
- * @param clockMs Injectable clock for unit-testable staleness checks.
- */
-class LocationService(
-    private val windCalculator: TrueWindCalculator = TrueWindCalculator(),
-    private val nmeaStalenessThresholdMs: Long = 5_000L,
-    private val nmeaExtendedThresholdMs: Long = 10_000L,
-    private val clockMs: () -> Long = System::currentTimeMillis
-) {
-
-    private val _latestSensor = MutableStateFlow<SensorData?>(null)
-    /** The most recently received unified sensor reading. */
-    val latestSensor: StateFlow<SensorData?> = _latestSensor.asStateFlow()
-
-    private val _latestTrueWind = MutableStateFlow<TrueWindData?>(null)
-    /** Most recent resolved true-wind vector, updated whenever a full sensor reading arrives. */
-    val latestTrueWind: StateFlow<TrueWindData?> = _latestTrueWind.asStateFlow()
-
-    private val _currentSpeedKt = MutableStateFlow<Double?>(null)
-    private val _currentDirectionDeg = MutableStateFlow<Double?>(null)
-
-    // ── GPS sensor fusion state ───────────────────────────────────────────────
-
-    private var lastNmeaPosition: GpsPosition? = null
-    private var lastAndroidPosition: GpsPosition? = null
-
-    private val _bestPosition = MutableStateFlow<GpsPosition?>(null)
-    /**
-     * The best available GPS fix, selected from NMEA and Android sources according
-     * to the fusion policy described in the class KDoc.  Null until at least one
-     * source reports a fix.
-     */
-    val bestPosition: StateFlow<GpsPosition?> = _bestPosition.asStateFlow()
-
-    private val _activeGpsSource = MutableStateFlow(GpsSource.NONE)
-    /** The source that produced [bestPosition]. [GpsSource.NONE] before any fix arrives. */
-    val activeGpsSource: StateFlow<GpsSource> = _activeGpsSource.asStateFlow()
-
-    /**
-     * Ingest a new sensor reading.  If the reading carries apparent wind, boat speed,
-     * and heading, true wind is resolved immediately via [TrueWindCalculator] and
-     * stored in [latestTrueWind].
-     */
-    fun updateSensorData(data: SensorData) {
-        _latestSensor.value = data
-
-        val aws = data.apparentWindSpeedKt
-        val awa = data.apparentWindAngleDeg
-        val bsp = data.speedOverGroundKt   // use SOG as proxy when BSP is absent
-        val hdg = data.headingTrueDeg
-
-        if (aws != null && awa != null && bsp != null && hdg != null) {
-            _latestTrueWind.value = windCalculator.update(
-                apparent = ApparentWind(speedKt = aws, angleDeg = awa),
-                bsp = bsp,
-                hdgDeg = hdg
-            )
-        }
-    }
-
-    // ── GPS source ingestion ──────────────────────────────────────────────────
-
-    /**
-     * Ingest a new GPS fix from the NMEA source (e.g. a marine chartplotter or
-     * NMEA multiplexer).  Triggers a fusion re-evaluation.
-     */
-    fun updateNmeaGps(position: GpsPosition) {
-        lastNmeaPosition = position
-        recomputeBestPosition()
-    }
-
-    /**
-     * Ingest a new GPS fix from the Android system location provider.
-     * Triggers a fusion re-evaluation.
-     */
-    fun updateAndroidGps(position: GpsPosition) {
-        lastAndroidPosition = position
-        recomputeBestPosition()
-    }
-
-    /**
-     * Selects the best GPS fix and updates [bestPosition] / [activeGpsSource].
-     *
-     * Priority tiers (in order):
-     *  1. Fresh NMEA (age ≤ [nmeaStalenessThresholdMs]) — always preferred.
-     *  2. Marginally-stale NMEA (age in (primary, extended] threshold) when Android is
-     *     also available — keep NMEA only if its [GpsPosition.accuracyMeters] is strictly
-     *     better than Android's; otherwise use Android.
-     *  3. Android GPS (any age) once NMEA is beyond the extended threshold.
-     *  4. Stale NMEA — used as last resort when Android has never reported.
-     */
-    private fun recomputeBestPosition() {
-        val now = clockMs()
-        val nmea = lastNmeaPosition
-        val android = lastAndroidPosition
-
-        val nmeaAge = nmea?.let { now - it.timestampMs }
-        val nmeaFresh = nmeaAge != null && nmeaAge <= nmeaStalenessThresholdMs
-        val nmeaMarginallyStale = nmeaAge != null &&
-                nmeaAge > nmeaStalenessThresholdMs &&
-                nmeaAge <= nmeaExtendedThresholdMs
-
-        val (best, source) = when {
-            nmeaFresh -> nmea!! to GpsSource.NMEA
-
-            nmeaMarginallyStale && android != null ->
-                // Quality tie-break: NMEA wins only when it has a strictly better accuracy.
-                if (nmea!!.hasStrictlyBetterAccuracyThan(android)) nmea to GpsSource.NMEA
-                else android to GpsSource.ANDROID
-
-            android != null -> android to GpsSource.ANDROID
-            nmea != null    -> nmea    to GpsSource.NMEA   // only source, however stale
-            else            -> null    to GpsSource.NONE
-        }
-
-        _bestPosition.value = best
-        _activeGpsSource.value = source
-    }
-
-    // ── private helpers ───────────────────────────────────────────────────────
-
-    /**
-     * Returns true when this fix carries an accuracy estimate that is numerically
-     * smaller (i.e. better) than [other]'s.  Returns false when either estimate is
-     * absent — conservatively preferring the other source when quality is unknown.
-     */
-    private fun GpsPosition.hasStrictlyBetterAccuracyThan(other: GpsPosition): Boolean {
-        val thisAccuracy = accuracyMeters ?: return false
-        val otherAccuracy = other.accuracyMeters ?: return true
-        return thisAccuracy < otherAccuracy
-    }
-
-    /**
-     * Update the ocean current conditions from the latest marine-forecast response.
-     *
-     * @param speedKt     Current speed in knots (null to clear)
-     * @param directionDeg Direction the current flows TOWARD, in degrees (null to clear)
-     */
-    fun updateCurrentConditions(speedKt: Double?, directionDeg: Double?) {
-        _currentSpeedKt.value = speedKt
-        _currentDirectionDeg.value = directionDeg
-    }
-
-    /**
-     * Captures a snapshot of wind and current conditions at the current moment.
-     *
-     * All fields are nullable — only data that was available at snapshot time is
-     * populated.  This snapshot is intended to be logged alongside a [MobEvent]
-     * at the instant of MOB activation.
-     */
-    fun snapshot(): EnvironmentalSnapshot {
-        val trueWind = _latestTrueWind.value
-        return EnvironmentalSnapshot(
-            windSpeedKt = trueWind?.speedKt,
-            windDirectionDeg = trueWind?.directionDeg,
-            currentSpeedKt = _currentSpeedKt.value,
-            currentDirectionDeg = _currentDirectionDeg.value
-        )
-    }
-}
-
-/**
- * Point-in-time snapshot of wind and current conditions.
- *
- * @param windSpeedKt      True Wind Speed in knots; null if sensors were unavailable.
- * @param windDirectionDeg True Wind Direction (degrees true, wind comes FROM); null if unavailable.
- * @param currentSpeedKt   Ocean current speed in knots; null if forecast was unavailable.
- * @param currentDirectionDeg Ocean current direction (degrees, flows TOWARD); null if unavailable.
- */
-data class EnvironmentalSnapshot(
-    val windSpeedKt: Double?,
-    val windDirectionDeg: Double?,
-    val currentSpeedKt: Double?,
-    val currentDirectionDeg: Double?
-)
diff --git a/android-app/app/src/main/kotlin/com/example/androidapp/logbook/LogbookFormatter.kt b/android-app/app/src/main/kotlin/com/example/androidapp/logbook/LogbookFormatter.kt
deleted file mode 100644
index d4cf50d..0000000
--- a/android-app/app/src/main/kotlin/com/example/androidapp/logbook/LogbookFormatter.kt
+++ /dev/null
@@ -1,81 +0,0 @@
-package com.example.androidapp.logbook
-
-import org.terst.nav.data.model.LogbookEntry
-import java.util.Calendar
-import java.util.TimeZone
-
-data class LogbookRow(
-    val time: String,
-    val position: String,
-    val sog: String,
-    val cog: String,
-    val wind: String,
-    val baro: String,
-    val depth: String,
-    val eventNotes: String
-)
-
-data class LogbookPage(
-    val title: String,
-    val columns: List<String>,
-    val rows: List<LogbookRow>
-)
-
-object LogbookFormatter {
-
-    val COLUMNS = listOf(
-        "Time (UTC)", "Position", "SOG", "COG", "Wind", "Baro", "Depth", "Event / Notes"
-    )
-
-    private val COMPASS_POINTS = arrayOf(
-        "N", "NNE", "NE", "ENE", "E", "ESE", "SE", "SSE",
-        "S", "SSW", "SW", "WSW", "W", "WNW", "NW", "NNW"
-    )
-
-    fun formatTime(timestampMs: Long): String {
-        val cal = Calendar.getInstance(TimeZone.getTimeZone("UTC"))
-        cal.timeInMillis = timestampMs
-        return "%02d:%02d".format(
-            cal.get(Calendar.HOUR_OF_DAY),
-            cal.get(Calendar.MINUTE)
-        )
-    }
-
-    fun formatPosition(lat: Double, lon: Double): String {
-        val latDir = if (lat >= 0) "N" else "S"
-        val lonDir = if (lon >= 0) "E" else "W"
-        val absLat = Math.abs(lat)
-        val absLon = Math.abs(lon)
-        val latDeg = absLat.toInt()
-        val lonDeg = absLon.toInt()
-        val latMin = (absLat - latDeg) * 60.0
-        val lonMin = (absLon - lonDeg) * 60.0
-        return "%d°%.1f%s %d°%.1f%s".format(latDeg, latMin, latDir, lonDeg, lonMin, lonDir)
-    }
-
-    fun toCompassPoint(degrees: Double): String {
-        val normalized = ((degrees % 360.0) + 360.0) % 360.0
-        val index = ((normalized + 11.25) / 22.5).toInt() % 16
-        return COMPASS_POINTS[index]
-    }
-
-    fun formatWind(knots: Double?, directionDeg: Double?): String {
-        if (knots == null) return ""
-        val knotsStr = "%.0fkt".format(knots)
-        return if (directionDeg == null) knotsStr else "$knotsStr ${toCompassPoint(directionDeg)}"
-    }
-
-    fun toRow(entry: LogbookEntry): LogbookRow = LogbookRow(
-        time = formatTime(entry.timestampMs),
-        position = formatPosition(entry.lat, entry.lon),
-        sog = "%.1f".format(entry.sogKnots),
-        cog = "%.0f".format(entry.cogDegrees),
-        wind = formatWind(entry.windKnots, entry.windDirectionDeg),
-        baro = entry.baroHpa?.let { "%.0f".format(it) } ?: "",
-        depth = entry.depthMeters?.let { "%.0fm".format(it) } ?: "",
-        eventNotes = listOfNotNull(entry.event, entry.notes).joinToString(": ")
-    )
-
-    fun toPage(entries: List<LogbookEntry>, title: String = "Trip Logbook"): LogbookPage =
-        LogbookPage(title = title, columns = COLUMNS, rows = entries.map { toRow(it) })
-}
diff --git a/android-app/app/src/main/kotlin/com/example/androidapp/logbook/LogbookPdfExporter.kt b/android-app/app/src/main/kotlin/com/example/androidapp/logbook/LogbookPdfExporter.kt
deleted file mode 100644
index 78ea834..0000000
--- a/android-app/app/src/main/kotlin/com/example/androidapp/logbook/LogbookPdfExporter.kt
+++ /dev/null
@@ -1,137 +0,0 @@
-package com.example.androidapp.logbook
-
-import android.graphics.Canvas
-import android.graphics.Color
-import android.graphics.Paint
-import android.graphics.Typeface
-import android.graphics.pdf.PdfDocument
-import org.terst.nav.data.model.LogbookEntry
-import java.io.OutputStream
-
-/**
- * Renders trip logbook entries to a formatted PDF (landscape A4).
- * Section 4.8 — Trip Logging and Electronic Logbook.
- */
-object LogbookPdfExporter {
-
-    // Landscape A4 in points (1 point = 1/72 inch)
-    private const val PAGE_WIDTH = 842
-    private const val PAGE_HEIGHT = 595
-    private const val MARGIN = 36f
-    private const val ROW_HEIGHT = 22f
-    private const val HEADER_HEIGHT = 36f
-    private const val TITLE_SIZE = 16f
-    private const val CELL_TEXT_SIZE = 9f
-
-    // Column width fractions (must sum to 1.0)
-    private val COL_FRACTIONS = floatArrayOf(
-        0.08f, // Time
-        0.18f, // Position
-        0.06f, // SOG
-        0.06f, // COG
-        0.10f, // Wind
-        0.07f, // Baro
-        0.07f, // Depth
-        0.38f  // Event / Notes
-    )
-
-    fun export(
-        entries: List<LogbookEntry>,
-        outputStream: OutputStream,
-        title: String = "Trip Logbook"
-    ) {
-        val page = LogbookFormatter.toPage(entries, title)
-        val document = PdfDocument()
-        try {
-            val pageInfo = PdfDocument.PageInfo.Builder(PAGE_WIDTH, PAGE_HEIGHT, 1).create()
-            val pdfPage = document.startPage(pageInfo)
-            drawPage(pdfPage.canvas, page)
-            document.finishPage(pdfPage)
-            document.writeTo(outputStream)
-        } finally {
-            document.close()
-        }
-    }
-
-    private fun drawPage(canvas: Canvas, page: LogbookPage) {
-        val usableWidth = PAGE_WIDTH - 2 * MARGIN
-        val colWidths = COL_FRACTIONS.map { it * usableWidth }
-
-        val titlePaint = Paint().apply {
-            textSize = TITLE_SIZE
-            typeface = Typeface.DEFAULT_BOLD
-            color = Color.BLACK
-        }
-        val headerTextPaint = Paint().apply {
-            textSize = CELL_TEXT_SIZE
-            typeface = Typeface.DEFAULT_BOLD
-            color = Color.WHITE
-        }
-        val cellPaint = Paint().apply {
-            textSize = CELL_TEXT_SIZE
-            color = Color.BLACK
-        }
-        val linePaint = Paint().apply {
-            color = Color.LTGRAY
-            strokeWidth = 0.5f
-        }
-        val headerBgPaint = Paint().apply {
-            color = Color.rgb(41, 82, 123)
-            style = Paint.Style.FILL
-        }
-        val altBgPaint = Paint().apply {
-            color = Color.rgb(235, 242, 252)
-            style = Paint.Style.FILL
-        }
-        val borderPaint = Paint().apply {
-            color = Color.DKGRAY
-            strokeWidth = 1f
-            style = Paint.Style.STROKE
-        }
-
-        var y = MARGIN
-
-        // Title
-        canvas.drawText(page.title, MARGIN, y + TITLE_SIZE, titlePaint)
-        y += HEADER_HEIGHT
-
-        val tableTop = y
-
-        // Column header background
-        canvas.drawRect(MARGIN, y, PAGE_WIDTH - MARGIN, y + ROW_HEIGHT, headerBgPaint)
-
-        // Column header text
-        var x = MARGIN + 3f
-        page.columns.forEachIndexed { i, col ->
-            canvas.drawText(col, x, y + ROW_HEIGHT - 6f, headerTextPaint)
-            x += colWidths[i]
-        }
-        y += ROW_HEIGHT
-
-        // Data rows
-        page.rows.forEach { row ->
-            if (y + ROW_HEIGHT > PAGE_HEIGHT - MARGIN) return@forEach
-
-            if (page.rows.indexOf(row) % 2 == 1) {
-                canvas.drawRect(MARGIN, y, PAGE_WIDTH - MARGIN, y + ROW_HEIGHT, altBgPaint)
-            }
-
-            val cells = listOf(
-                row.time, row.position, row.sog, row.cog,
-                row.wind, row.baro, row.depth, row.eventNotes
-            )
-            x = MARGIN + 3f
-            cells.forEachIndexed { i, cell ->
-                val maxChars = (colWidths[i] / (CELL_TEXT_SIZE * 0.55)).toInt().coerceAtLeast(4)
-                canvas.drawText(cell.take(maxChars), x, y + ROW_HEIGHT - 6f, cellPaint)
-                x += colWidths[i]
-            }
-
-            canvas.drawLine(MARGIN, y + ROW_HEIGHT, PAGE_WIDTH - MARGIN, y + ROW_HEIGHT, linePaint)
-            y += ROW_HEIGHT
-        }
-
-        // Table border
-        canvas.drawRect(MARGIN, tableTop, PAGE_WIDTH - MARGIN, y, borderPaint)
-    }
-}
diff --git a/android-app/app/src/main/kotlin/com/example/androidapp/nmea/NmeaParser.kt b/android-app/app/src/main/kotlin/com/example/androidapp/nmea/NmeaParser.kt
deleted file mode 100644
index b1b186a..0000000
--- a/android-app/app/src/main/kotlin/com/example/androidapp/nmea/NmeaParser.kt
+++ /dev/null
@@ -1,94 +0,0 @@
-package com.example.androidapp.nmea
-
-import com.example.androidapp.gps.GpsPosition
-import java.util.Calendar
-import java.util.TimeZone
-
-class NmeaParser {
-
-    /**
-     * Parses an NMEA RMC sentence and returns a [GpsPosition], or null if the
-     * sentence is void (status=V), malformed, or cannot be parsed.
-     *
-     * Supported talker IDs: GP, GN, and any other standard prefix.
-     * SOG and COG default to 0.0 when the fields are absent.
-     */
-    fun parseRmc(sentence: String): GpsPosition? {
-        if (sentence.isBlank()) return null
-
-        val body = if ('*' in sentence) sentence.substringBefore('*') else sentence
-        val fields = body.split(',')
-        if (fields.size < 10) return null
-
-        if (!fields[0].endsWith("RMC")) return null
-        if (fields[2] != "A") return null
-
-        val latStr = fields.getOrNull(3) ?: return null
-        val latDir = fields.getOrNull(4) ?: return null
-        val lonStr = fields.getOrNull(5) ?: return null
-        val lonDir = fields.getOrNull(6) ?: return null
-
-        val latitude = parseNmeaDegrees(latStr) * if (latDir == "S") -1.0 else 1.0
-        val longitude = parseNmeaDegrees(lonStr) * if (lonDir == "W") -1.0 else 1.0
-
-        val sog = fields.getOrNull(7)?.toDoubleOrNull() ?: 0.0
-        val cog = fields.getOrNull(8)?.toDoubleOrNull() ?: 0.0
-
-        val timestampMs = parseTimestamp(
-            timeStr = fields.getOrNull(1) ?: "",
-            dateStr = fields.getOrNull(9) ?: ""
-        )
-        if (timestampMs == 0L) return null
-
-        return GpsPosition(latitude, longitude, sog, cog, timestampMs)
-    }
-
-    /**
-     * Converts NMEA degree-minutes format (DDDMM.MMMM) to decimal degrees.
-     */
-    private fun parseNmeaDegrees(value: String): Double {
-        val raw = value.toDoubleOrNull() ?: return 0.0
-        val degrees = (raw / 100.0).toInt()
-        val minutes = raw - degrees * 100.0
-        return degrees + minutes / 60.0
-    }
-
-    /**
-     * Combines NMEA time (HHMMSS.ss) and date (DDMMYY) into Unix epoch millis UTC.
-     * Returns 0 on any parse failure.
-     */
-    private fun parseTimestamp(timeStr: String, dateStr: String): Long {
-        return try {
-            val cal = Calendar.getInstance(TimeZone.getTimeZone("UTC"))
-            cal.isLenient = false
-
-            if (dateStr.length >= 6) {
-                val day   = dateStr.substring(0, 2).toInt()
-                val month = dateStr.substring(2, 4).toInt() - 1
-                val yy    = dateStr.substring(4, 6).toInt()
-                val year  = if (yy < 70) 2000 + yy else 1900 + yy
-                cal.set(Calendar.YEAR, year)
-                cal.set(Calendar.MONTH, month)
-                cal.set(Calendar.DAY_OF_MONTH, day)
-            }
-
-            if (timeStr.length >= 6) {
-                val hours   = timeStr.substring(0, 2).toInt()
-                val minutes = timeStr.substring(2, 4).toInt()
-                val seconds = timeStr.substring(4, 6).toInt()
-                val millis  = if (timeStr.length > 7) {
-                    val fracStr = timeStr.substring(7)
-                    (("0.$fracStr").toDoubleOrNull()?.times(1000.0))?.toInt() ?: 0
-                } else 0
-                cal.set(Calendar.HOUR_OF_DAY, hours)
-                cal.set(Calendar.MINUTE, minutes)
-                cal.set(Calendar.SECOND, seconds)
-                cal.set(Calendar.MILLISECOND, millis)
-            }
-
-            cal.timeInMillis
-        } catch (e: Exception) {
-            0L
-        }
-    }
-}
diff --git a/android-app/app/src/main/kotlin/com/example/androidapp/routing/IsochroneResult.kt b/android-app/app/src/main/kotlin/com/example/androidapp/routing/IsochroneResult.kt
deleted file mode 100644
index 60a5918..0000000
--- a/android-app/app/src/main/kotlin/com/example/androidapp/routing/IsochroneResult.kt
+++ /dev/null
@@ -1,12 +0,0 @@
-package com.example.androidapp.routing
-
-/**
- * The result of an isochrone weather routing computation.
- *
- * @param path  Ordered list of [RoutePoint]s from the start to the destination.
- * @param etaMs Estimated Time of Arrival as a UNIX timestamp in milliseconds.
- */
-data class IsochroneResult(
-    val path: List<RoutePoint>,
-    val etaMs: Long
-)
diff --git a/android-app/app/src/main/kotlin/com/example/androidapp/routing/IsochroneRouter.kt b/android-app/app/src/main/kotlin/com/example/androidapp/routing/IsochroneRouter.kt
deleted file mode 100644
index 901fdbc..0000000
--- a/android-app/app/src/main/kotlin/com/example/androidapp/routing/IsochroneRouter.kt
+++ /dev/null
@@ -1,178 +0,0 @@
-package com.example.androidapp.routing
-
-import org.terst.nav.data.model.BoatPolars
-import org.terst.nav.data.model.WindForecast
-import kotlin.math.asin
-import kotlin.math.atan2
-import kotlin.math.cos
-import kotlin.math.pow
-import kotlin.math.sin
-import kotlin.math.sqrt
-
-/**
- * Isochrone-based weather routing engine (Section 3.4).
- *
- * Algorithm:
- *  1. Start from a single point; expand a fan of headings at each time step.
- *  2. For each candidate heading, compute BSP from [BoatPolars] at the local forecast wind.
- *  3. Advance position by BSP × Δt using the spherical-Earth destination-point formula.
- *  4. Check whether the destination has been reached (within [arrivalRadiusM]).
- *  5. Prune candidates: for each angular sector around the start, keep only the point that
- *     advanced furthest (removes dominated points).
- *  6. Repeat until the destination is reached or [maxSteps] is exhausted.
- *  7. Backtrace parent pointers to produce the optimal path.
- */
-object IsochroneRouter {
-
-    private const val EARTH_RADIUS_M = 6_371_000.0
-    internal const val NM_TO_M = 1_852.0
-    private const val KT_TO_M_PER_S = NM_TO_M / 3600.0
-
-    const val DEFAULT_HEADING_STEP_DEG = 5.0
-    const val DEFAULT_ARRIVAL_RADIUS_M = 1_852.0   // 1 NM
-    const val DEFAULT_PRUNE_SECTORS = 72           // 5° sectors
-    const val DEFAULT_MAX_STEPS = 200
-
-    /**
-     * Compute an optimised route from start to destination.
-     *
-     * @param startLat        Start latitude (decimal degrees).
-     * @param startLon        Start longitude (decimal degrees).
-     * @param destLat         Destination latitude (decimal degrees).
-     * @param destLon         Destination longitude (decimal degrees).
-     * @param startTimeMs     Departure time as UNIX timestamp (ms).
-     * @param stepMs          Time increment per isochrone step (ms). Typical: 1–3 hours.
-     * @param polars          Boat polar table.
-     * @param windAt          Function returning [WindForecast] for a given position and time.
-     * @param headingStepDeg  Angular resolution of the heading fan (degrees). Default 5°.
-     * @param arrivalRadiusM  Distance threshold to consider destination reached (metres).
-     * @param maxSteps        Maximum number of isochrone expansions before giving up.
-     * @return [IsochroneResult] with the optimal path and ETA, or null if unreachable.
-     */
-    fun route(
-        startLat: Double,
-        startLon: Double,
-        destLat: Double,
-        destLon: Double,
-        startTimeMs: Long,
-        stepMs: Long,
-        polars: BoatPolars,
-        windAt: (lat: Double, lon: Double, timeMs: Long) -> WindForecast,
-        headingStepDeg: Double = DEFAULT_HEADING_STEP_DEG,
-        arrivalRadiusM: Double = DEFAULT_ARRIVAL_RADIUS_M,
-        maxSteps: Int = DEFAULT_MAX_STEPS
-    ): IsochroneResult? {
-        val start = RoutePoint(startLat, startLon, startTimeMs)
-        var isochrone = listOf(start)
-
-        repeat(maxSteps) { step ->
-            val nextTimeMs = startTimeMs + (step + 1).toLong() * stepMs
-            val candidates = mutableListOf<RoutePoint>()
-
-            for (point in isochrone) {
-                var heading = 0.0
-                while (heading < 360.0) {
-                    val wind = windAt(point.lat, point.lon, point.timestampMs)
-                    val twa = ((heading - wind.twdDeg + 360.0) % 360.0)
-                    val bspKt = polars.bsp(twa, wind.twsKt)
-                    if (bspKt > 0.0) {
-                        val distM = bspKt * KT_TO_M_PER_S * (stepMs / 1000.0)
-                        val (newLat, newLon) = destinationPoint(point.lat, point.lon, heading, distM)
-                        val newPoint = RoutePoint(newLat, newLon, nextTimeMs, parent = point)
-
-                        if (haversineM(newLat, newLon, destLat, destLon) <= arrivalRadiusM) {
-                            return IsochroneResult(
-                                path = backtrace(newPoint),
-                                etaMs = nextTimeMs
-                            )
-                        }
-                        candidates.add(newPoint)
-                    }
-                    heading += headingStepDeg
-                }
-            }
-
-            if (candidates.isEmpty()) return null
-            isochrone = prune(candidates, startLat, startLon, DEFAULT_PRUNE_SECTORS)
-        }
-
-        return null
-    }
-
-    /** Walk parent pointers from destination back to start, then reverse. */
-    internal fun backtrace(dest: RoutePoint): List<RoutePoint> {
-        val path = mutableListOf<RoutePoint>()
-        var current: RoutePoint? = dest
-        while (current != null) {
-            path.add(current)
-            current = current.parent
-        }
-        path.reverse()
-        return path
-    }
-
-    /**
-     * Angular-sector pruning: divide the plane into [sectors] equal angular sectors around the
-     * start. Within each sector keep only the candidate that is furthest from the start.
-     */
-    internal fun prune(
-        candidates: List<RoutePoint>,
-        startLat: Double,
-        startLon: Double,
-        sectors: Int
-    ): List<RoutePoint> {
-        val sectorSize = 360.0 / sectors
-        val best = mutableMapOf<Int, RoutePoint>()
-
-        for (point in candidates) {
-            val bearing = bearingDeg(startLat, startLon, point.lat, point.lon)
-            val sector = (bearing / sectorSize).toInt().coerceIn(0, sectors - 1)
-            val existing = best[sector]
-            if (existing == null ||
-                haversineM(startLat, startLon, point.lat, point.lon) >
-                haversineM(startLat, startLon, existing.lat, existing.lon)
-            ) {
-                best[sector] = point
-            }
-        }
-
-        return best.values.toList()
-    }
-
-    /** Haversine great-circle distance in metres. */
-    internal fun haversineM(lat1: Double, lon1: Double, lat2: Double, lon2: Double): Double {
-        val dLat = Math.toRadians(lat2 - lat1)
-        val dLon = Math.toRadians(lon2 - lon1)
-        val a = sin(dLat / 2).pow(2) +
-                cos(Math.toRadians(lat1)) * cos(Math.toRadians(lat2)) * sin(dLon / 2).pow(2)
-        return 2.0 * EARTH_RADIUS_M * asin(sqrt(a))
-    }
-
-    /** Initial bearing from point 1 to point 2 (degrees, 0 = North, clockwise). */
-    internal fun bearingDeg(lat1Deg: Double, lon1Deg: Double, lat2Deg: Double, lon2Deg: Double): Double {
-        val lat1 = Math.toRadians(lat1Deg)
-        val lat2 = Math.toRadians(lat2Deg)
-        val dLon = Math.toRadians(lon2Deg - lon1Deg)
-        val y = sin(dLon) * cos(lat2)
-        val x = cos(lat1) * sin(lat2) - sin(lat1) * cos(lat2) * cos(dLon)
-        return (Math.toDegrees(atan2(y, x)) + 360.0) % 360.0
-    }
-
-    /** Spherical-Earth destination-point given start, bearing, and distance. */
-    internal fun destinationPoint(
-        lat1Deg: Double,
-        lon1Deg: Double,
-        bearingDeg: Double,
-        distM: Double
-    ): Pair<Double, Double> {
-        val lat1 = Math.toRadians(lat1Deg)
-        val lon1 = Math.toRadians(lon1Deg)
-        val brng = Math.toRadians(bearingDeg)
-        val d = distM / EARTH_RADIUS_M
-
-        val lat2 = asin(sin(lat1) * cos(d) + cos(lat1) * sin(d) * cos(brng))
-        val lon2 = lon1 + atan2(sin(brng) * sin(d) * cos(lat1), cos(d) - sin(lat1) * sin(lat2))
-
-        return Pair(Math.toDegrees(lat2), Math.toDegrees(lon2))
-    }
-}
diff --git a/android-app/app/src/main/kotlin/com/example/androidapp/routing/RoutePoint.kt b/android-app/app/src/main/kotlin/com/example/androidapp/routing/RoutePoint.kt
deleted file mode 100644
index 02988d1..0000000
--- a/android-app/app/src/main/kotlin/com/example/androidapp/routing/RoutePoint.kt
+++ /dev/null
@@ -1,16 +0,0 @@
-package com.example.androidapp.routing
-
-/**
- * A single point in the isochrone routing tree.
- *
- * @param lat         Latitude (decimal degrees).
- * @param lon         Longitude (decimal degrees).
- * @param timestampMs UNIX time in milliseconds when this position is reached.
- * @param parent      The previous [RoutePoint] (null for the start point).
- */
-data class RoutePoint(
-    val lat: Double,
-    val lon: Double,
-    val timestampMs: Long,
-    val parent: RoutePoint? = null
-)
diff --git a/android-app/app/src/main/kotlin/com/example/androidapp/safety/AnchorWatchState.kt b/android-app/app/src/main/kotlin/com/example/androidapp/safety/AnchorWatchState.kt
deleted file mode 100644
index f544f63..0000000
--- a/android-app/app/src/main/kotlin/com/example/androidapp/safety/AnchorWatchState.kt
+++ /dev/null
@@ -1,24 +0,0 @@
-package com.example.androidapp.safety
-
-import kotlin.math.sqrt
-
-/**
- * Holds UI-facing state for the anchor watch setup screen and provides
- * the suggested watch-circle radius derived from depth and rode out.
- */
-class AnchorWatchState {
-
-    /**
-     * Returns the recommended watch-circle radius (metres) for the given depth
-     * and amount of rode deployed.
-     *
-     * Uses the Pythagorean formula sqrt(rode² - vertical²) when the geometry is
-     * valid (rode > depth + freeboard).  Falls back to [rodeOutM] itself as the
-     * maximum possible swing radius when the rode is too short to form a catenary angle.
-     */
-    fun calculateRecommendedWatchCircleRadius(depthM: Double, rodeOutM: Double): Double {
-        val vertical = depthM + 2.0 // 2 m default freeboard
-        return if (rodeOutM > vertical) sqrt(rodeOutM * rodeOutM - vertical * vertical)
-        else rodeOutM
-    }
-}
diff --git a/android-app/app/src/main/kotlin/com/example/androidapp/tide/HarmonicTideCalculator.kt b/android-app/app/src/main/kotlin/com/example/androidapp/tide/HarmonicTideCalculator.kt
deleted file mode 100644
index 2bdbf6c..0000000
--- a/android-app/app/src/main/kotlin/com/example/androidapp/tide/HarmonicTideCalculator.kt
+++ /dev/null
@@ -1,88 +0,0 @@
-package com.example.androidapp.tide
-
-import com.example.androidapp.data.model.TidePrediction
-import com.example.androidapp.data.model.TideStation
-import kotlin.math.cos
-
-/**
- * Computes harmonic tide predictions using the standard formula:
- *   h(t) = Z0 + Σ [ Hi × cos( ωi × (t − t0) − φi ) ]
- *
- * where:
- *   Z0  = datum offset (mean water level above chart datum, metres)
- *   Hi  = amplitude of constituent i (metres)
- *   ωi  = angular speed of constituent i (degrees / hour)
- *   t   = hours elapsed since [EPOCH_MS] (2000-01-01 00:00 UTC)
- *   φi  = phase lag (degrees)
- */
-object HarmonicTideCalculator {
-
-    /** Reference epoch: 2000-01-01 00:00:00 UTC in Unix milliseconds. */
-    internal const val EPOCH_MS = 946_684_800_000L
-
-    /**
-     * Predict the tide height at a single moment.
-     *
-     * @param station     Tide station with harmonic constituents.
-     * @param timestampMs Unix epoch milliseconds for the desired time.
-     * @return Predicted height in metres above chart datum.
-     */
-    fun predictHeight(station: TideStation, timestampMs: Long): Double {
-        val hoursFromEpoch = (timestampMs - EPOCH_MS) / 3_600_000.0
-        var height = station.datumOffsetMeters
-        for (c in station.constituents) {
-            val angleDeg = c.speedDegPerHour * hoursFromEpoch - c.phaseDeg
-            height += c.amplitudeMeters * cos(Math.toRadians(angleDeg))
-        }
-        return height
-    }
-
-    /**
-     * Predict tide heights over a time range at regular intervals.
-     *
-     * @param station     Tide station.
-     * @param fromMs      Start of range (Unix milliseconds, inclusive).
-     * @param toMs        End of range (Unix milliseconds, inclusive).
-     * @param intervalMs  Time step in milliseconds (must be positive).
-     * @return List of [TidePrediction] ordered by ascending timestamp.
-     */
-    fun predictRange(
-        station: TideStation,
-        fromMs: Long,
-        toMs: Long,
-        intervalMs: Long
-    ): List<TidePrediction> {
-        require(intervalMs > 0) { "intervalMs must be positive" }
-        require(fromMs <= toMs) { "fromMs must not exceed toMs" }
-        val predictions = mutableListOf<TidePrediction>()
-        var t = fromMs
-        while (t <= toMs) {
-            predictions += TidePrediction(t, predictHeight(station, t))
-            t += intervalMs
-        }
-        return predictions
-    }
-
-    /**
-     * Find high and low water events from a pre-computed prediction series.
-     *
-     * Detects local maxima (high water) and minima (low water) by comparing
-     * each interior sample with its immediate neighbours.
-     *
-     * @param predictions Ordered list of tide predictions (at least 3 points).
-     * @return Subset list containing only high/low turning points.
-     */
-    fun findHighLow(predictions: List<TidePrediction>): List<TidePrediction> {
-        if (predictions.size < 3) return emptyList()
-        val result = mutableListOf<TidePrediction>()
-        for (i in 1 until predictions.size - 1) {
-            val prev = predictions[i - 1].heightMeters
-            val curr = predictions[i].heightMeters
-            val next = predictions[i + 1].heightMeters
-            val isMax = curr >= prev && curr >= next
-            val isMin = curr <= prev && curr <= next
-            if (isMax || isMin) result += predictions[i]
-        }
-        return result
-    }
-}
diff --git a/android-app/app/src/main/kotlin/com/example/androidapp/ui/anchorwatch/AnchorWatchHandler.kt b/android-app/app/src/main/kotlin/com/example/androidapp/ui/anchorwatch/AnchorWatchHandler.kt
deleted file mode 100644
index 289a857..0000000
--- a/android-app/app/src/main/kotlin/com/example/androidapp/ui/anchorwatch/AnchorWatchHandler.kt
+++ /dev/null
@@ -1,58 +0,0 @@
-package com.example.androidapp.ui.anchorwatch
-
-import android.os.Bundle
-import android.text.Editable
-import android.text.TextWatcher
-import android.view.LayoutInflater
-import android.view.View
-import android.view.ViewGroup
-import androidx.fragment.app.Fragment
-import org.terst.nav.R
-import org.terst.nav.databinding.FragmentAnchorWatchBinding
-import com.example.androidapp.safety.AnchorWatchState
-
-class AnchorWatchHandler : Fragment() {
-
-    private var _binding: FragmentAnchorWatchBinding? = null
-    private val binding get() = _binding!!
-
-    private val anchorWatchState = AnchorWatchState()
-
-    override fun onCreateView(
-        inflater: LayoutInflater, container: ViewGroup?,
-        savedInstanceState: Bundle?
-    ): View {
-        _binding = FragmentAnchorWatchBinding.inflate(inflater, container, false)
-        return binding.root
-    }
-
-    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
-        super.onViewCreated(view, savedInstanceState)
-
-        val watcher = object : TextWatcher {
-            override fun beforeTextChanged(s: CharSequence?, start: Int, count: Int, after: Int) = Unit
-            override fun onTextChanged(s: CharSequence?, start: Int, before: Int, count: Int) = Unit
-            override fun afterTextChanged(s: Editable?) = updateSuggestedRadius()
-        }
-        binding.etDepth.addTextChangedListener(watcher)
-        binding.etRodeOut.addTextChangedListener(watcher)
-    }
-
-    private fun updateSuggestedRadius() {
-        val depth = binding.etDepth.text.toString().toDoubleOrNull()
-        val rode = binding.etRodeOut.text.toString().toDoubleOrNull()
-
-        if (depth != null && rode != null && depth >= 0.0 && rode > 0.0) {
-            val radius = anchorWatchState.calculateRecommendedWatchCircleRadius(depth, rode)
-            binding.tvSuggestedRadius.text =
-                getString(R.string.anchor_suggested_radius_fmt, radius)
-        } else {
-            binding.tvSuggestedRadius.text = getString(R.string.anchor_suggested_radius_empty)
-        }
-    }
-
-    override fun onDestroyView() {
-        super.onDestroyView()
-        _binding = null
-    }
-}
diff --git a/android-app/app/src/main/kotlin/com/example/androidapp/wind/ApparentWind.kt b/android-app/app/src/main/kotlin/com/example/androidapp/wind/ApparentWind.kt
deleted file mode 100644
index 01656a3..0000000
--- a/android-app/app/src/main/kotlin/com/example/androidapp/wind/ApparentWind.kt
+++ /dev/null
@@ -1,3 +0,0 @@
-package com.example.androidapp.wind
-
-data class ApparentWind(val speedKt: Double, val angleDeg: Double)
diff --git a/android-app/app/src/main/kotlin/com/example/androidapp/wind/TrueWindCalculator.kt b/android-app/app/src/main/kotlin/com/example/androidapp/wind/TrueWindCalculator.kt
deleted file mode 100644
index db32163..0000000
--- a/android-app/app/src/main/kotlin/com/example/androidapp/wind/TrueWindCalculator.kt
+++ /dev/null
@@ -1,20 +0,0 @@
-package com.example.androidapp.wind
-
-import kotlin.math.atan2
-import kotlin.math.cos
-import kotlin.math.sin
-import kotlin.math.sqrt
-
-class TrueWindCalculator {
-    fun update(apparent: ApparentWind, bsp: Double, hdgDeg: Double): TrueWindData {
-        val awaRad = Math.toRadians(apparent.angleDeg)
-        val awX = apparent.speedKt * cos(awaRad)
-        val awY = apparent.speedKt * sin(awaRad)
-        val twX = awX - bsp
-        val twY = awY
-        val tws = sqrt(twX * twX + twY * twY)
-        val twaDeg = Math.toDegrees(atan2(twY, twX))
-        val twdDeg = ((hdgDeg + twaDeg) % 360 + 360) % 360
-        return TrueWindData(speedKt = tws, directionDeg = twdDeg)
-    }
-}
diff --git a/android-app/app/src/main/kotlin/com/example/androidapp/wind/TrueWindData.kt b/android-app/app/src/main/kotlin/com/example/androidapp/wind/TrueWindData.kt
deleted file mode 100644
index 78e9558..0000000
--- a/android-app/app/src/main/kotlin/com/example/androidapp/wind/TrueWindData.kt
+++ /dev/null
@@ -1,3 +0,0 @@
-package com.example.androidapp.wind
-
-data class TrueWindData(val speedKt: Double, val directionDeg: Double)