diff --git a/demo/src/main/java/com/google/maps/android/utils/demo/FlexiblePolylineDemoActivity.kt b/demo/src/main/java/com/google/maps/android/utils/demo/FlexiblePolylineDemoActivity.kt
index 4d899165d..8c8bed9c7 100644
--- a/demo/src/main/java/com/google/maps/android/utils/demo/FlexiblePolylineDemoActivity.kt
+++ b/demo/src/main/java/com/google/maps/android/utils/demo/FlexiblePolylineDemoActivity.kt
@@ -15,54 +15,308 @@
  */
 package com.google.maps.android.utils.demo
 
-import android.widget.Toast
+import android.view.ViewGroup
+import android.widget.SeekBar
+import androidx.annotation.StringRes
+import androidx.lifecycle.lifecycleScope
 import com.google.android.gms.maps.CameraUpdateFactory
 import com.google.android.gms.maps.model.LatLng
+import com.google.android.gms.maps.model.Marker
+import com.google.android.gms.maps.model.MarkerOptions
+import com.google.android.gms.maps.model.Polyline
 import com.google.android.gms.maps.model.PolylineOptions
+import com.google.maps.android.FlexiblePoint
+import com.google.maps.android.FlexiblePolyline
 import com.google.maps.android.FlexiblePolylineUtil
+import com.google.maps.android.ThirdDimension
+import com.google.maps.android.utils.demo.databinding.ActivityFlexiblePolylineDemoBinding
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.launch
+import kotlin.math.cos
+import kotlin.math.sin
 
 /**
- * Decodes a flexible polyline with [FlexiblePolylineUtil] and draws it.
- *
- * [ENCODED_WALKWAY] holds ten points along the Sydney Harbour Bridge walkway at seven decimal
- * places. [FlexiblePolylineUtil.decodeToLatLngs] supplies the path for [PolylineOptions].
+ * Demonstrates encoding, decoding, and scrubbing synthetic 4D flexible polyline tracks carrying
+ * sub-metre coordinates (`precision = 6`, ~11 cm), decimetre vertical height
+ * ([ThirdDimension.ELEVATION] or [ThirdDimension.ALTITUDE], `thirdDimensionPrecision = 1`, 10 cm),
+ * and sub-second timestamps (`timePrecision = 1`, 100 ms).
  */
-class FlexiblePolylineDemoActivity : BaseDemoActivity() {
+class FlexiblePolylineDemoActivity :
+    BaseDemoActivity(),
+    SeekBar.OnSeekBarChangeListener {
+
+    private lateinit var binding: ActivityFlexiblePolylineDemoBinding
+    private lateinit var decodedTrack: FlexiblePolyline
+    private var backgroundPolyline: Polyline? = null
+    private var activePolyline: Polyline? = null
+    private var positionMarker: Marker? = null
+    private var playbackJob: Job? = null
+    private var currentFraction: Double = 0.0
+
+    override fun getLayoutId(): Int = R.layout.activity_flexible_polyline_demo
+
     override fun startDemo(isRestore: Boolean) {
+        val rootView = findViewById<ViewGroup>(android.R.id.content).getChildAt(0)
+        binding = ActivityFlexiblePolylineDemoBinding.bind(rootView)
+
+        binding.presetHikeButton.setOnClickListener {
+            loadPreset(TrackPreset.ALPINE_RUN, moveCamera = true)
+        }
+        binding.presetBikeButton.setOnClickListener {
+            loadPreset(TrackPreset.BIKE_CLIMB, moveCamera = true)
+        }
+        binding.presetFlightButton.setOnClickListener {
+            loadPreset(TrackPreset.SCENIC_FLIGHT, moveCamera = true)
+        }
+
+        binding.timeSeekBar.setOnSeekBarChangeListener(this)
+        binding.restartButton.setOnClickListener {
+            stopPlayback()
+            updateScrubber(0.0)
+            startPlayback()
+        }
+        binding.playPauseButton.setOnClickListener {
+            if (playbackJob?.isActive == true) {
+                stopPlayback()
+            } else {
+                startPlayback()
+            }
+        }
+
+        loadPreset(TrackPreset.ALPINE_RUN, moveCamera = !isRestore)
+    }
+
+    private fun loadPreset(preset: TrackPreset, moveCamera: Boolean) {
         val map = map ?: return
-        val path = FlexiblePolylineUtil.decodeToLatLngs(ENCODED_WALKWAY)
-
-        map.addPolyline(
-            PolylineOptions()
-                .addAll(path)
-                .width(POLYLINE_WIDTH)
-                .color(POLYLINE_COLOR),
-        )
-
-        Toast.makeText(
-            this,
-            getString(R.string.flexible_polyline_summary, path.size),
-            Toast.LENGTH_SHORT,
-        ).show()
-
-        if (!isRestore) {
-            map.moveCamera(CameraUpdateFactory.newLatLngZoom(CAMERA_TARGET, CAMERA_ZOOM))
+        stopPlayback()
+
+        binding.trackTitleText.setText(preset.titleResId)
+
+        // [START maps_android_utils_flexible_polyline_encode_4d]
+        val encodedTrack =
+            FlexiblePolylineUtil.encode(
+                points = preset.points,
+                precision = 6, // ~11 cm lat/lng resolution
+                thirdDimension = preset.thirdDimension,
+                thirdDimensionPrecision = 1, // 10 cm vertical resolution
+                hasTime = true,
+                timePrecision = 1, // 100 ms timestamp resolution
+            )
+        // [END maps_android_utils_flexible_polyline_encode_4d]
+
+        // [START maps_android_utils_flexible_polyline_decode_4d]
+        decodedTrack = FlexiblePolylineUtil.decode(encodedTrack)
+        // [END maps_android_utils_flexible_polyline_decode_4d]
+
+        binding.headerMetaText.text =
+            getString(
+                R.string.flexible_polyline_header_fmt,
+                decodedTrack.points.size,
+                encodedTrack.length,
+                decodedTrack.precision,
+                decodedTrack.thirdDimension.name,
+                decodedTrack.thirdDimensionPrecision,
+                decodedTrack.timePrecision,
+            )
+
+        backgroundPolyline?.remove()
+        backgroundPolyline =
+            map.addPolyline(
+                PolylineOptions()
+                    .addAll(decodedTrack.toLatLngs())
+                    .width(BACKGROUND_POLYLINE_WIDTH)
+                    .color(BACKGROUND_POLYLINE_COLOR),
+            )
+
+        if (moveCamera) {
+            map.moveCamera(CameraUpdateFactory.newLatLngZoom(preset.cameraTarget, preset.cameraZoom))
+        }
+
+        updateScrubber(0.0)
+        startPlayback()
+    }
+
+    private fun startPlayback() {
+        stopPlayback()
+        binding.playPauseButton.setText(R.string.polyline_progress_pause)
+        playbackJob =
+            lifecycleScope.launch {
+                while (true) {
+                    val next = if (currentFraction >= 1.0) 0.0 else (currentFraction + PLAYBACK_STEP).coerceAtMost(1.0)
+                    updateScrubber(next)
+                    delay(PLAYBACK_DELAY_MS)
+                }
+            }
+    }
+
+    private fun stopPlayback() {
+        playbackJob?.cancel()
+        playbackJob = null
+        if (::binding.isInitialized) {
+            binding.playPauseButton.setText(R.string.flexible_polyline_play)
         }
     }
 
+    private fun updateScrubber(fraction: Double) {
+        currentFraction = fraction
+        binding.timeSeekBar.progress = (fraction * SEEK_BAR_MAX).toInt()
+
+        val startMillis = decodedTrack.points.first().timestampMillis ?: return
+        val durationMillis = decodedTrack.durationMillis ?: return
+        val targetMillis = startMillis + (durationMillis * fraction).toLong()
+
+        // [START maps_android_utils_flexible_polyline_interpolate]
+        val currentPoint = decodedTrack.interpolateAtTime(targetMillis) ?: return
+        val prefixLatLngs = decodedTrack.getPrefixAtTime(targetMillis).map(FlexiblePoint::toLatLng)
+        // [END maps_android_utils_flexible_polyline_interpolate]
+
+        val verticalMeters = currentPoint.thirdDimensionValue ?: 0.0
+        val elapsedSeconds = (targetMillis - startMillis) / 1000.0
+        val totalSeconds = durationMillis / 1000.0
+
+        binding.telemetryText.text =
+            getString(
+                R.string.flexible_polyline_telemetry_fmt,
+                decodedTrack.thirdDimension.name,
+                verticalMeters,
+                elapsedSeconds,
+                totalSeconds,
+            )
+
+        activePolyline?.remove()
+        if (prefixLatLngs.isNotEmpty()) {
+            activePolyline =
+                map?.addPolyline(
+                    PolylineOptions()
+                        .addAll(prefixLatLngs)
+                        .width(ACTIVE_POLYLINE_WIDTH)
+                        .color(ACTIVE_POLYLINE_COLOR)
+                        .zIndex(1f),
+                )
+        }
+
+        val latLng = currentPoint.toLatLng()
+        val marker = positionMarker
+        if (marker == null) {
+            positionMarker =
+                map?.addMarker(
+                    MarkerOptions()
+                        .position(latLng)
+                        .title(binding.trackTitleText.text.toString()),
+                )
+        } else {
+            marker.position = latLng
+            marker.title = binding.trackTitleText.text.toString()
+        }
+    }
+
+    override fun onProgressChanged(seekBar: SeekBar?, progress: Int, fromUser: Boolean) {
+        if (fromUser) {
+            stopPlayback()
+            updateScrubber(progress.toDouble() / SEEK_BAR_MAX)
+        }
+    }
+
+    override fun onStartTrackingTouch(seekBar: SeekBar?) {
+        stopPlayback()
+    }
+
+    override fun onStopTrackingTouch(seekBar: SeekBar?) = Unit
+
+    /**
+     * Purely synthetic 4D track presets illustrating [ThirdDimension.ELEVATION] and
+     * [ThirdDimension.ALTITUDE] with sub-second timestamps.
+     */
+    private enum class TrackPreset(
+        @StringRes val titleResId: Int,
+        val thirdDimension: ThirdDimension,
+        val cameraTarget: LatLng,
+        val cameraZoom: Float,
+        val points: List<FlexiblePoint>,
+    ) {
+        ALPINE_RUN(
+            titleResId = R.string.flexible_polyline_title_hike,
+            thirdDimension = ThirdDimension.ELEVATION,
+            cameraTarget = LatLng(46.7980, -121.7280),
+            cameraZoom = 13.5f,
+            points = generateAlpineTrailTrack(),
+        ),
+        BIKE_CLIMB(
+            titleResId = R.string.flexible_polyline_title_bike,
+            thirdDimension = ThirdDimension.ELEVATION,
+            cameraTarget = LatLng(37.8285, -122.4995),
+            cameraZoom = 14.2f,
+            points = generateBikeClimbTrack(),
+        ),
+        SCENIC_FLIGHT(
+            titleResId = R.string.flexible_polyline_title_flight,
+            thirdDimension = ThirdDimension.ALTITUDE,
+            cameraTarget = LatLng(-33.8540, 151.2150),
+            cameraZoom = 13.2f,
+            points = generateScenicFlightTrack(),
+        ),
+    }
+
     private companion object {
-        /**
-         * The Sydney Harbour Bridge walkway, encoded at precision 7. The alphabet is URL safe,
-         * so the string needs no escaping in source, a URL or a JSON field. The Google format
-         * sample in [PolyDecodeDemoActivity] contains four backslashes that are doubled in the
-         * Java literal.
-         */
-        const val ENCODED_WALKWAY =
-            "BH__k0lU4kokk6CnzQnqDnzQvwDnzQvwDnzQvwDnzQvwDnzQvwDnzQvwDnzQvwDnzQvwD"
-
-        val CAMERA_TARGET = LatLng(-33.85343, 151.21083)
-        const val CAMERA_ZOOM = 15f
-        const val POLYLINE_WIDTH = 12f
-        const val POLYLINE_COLOR = 0xFF1A73E8.toInt()
+        const val BASE_TIME_MILLIS = 1_767_254_400_000L // 2026-01-01T08:00:00Z
+        const val POINT_COUNT = 240
+        const val BACKGROUND_POLYLINE_WIDTH = 10f
+        const val ACTIVE_POLYLINE_WIDTH = 14f
+        const val BACKGROUND_POLYLINE_COLOR = 0x665F6368
+        const val ACTIVE_POLYLINE_COLOR = 0xFF1A73E8.toInt()
+        const val SEEK_BAR_MAX = 1000
+        const val PLAYBACK_STEP = 0.008
+        const val PLAYBACK_DELAY_MS = 50L
+
+        /** Generates a synthetic 240-point alpine switchback trail near Mount Rainier. */
+        fun generateAlpineTrailTrack(): List<FlexiblePoint> {
+            var currentMillis = BASE_TIME_MILLIS
+            return (0 until POINT_COUNT).map { step ->
+                val p = step / (POINT_COUNT - 1.0)
+                val lat = 46.786000 + p * 0.024000 + 0.001600 * sin(p * 18.0)
+                val lng = -121.736000 + p * 0.016000 + 0.002200 * cos(p * 18.0)
+                val elevation = 1_650.0 + 630.0 * sin(p * Math.PI) + 14.0 * sin(p * 28.0)
+                if (step > 0) {
+                    // Pace slows during the first-half climb and quickens on the descent
+                    val stepDurationMillis = if (p < 0.5) 2_400L else 1_500L
+                    currentMillis += stepDurationMillis
+                }
+                FlexiblePoint(lat, lng, elevation, currentMillis)
+            }
+        }
+
+        /** Generates a synthetic 240-point hairpin cycling loop in the Marin Headlands. */
+        fun generateBikeClimbTrack(): List<FlexiblePoint> {
+            var currentMillis = BASE_TIME_MILLIS
+            return (0 until POINT_COUNT).map { step ->
+                val p = step / (POINT_COUNT - 1.0)
+                val angle = p * 2.0 * Math.PI
+                val lat = 37.828500 + 0.008500 * sin(angle) + 0.001200 * sin(angle * 6.0)
+                val lng = -122.499500 + 0.011000 * cos(angle) + 0.001200 * cos(angle * 6.0)
+                val elevation = 25.0 + 255.0 * sin(p * Math.PI)
+                if (step > 0) {
+                    val stepDurationMillis = if (p < 0.5) 1_800L else 700L
+                    currentMillis += stepDurationMillis
+                }
+                FlexiblePoint(lat, lng, elevation, currentMillis)
+            }
+        }
+
+        /** Generates a synthetic 240-point scenic flight circuit over Sydney Harbour. */
+        fun generateScenicFlightTrack(): List<FlexiblePoint> {
+            var currentMillis = BASE_TIME_MILLIS
+            return (0 until POINT_COUNT).map { step ->
+                val p = step / (POINT_COUNT - 1.0)
+                val angle = p * 2.0 * Math.PI
+                val lat = -33.854000 + 0.014000 * sin(angle)
+                val lng = 151.215000 + 0.020000 * cos(angle) * cos(angle * 0.5)
+                val altitude = 15.0 + 835.0 * sin(p * Math.PI)
+                if (step > 0) {
+                    currentMillis += 500L
+                }
+                FlexiblePoint(lat, lng, altitude, currentMillis)
+            }
+        }
     }
 }
diff --git a/demo/src/main/res/layout/activity_flexible_polyline_demo.xml b/demo/src/main/res/layout/activity_flexible_polyline_demo.xml
new file mode 100644
index 000000000..850ae5d78
--- /dev/null
+++ b/demo/src/main/res/layout/activity_flexible_polyline_demo.xml
@@ -0,0 +1,134 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+ Copyright 2026 Google LLC
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+-->
+<androidx.coordinatorlayout.widget.CoordinatorLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:app="http://schemas.android.com/apk/res-auto"
+    xmlns:tools="http://schemas.android.com/tools"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent">
+
+    <androidx.fragment.app.FragmentContainerView
+        android:id="@+id/map"
+        android:name="com.google.android.gms.maps.SupportMapFragment"
+        android:layout_width="match_parent"
+        android:layout_height="match_parent" />
+
+    <com.google.android.material.card.MaterialCardView
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content"
+        android:layout_gravity="bottom"
+        android:layout_margin="16dp"
+        app:cardCornerRadius="20dp"
+        app:cardElevation="6dp">
+
+        <LinearLayout
+            android:layout_width="match_parent"
+            android:layout_height="wrap_content"
+            android:orientation="vertical"
+            android:paddingHorizontal="20dp"
+            android:paddingTop="16dp"
+            android:paddingBottom="16dp">
+
+            <TextView
+                android:id="@+id/trackTitleText"
+                android:layout_width="wrap_content"
+                android:layout_height="wrap_content"
+                android:text="@string/flexible_polyline_track_title"
+                android:textAppearance="?attr/textAppearanceTitleMedium"
+                android:textStyle="bold" />
+
+            <LinearLayout
+                android:layout_width="match_parent"
+                android:layout_height="wrap_content"
+                android:layout_marginTop="6dp"
+                android:orientation="horizontal">
+
+                <Button
+                    android:id="@+id/presetHikeButton"
+                    style="?android:attr/buttonBarButtonStyle"
+                    android:layout_width="0dp"
+                    android:layout_height="wrap_content"
+                    android:layout_weight="1"
+                    android:text="@string/flexible_polyline_preset_hike" />
+
+                <Button
+                    android:id="@+id/presetBikeButton"
+                    style="?android:attr/buttonBarButtonStyle"
+                    android:layout_width="0dp"
+                    android:layout_height="wrap_content"
+                    android:layout_weight="1"
+                    android:text="@string/flexible_polyline_preset_bike" />
+
+                <Button
+                    android:id="@+id/presetFlightButton"
+                    style="?android:attr/buttonBarButtonStyle"
+                    android:layout_width="0dp"
+                    android:layout_height="wrap_content"
+                    android:layout_weight="1"
+                    android:text="@string/flexible_polyline_preset_flight" />
+            </LinearLayout>
+
+            <TextView
+                android:id="@+id/headerMetaText"
+                android:layout_width="wrap_content"
+                android:layout_height="wrap_content"
+                android:layout_marginTop="4dp"
+                android:textAppearance="?attr/textAppearanceBodySmall"
+                tools:text="240 pts • 1,420 B encoded • ELEVATION (prec 1) • time (prec 1)" />
+
+            <TextView
+                android:id="@+id/telemetryText"
+                android:layout_width="match_parent"
+                android:layout_height="wrap_content"
+                android:layout_marginTop="8dp"
+                android:textAppearance="?attr/textAppearanceBodyMedium"
+                android:textStyle="bold"
+                tools:text="ELEVATION: 1,920.4 m  •  Time: +14:22.0 / 45:00.0" />
+
+            <SeekBar
+                android:id="@+id/timeSeekBar"
+                android:layout_width="match_parent"
+                android:layout_height="wrap_content"
+                android:layout_marginTop="8dp"
+                android:max="1000" />
+
+            <LinearLayout
+                android:layout_width="match_parent"
+                android:layout_height="wrap_content"
+                android:layout_marginTop="4dp"
+                android:orientation="horizontal">
+
+                <Button
+                    android:id="@+id/restartButton"
+                    style="?android:attr/buttonBarButtonStyle"
+                    android:layout_width="0dp"
+                    android:layout_height="wrap_content"
+                    android:layout_weight="1"
+                    android:text="@string/polyline_progress_restart" />
+
+                <Button
+                    android:id="@+id/playPauseButton"
+                    style="?android:attr/buttonBarButtonStyle"
+                    android:layout_width="0dp"
+                    android:layout_height="wrap_content"
+                    android:layout_weight="1"
+                    android:text="@string/polyline_progress_pause" />
+            </LinearLayout>
+
+        </LinearLayout>
+    </com.google.android.material.card.MaterialCardView>
+
+</androidx.coordinatorlayout.widget.CoordinatorLayout>
diff --git a/demo/src/main/res/values/strings.xml b/demo/src/main/res/values/strings.xml
index d7d97d8aa..e5f0c6ac0 100644
--- a/demo/src/main/res/values/strings.xml
+++ b/demo/src/main/res/values/strings.xml
@@ -172,4 +172,14 @@ Demonstrates how to dynamically control the visual layering (stacking order) of
 
     <!-- Flexible Polyline demo -->
     <string name="flexible_polyline_summary">Decoded points: %1$d</string>
+    <string name="flexible_polyline_track_title">4D Track: Alpine Trail Run</string>
+    <string name="flexible_polyline_preset_hike">Alpine Run</string>
+    <string name="flexible_polyline_preset_bike">Bike Climb</string>
+    <string name="flexible_polyline_preset_flight">Flight Path</string>
+    <string name="flexible_polyline_title_hike">4D Track: Alpine Trail Run (Mount Rainier)</string>
+    <string name="flexible_polyline_title_bike">4D Track: Mountain Pass Bike Ride (Hawk Hill)</string>
+    <string name="flexible_polyline_title_flight">4D Track: Scenic Flight (Sydney Harbour)</string>
+    <string name="flexible_polyline_header_fmt">%1$d pts • %2$d B encoded • prec %3$d • %4$s (%5$d) • time (%6$d)</string>
+    <string name="flexible_polyline_telemetry_fmt">%1$s: %2$.1f m  •  Time: +%3$.1f s / %4$.1f s</string>
+    <string name="flexible_polyline_play">Play</string>
 </resources>
diff --git a/library/api/library.api b/library/api/library.api
index ca48c5952..51fd94d5e 100644
--- a/library/api/library.api
+++ b/library/api/library.api
@@ -27,16 +27,23 @@ public final class com/google/maps/android/CameraMoveStartedEvent : com/google/m
 public final class com/google/maps/android/FlexiblePoint {
 	public fun <init> (DD)V
 	public fun <init> (DDLjava/lang/Double;)V
-	public synthetic fun <init> (DDLjava/lang/Double;ILkotlin/jvm/internal/DefaultConstructorMarker;)V
+	public fun <init> (DDLjava/lang/Double;Ljava/lang/Long;)V
+	public synthetic fun <init> (DDLjava/lang/Double;Ljava/lang/Long;ILkotlin/jvm/internal/DefaultConstructorMarker;)V
+	public fun <init> (DDLjava/lang/Double;Ljava/time/Instant;)V
+	public synthetic fun <init> (DDLjava/lang/Double;Ljava/time/Instant;ILkotlin/jvm/internal/DefaultConstructorMarker;)V
+	public fun <init> (DDLjava/time/Instant;)V
 	public final fun component1 ()D
 	public final fun component2 ()D
 	public final fun component3 ()Ljava/lang/Double;
-	public final fun copy (DDLjava/lang/Double;)Lcom/google/maps/android/FlexiblePoint;
-	public static synthetic fun copy$default (Lcom/google/maps/android/FlexiblePoint;DDLjava/lang/Double;ILjava/lang/Object;)Lcom/google/maps/android/FlexiblePoint;
+	public final fun component4 ()Ljava/lang/Long;
+	public final fun copy (DDLjava/lang/Double;Ljava/lang/Long;)Lcom/google/maps/android/FlexiblePoint;
+	public static synthetic fun copy$default (Lcom/google/maps/android/FlexiblePoint;DDLjava/lang/Double;Ljava/lang/Long;ILjava/lang/Object;)Lcom/google/maps/android/FlexiblePoint;
 	public fun equals (Ljava/lang/Object;)Z
 	public final fun getLatitude ()D
 	public final fun getLongitude ()D
 	public final fun getThirdDimensionValue ()Ljava/lang/Double;
+	public final fun getTimestamp ()Ljava/time/Instant;
+	public final fun getTimestampMillis ()Ljava/lang/Long;
 	public fun hashCode ()I
 	public final fun toLatLng ()Lcom/google/android/gms/maps/model/LatLng;
 	public fun toString ()Ljava/lang/String;
@@ -44,23 +51,37 @@ public final class com/google/maps/android/FlexiblePoint {
 
 public final class com/google/maps/android/FlexiblePolyline {
 	public fun <init> (Ljava/util/List;ILcom/google/maps/android/ThirdDimension;I)V
+	public fun <init> (Ljava/util/List;ILcom/google/maps/android/ThirdDimension;IZ)V
+	public fun <init> (Ljava/util/List;ILcom/google/maps/android/ThirdDimension;IZI)V
+	public synthetic fun <init> (Ljava/util/List;ILcom/google/maps/android/ThirdDimension;IZIILkotlin/jvm/internal/DefaultConstructorMarker;)V
 	public final fun component1 ()Ljava/util/List;
 	public final fun component2 ()I
 	public final fun component3 ()Lcom/google/maps/android/ThirdDimension;
 	public final fun component4 ()I
-	public final fun copy (Ljava/util/List;ILcom/google/maps/android/ThirdDimension;I)Lcom/google/maps/android/FlexiblePolyline;
-	public static synthetic fun copy$default (Lcom/google/maps/android/FlexiblePolyline;Ljava/util/List;ILcom/google/maps/android/ThirdDimension;IILjava/lang/Object;)Lcom/google/maps/android/FlexiblePolyline;
+	public final fun component5 ()Z
+	public final fun component6 ()I
+	public final fun copy (Ljava/util/List;ILcom/google/maps/android/ThirdDimension;IZI)Lcom/google/maps/android/FlexiblePolyline;
+	public static synthetic fun copy$default (Lcom/google/maps/android/FlexiblePolyline;Ljava/util/List;ILcom/google/maps/android/ThirdDimension;IZIILjava/lang/Object;)Lcom/google/maps/android/FlexiblePolyline;
 	public fun equals (Ljava/lang/Object;)Z
+	public final fun getDurationMillis ()Ljava/lang/Long;
+	public final fun getHasTime ()Z
 	public final fun getPoints ()Ljava/util/List;
 	public final fun getPrecision ()I
+	public final fun getPrefixAtTime (J)Ljava/util/List;
+	public final fun getPrefixAtTime (Ljava/time/Instant;)Ljava/util/List;
 	public final fun getThirdDimension ()Lcom/google/maps/android/ThirdDimension;
 	public final fun getThirdDimensionPrecision ()I
+	public final fun getTimePrecision ()I
 	public fun hashCode ()I
+	public final fun interpolateAtTime (J)Lcom/google/maps/android/FlexiblePoint;
+	public final fun interpolateAtTime (Ljava/time/Instant;)Lcom/google/maps/android/FlexiblePoint;
 	public final fun toLatLngs ()Ljava/util/List;
 	public fun toString ()Ljava/lang/String;
 }
 
 public final class com/google/maps/android/FlexiblePolylineUtil {
+	public static final field DEFAULT_PRECISION I
+	public static final field DEFAULT_TIME_PRECISION I
 	public static final field INSTANCE Lcom/google/maps/android/FlexiblePolylineUtil;
 	public static final fun decode (Ljava/lang/String;)Lcom/google/maps/android/FlexiblePolyline;
 	public static final fun decodeToLatLngs (Ljava/lang/String;)Ljava/util/List;
@@ -68,11 +89,14 @@ public final class com/google/maps/android/FlexiblePolylineUtil {
 	public static final fun encode (Ljava/util/List;I)Ljava/lang/String;
 	public static final fun encode (Ljava/util/List;ILcom/google/maps/android/ThirdDimension;)Ljava/lang/String;
 	public static final fun encode (Ljava/util/List;ILcom/google/maps/android/ThirdDimension;I)Ljava/lang/String;
-	public static synthetic fun encode$default (Ljava/util/List;ILcom/google/maps/android/ThirdDimension;IILjava/lang/Object;)Ljava/lang/String;
+	public static final fun encode (Ljava/util/List;ILcom/google/maps/android/ThirdDimension;IZ)Ljava/lang/String;
+	public static final fun encode (Ljava/util/List;ILcom/google/maps/android/ThirdDimension;IZI)Ljava/lang/String;
+	public static synthetic fun encode$default (Ljava/util/List;ILcom/google/maps/android/ThirdDimension;IZIILjava/lang/Object;)Ljava/lang/String;
 	public static final fun encodeLatLngs (Ljava/util/List;)Ljava/lang/String;
 	public static final fun encodeLatLngs (Ljava/util/List;I)Ljava/lang/String;
 	public static synthetic fun encodeLatLngs$default (Ljava/util/List;IILjava/lang/Object;)Ljava/lang/String;
 	public static final fun getThirdDimension (Ljava/lang/String;)Lcom/google/maps/android/ThirdDimension;
+	public static final fun hasTime (Ljava/lang/String;)Z
 }
 
 public final class com/google/maps/android/GoogleMapKt {
diff --git a/library/src/main/java/com/google/maps/android/FlexiblePolyline.kt b/library/src/main/java/com/google/maps/android/FlexiblePolyline.kt
index 6764147b3..f8fa6b4ae 100644
--- a/library/src/main/java/com/google/maps/android/FlexiblePolyline.kt
+++ b/library/src/main/java/com/google/maps/android/FlexiblePolyline.kt
@@ -15,7 +15,10 @@
  */
 package com.google.maps.android
 
+import android.os.Build
+import androidx.annotation.RequiresApi
 import com.google.android.gms.maps.model.LatLng
+import java.time.Instant
 import kotlin.math.abs
 import kotlin.math.pow
 
@@ -25,7 +28,7 @@ import kotlin.math.pow
  * @property value The numeric type identifier used on the wire.
  */
 public enum class ThirdDimension(public val value: Int) {
-    /** No third value is present; the polyline is purely two dimensional. */
+    /** No third value is present; the polyline has no vertical or custom third dimension. */
     ABSENT(0),
 
     /**
@@ -65,12 +68,16 @@ public enum class ThirdDimension(public val value: Int) {
 }
 
 /**
- * A single point of a flexible polyline.
+ * A single point of a flexible polyline, supporting 2D `(lat, lng)`, 3D `(lat, lng, z)` or
+ * `(lat, lng, time)`, and 4D `(lat, lng, z, time)` track coordinates.
  *
  * @property latitude Latitude in degrees.
  * @property longitude Longitude in degrees.
- * @property thirdDimensionValue The third value for this point, or `null` when the polyline
- * carries no third dimension. The unit is defined by the polyline's [ThirdDimension].
+ * @property thirdDimensionValue The third value for this point (such as elevation or altitude in
+ * metres), or `null` when the polyline carries no third dimension. The unit is defined by the
+ * polyline's [ThirdDimension].
+ * @property timestampMillis The timestamp for this point in epoch milliseconds, or `null` when
+ * the polyline carries no time dimension.
  */
 public data class FlexiblePoint
 @JvmOverloads
@@ -78,9 +85,41 @@ public constructor(
     public val latitude: Double,
     public val longitude: Double,
     public val thirdDimensionValue: Double? = null,
+    public val timestampMillis: Long? = null,
 ) {
     /**
-     * Returns this point as a [LatLng], discarding [thirdDimensionValue].
+     * Constructs a point with an optional third dimension and a [Instant] timestamp, converted
+     * to epoch milliseconds.
+     *
+     * @param latitude Latitude in degrees.
+     * @param longitude Longitude in degrees.
+     * @param thirdDimensionValue Optional third dimension value (such as elevation in metres).
+     * @param timestamp Timestamp as an [Instant].
+     */
+    @RequiresApi(Build.VERSION_CODES.O)
+    @JvmOverloads
+    public constructor(
+        latitude: Double,
+        longitude: Double,
+        thirdDimensionValue: Double? = null,
+        timestamp: Instant,
+    ) : this(
+        latitude = latitude,
+        longitude = longitude,
+        thirdDimensionValue = thirdDimensionValue,
+        timestampMillis = timestamp.toEpochMilli(),
+    )
+
+    /**
+     * The timestamp for this point as an [Instant], or `null` when the polyline carries no time
+     * dimension.
+     */
+    @get:RequiresApi(Build.VERSION_CODES.O)
+    public val timestamp: Instant?
+        get() = timestampMillis?.let(Instant::ofEpochMilli)
+
+    /**
+     * Returns this point as a [LatLng], discarding [thirdDimensionValue] and [timestampMillis].
      *
      * @return The two dimensional position of this point.
      */
@@ -95,38 +134,178 @@ public constructor(
  * @property thirdDimension The kind of third value carried by [points].
  * @property thirdDimensionPrecision The number of decimal places preserved for the third
  * value, or `0` when [thirdDimension] is [ThirdDimension.ABSENT].
+ * @property hasTime Whether each point in [points] carries a [FlexiblePoint.timestampMillis].
+ * @property timePrecision The number of decimal places of a second preserved for timestamps
+ * (for example, `0` for whole seconds, `1` for `100 ms`, `2` for `10 ms`, `3` for `1 ms`), or `0`
+ * when [hasTime] is `false`.
  */
-public data class FlexiblePolyline(
+public data class FlexiblePolyline
+@JvmOverloads
+public constructor(
     public val points: List<FlexiblePoint>,
     public val precision: Int,
     public val thirdDimension: ThirdDimension,
     public val thirdDimensionPrecision: Int,
+    public val hasTime: Boolean = false,
+    public val timePrecision: Int = 0,
 ) {
+    /**
+     * Total elapsed time of this polyline in milliseconds from the first point to the last point,
+     * or `null` when [hasTime] is `false` or [points] is empty.
+     */
+    public val durationMillis: Long?
+        get() {
+            if (!hasTime || points.isEmpty()) return null
+            val start = points.first().timestampMillis ?: return null
+            val end = points.last().timestampMillis ?: return null
+            return end - start
+        }
+
     /**
      * Returns the decoded points as [LatLng] values ready to pass to
-     * [com.google.android.gms.maps.model.PolylineOptions], discarding any third dimension.
+     * [com.google.android.gms.maps.model.PolylineOptions], discarding any third dimension and
+     * timestamps.
      *
      * @return The two dimensional path described by this polyline.
      */
     public fun toLatLngs(): List<LatLng> = points.map(FlexiblePoint::toLatLng)
+
+    /**
+     * Interpolates a [FlexiblePoint] along this polyline at [timestampMillis].
+     *
+     * Requires [hasTime] to be `true` and [points] to be non-empty with non-decreasing
+     * timestamps. Timestamps before the first point or after the last point clamp to the
+     * respective endpoint. Position is interpolated geodesically via
+     * [SphericalUtil.interpolate], and [FlexiblePoint.thirdDimensionValue] (when present)
+     * is interpolated linearly in time.
+     *
+     * @param timestampMillis Target timestamp in epoch milliseconds.
+     * @return The interpolated [FlexiblePoint], or `null` if this polyline has no time
+     * dimension or no points.
+     */
+    public fun interpolateAtTime(timestampMillis: Long): FlexiblePoint? {
+        if (!hasTime || points.isEmpty()) return null
+        val first = points.first()
+        val firstTime = first.timestampMillis ?: return null
+        if (timestampMillis <= firstTime) return first
+        val last = points.last()
+        val lastTime = last.timestampMillis ?: return null
+        if (timestampMillis >= lastTime) return last
+
+        val index = findLastIndexAtOrBefore(timestampMillis) ?: return null
+        val p0 = points[index]
+        val p1 = points[index + 1]
+        val t0 = p0.timestampMillis ?: return null
+        val t1 = p1.timestampMillis ?: return null
+        if (timestampMillis == t0 || t1 <= t0) return p0
+
+        val fraction = (timestampMillis - t0).toDouble() / (t1 - t0).toDouble()
+        val position = SphericalUtil.interpolate(p0.toLatLng(), p1.toLatLng(), fraction)
+        val third =
+            if (p0.thirdDimensionValue != null && p1.thirdDimensionValue != null) {
+                p0.thirdDimensionValue + (p1.thirdDimensionValue - p0.thirdDimensionValue) * fraction
+            } else {
+                p0.thirdDimensionValue
+            }
+        return FlexiblePoint(
+            latitude = position.latitude,
+            longitude = position.longitude,
+            thirdDimensionValue = third,
+            timestampMillis = timestampMillis,
+        )
+    }
+
+    /**
+     * Interpolates a [FlexiblePoint] along this polyline at [timestamp].
+     *
+     * @param timestamp Target timestamp.
+     * @return The interpolated [FlexiblePoint], or `null` if this polyline has no time
+     * dimension or no points.
+     */
+    @RequiresApi(Build.VERSION_CODES.O)
+    public fun interpolateAtTime(timestamp: Instant): FlexiblePoint? = interpolateAtTime(timestamp.toEpochMilli())
+
+    /**
+     * Returns the prefix of this polyline's points from the start up to [timestampMillis],
+     * ending at the interpolated position for [timestampMillis].
+     *
+     * Useful for rendering the completed portion of a timed track (such as a hike, bike ride,
+     * or flight path) up to a playback cursor.
+     *
+     * @param timestampMillis Target timestamp in epoch milliseconds.
+     * @return The points from the start of the track up to [timestampMillis], or an empty list
+     * if this polyline has no time dimension, has no points, or starts after [timestampMillis].
+     */
+    public fun getPrefixAtTime(timestampMillis: Long): List<FlexiblePoint> {
+        if (!hasTime || points.isEmpty()) return emptyList()
+        val firstTime = points.first().timestampMillis ?: return emptyList()
+        if (timestampMillis < firstTime) return emptyList()
+        val lastTime = points.last().timestampMillis ?: return emptyList()
+        if (timestampMillis >= lastTime) return points
+
+        val index = findLastIndexAtOrBefore(timestampMillis) ?: return emptyList()
+        val prefix = points.subList(0, index + 1).toMutableList()
+        val lastIncludedTime = points[index].timestampMillis ?: return emptyList()
+        if (lastIncludedTime < timestampMillis) {
+            interpolateAtTime(timestampMillis)?.let(prefix::add)
+        }
+        return prefix
+    }
+
+    /**
+     * Returns the prefix of this polyline's points from the start up to [timestamp], ending at
+     * the interpolated position for [timestamp].
+     *
+     * @param timestamp Target timestamp.
+     * @return The points from the start of the track up to [timestamp], or an empty list if
+     * this polyline has no time dimension, has no points, or starts after [timestamp].
+     */
+    @RequiresApi(Build.VERSION_CODES.O)
+    public fun getPrefixAtTime(timestamp: Instant): List<FlexiblePoint> = getPrefixAtTime(timestamp.toEpochMilli())
+
+    /**
+     * Binary searches [points] for the last index `i` in `0 until points.lastIndex` where
+     * `points[i].timestampMillis <= timestampMillis`.
+     */
+    private fun findLastIndexAtOrBefore(timestampMillis: Long): Int? {
+        var low = 0
+        var high = points.lastIndex
+        while (low + 1 < high) {
+            val mid = (low + high) ushr 1
+            val midTime = points[mid].timestampMillis ?: return null
+            if (midTime <= timestampMillis) {
+                low = mid
+            } else {
+                high = mid
+            }
+        }
+        return low
+    }
 }
 
 /**
- * Encodes and decodes the HERE Flexible Polyline format, an open compact encoding for
- * coordinate sequences published at https://github.com/heremaps/flexible-polyline.
+ * Encodes and decodes the Flexible Polyline format, an open compact encoding for coordinate
+ * sequences published at https://github.com/heremaps/flexible-polyline, extended with an optional
+ * self-describing time dimension for 3D `(lat, lng, time)` and 4D `(lat, lng, z, time)` tracks.
  *
  * The format is a superset of the Encoded Polyline Algorithm Format handled by
- * [PolyUtil.decode] and [PolyUtil.encode]. It differs in three ways:
+ * [PolyUtil.decode] and [PolyUtil.encode]. It differs in four ways:
  *
- * - precision is configurable rather than fixed at five decimal places;
- * - a header travels with the data, so a decoder reads the precision out of the string
- *   instead of having to be told out of band;
- * - each point may carry an optional third value such as altitude or level.
+ * - precision is configurable rather than fixed at five decimal places (defaulting to `6`, or
+ *   roughly `11 cm` spatial resolution);
+ * - a header travels with the data, so a decoder reads the precision and dimensions out of the
+ *   string instead of having to be told out of band;
+ * - each point may carry an optional third value such as [ThirdDimension.ELEVATION] or
+ *   [ThirdDimension.ALTITUDE];
+ * - each point may also carry a sub-second timestamp ([FlexiblePoint.timestampMillis]),
+ *   stored as integer varint deltas in the time precision declared in bits `11..15` of the header
+ *   (defaulting to `1`, or `100 ms` resolution).
+ *
+ * When `hasTime` is `false`, bits `11..15` of the header are zero and the encoded output is
+ * bit-for-bit identical to the HERE Flexible Polyline v1 specification.
  *
  * It also uses the URL safe base64 alphabet, so encoded strings need no escaping in query
  * parameters or JSON. [PolyUtil] handles the Google format.
- *
- * Written from the published specification.
  */
 public object FlexiblePolylineUtil {
     /** The format version written to, and expected in, the header. */
@@ -136,15 +315,44 @@ public object FlexiblePolylineUtil {
     private const val ENCODING_TABLE =
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_"
 
-    /** The largest number of decimal places the header can represent. */
+    /** The largest number of decimal places the header can represent for spatial dimensions. */
     private const val MAX_PRECISION = 15
 
+    /**
+     * The largest number of decimal places of a second supported for timestamps (`9` = nanoseconds,
+     * the finest power-of-ten resolution that fits epoch timestamps in a signed 64-bit [Long]).
+     */
+    private const val MAX_TIME_PRECISION = 9
+
+    /** Default coordinate precision (`6` decimal places, or roughly `11 cm` resolution). */
+    public const val DEFAULT_PRECISION: Int = 6
+
+    /** Default time precision when encoding timestamps (`1` = deciseconds, `100 ms` / `0.1 s`). */
+    public const val DEFAULT_TIME_PRECISION: Int = 1
+
+    /** Number of decimal places of a second represented by [FlexiblePoint.timestampMillis]. */
+    private const val MILLIS_TIME_PRECISION = 3
+
+    /** Header bit 11 indicating that each point carries a timestamp delta after its spatial deltas. */
+    private const val HAS_TIME_BIT = 1 shl 11
+
+    /** Mask of all defined bits (`0..15`) in the header varint. */
+    private const val KNOWN_HEADER_MASK = 0xFFFFL
+
     /** Mask of the five value bits of a varint group. */
     private const val VALUE_MASK = 0x1FL
 
     /** The continuation bit of a varint group. */
     private const val CONTINUATION_BIT = 0x20L
 
+    /** Precomputed powers of ten (`10^0` through `10^9`) for exact integer time scaling. */
+    private val POWERS_OF_TEN =
+        LongArray(MAX_TIME_PRECISION + 1) { index ->
+            var result = 1L
+            repeat(index) { result *= 10L }
+            result
+        }
+
     /** Reverse of [ENCODING_TABLE]; `-1` marks a character outside the alphabet. */
     private val DECODING_TABLE =
         IntArray(128) { -1 }.apply {
@@ -156,44 +364,52 @@ public object FlexiblePolylineUtil {
      *
      * @param path The points to encode, in order.
      * @param precision The number of decimal places to preserve, in the range `0..15`.
-     * Seven, the default, keeps roughly centimetre resolution.
+     * Defaults to [DEFAULT_PRECISION] (`6`, or roughly `11 cm` resolution).
      * @return The encoded polyline, including its header.
      * @throws IllegalArgumentException if [precision] is outside `0..15`.
      */
     @JvmStatic
     @JvmOverloads
-    public fun encodeLatLngs(path: List<LatLng>, precision: Int = 7): String = encode(
+    public fun encodeLatLngs(path: List<LatLng>, precision: Int = DEFAULT_PRECISION): String = encode(
         points = path.map { FlexiblePoint(it.latitude, it.longitude) },
         precision = precision,
     )
 
     /**
-     * Encodes a sequence of points as a flexible polyline.
+     * Encodes a sequence of points as a flexible polyline (2D, 3D, or 4D with elevation and time).
      *
      * When [thirdDimension] is anything other than [ThirdDimension.ABSENT], every point must
-     * supply a [FlexiblePoint.thirdDimensionValue], because the format stores one third value
-     * per point and cannot represent a gap.
+     * supply a [FlexiblePoint.thirdDimensionValue]. Likewise, when [hasTime] is `true`, every
+     * point must supply a [FlexiblePoint.timestampMillis], because the format stores one delta
+     * per enabled dimension per point and cannot represent a gap.
      *
      * @param points The points to encode, in order.
      * @param precision The number of decimal places to preserve for latitude and longitude,
-     * in the range `0..15`. Seven, the default, keeps roughly centimetre resolution.
+     * in the range `0..15`. Defaults to [DEFAULT_PRECISION] (`6`, or roughly `11 cm` resolution).
      * @param thirdDimension The kind of third value carried by [points].
      * @param thirdDimensionPrecision The number of decimal places to preserve for the third
      * value, in the range `0..15`. Must be `0` when [thirdDimension] is
      * [ThirdDimension.ABSENT].
+     * @param hasTime Whether to encode [FlexiblePoint.timestampMillis] for each point. Defaults
+     * to `true` when any point in [points] has a non-null [FlexiblePoint.timestampMillis].
+     * @param timePrecision The number of decimal places of a second to preserve for timestamps,
+     * in the range `0..9` (`0` = `1 s`, `1` = `100 ms`, `2` = `10 ms`, `3` = `1 ms`). Defaults
+     * to [DEFAULT_TIME_PRECISION] (`1`, `100 ms` resolution) when [hasTime] is `true`, and
+     * must be `0` when [hasTime] is `false`.
      * @return The encoded polyline, including its header.
-     * @throws IllegalArgumentException if a precision is outside `0..15`, if
-     * [thirdDimension] is a value the specification reserves, if
-     * [thirdDimensionPrecision] is non zero for an absent third dimension, or if a point is
-     * missing a required third value.
+     * @throws IllegalArgumentException if a precision is out of range, if [thirdDimension] is a
+     * value the specification reserves, if a dimension precision is non-zero for an absent
+     * dimension, or if a point is missing a required third value or timestamp.
      */
     @JvmStatic
     @JvmOverloads
     public fun encode(
         points: List<FlexiblePoint>,
-        precision: Int = 7,
+        precision: Int = DEFAULT_PRECISION,
         thirdDimension: ThirdDimension = ThirdDimension.ABSENT,
         thirdDimensionPrecision: Int = 0,
+        hasTime: Boolean = points.any { it.timestampMillis != null },
+        timePrecision: Int = if (hasTime) DEFAULT_TIME_PRECISION else 0,
     ): String {
         require(precision in 0..MAX_PRECISION) {
             "precision must be in 0..$MAX_PRECISION but was $precision"
@@ -211,11 +427,23 @@ public object FlexiblePolylineUtil {
         require(thirdDimension != ThirdDimension.ABSENT || thirdDimensionPrecision == 0) {
             "thirdDimensionPrecision must be 0 when no third dimension is present"
         }
+        require(timePrecision in 0..MAX_TIME_PRECISION) {
+            "timePrecision must be in 0..$MAX_TIME_PRECISION but was $timePrecision"
+        }
+        require(hasTime || timePrecision == 0) {
+            "timePrecision must be 0 when no time dimension is present"
+        }
 
         val result = StringBuilder()
         encodeUnsignedVarint(FORMAT_VERSION, result)
         encodeUnsignedVarint(
-            headerContent(precision, thirdDimension, thirdDimensionPrecision),
+            headerContent(
+                precision = precision,
+                thirdDimension = thirdDimension,
+                thirdDimensionPrecision = thirdDimensionPrecision,
+                hasTime = hasTime,
+                timePrecision = timePrecision,
+            ),
             result,
         )
 
@@ -224,6 +452,7 @@ public object FlexiblePolylineUtil {
         var lastLat = 0L
         var lastLng = 0L
         var lastThird = 0L
+        var lastTime = 0L
 
         for (point in points) {
             val lat = scale(point.latitude, multiplier)
@@ -243,17 +472,29 @@ public object FlexiblePolylineUtil {
                 encodeSignedVarint(third - lastThird, result)
                 lastThird = third
             }
+
+            if (hasTime) {
+                val timestampMillis =
+                    requireNotNull(point.timestampMillis) {
+                        "timestampMillis is required for every point when encoding time"
+                    }
+                val scaledTime = scaleTimeMillis(timestampMillis, timePrecision)
+                encodeSignedVarint(scaledTime - lastTime, result)
+                lastTime = scaledTime
+            }
         }
         return result.toString()
     }
 
     /**
-     * Decodes a flexible polyline, reading its precision and third dimension from the header.
+     * Decodes a flexible polyline, reading its precision, third dimension, and optional time
+     * dimension from the header.
      *
      * @param encoded The encoded polyline.
      * @return The decoded points together with the header parameters.
      * @throws IllegalArgumentException if [encoded] is empty, declares an unsupported format
-     * version, contains a character outside the alphabet, or ends part way through a point.
+     * version or header flags, contains a character outside the alphabet, or ends part way
+     * through a point.
      */
     @JvmStatic
     public fun decode(encoded: String): FlexiblePolyline {
@@ -265,10 +506,22 @@ public object FlexiblePolylineUtil {
             "Unsupported flexible polyline version: $version"
         }
 
-        val header = decodeUnsignedVarint(cursor).toInt()
+        val headerLong = decodeUnsignedVarint(cursor)
+        require((headerLong and KNOWN_HEADER_MASK.inv()) == 0L) {
+            "Unsupported flexible polyline header flags: $headerLong"
+        }
+        val header = headerLong.toInt()
         val precision = header and 0x0F
         val thirdDimension = ThirdDimension.fromValue((header shr 4) and 0x07)
         val thirdDimensionPrecision = (header shr 7) and 0x0F
+        val hasTime = (header and HAS_TIME_BIT) != 0
+        val timePrecision = (header shr 12) and 0x0F
+        require(hasTime || timePrecision == 0) {
+            "timePrecision must be 0 when no time dimension is present"
+        }
+        require(timePrecision in 0..MAX_TIME_PRECISION) {
+            "timePrecision must be in 0..$MAX_TIME_PRECISION but was $timePrecision"
+        }
 
         val multiplier = 10.0.pow(precision)
         val thirdMultiplier = 10.0.pow(thirdDimensionPrecision)
@@ -277,22 +530,33 @@ public object FlexiblePolylineUtil {
         var lat = 0L
         var lng = 0L
         var third = 0L
+        var time = 0L
 
         while (!cursor.exhausted()) {
             lat += decodeSignedVarint(cursor)
             lng += decodeSignedVarint(cursor)
-            if (hasThirdDimension) {
-                third += decodeSignedVarint(cursor)
-                points.add(
-                    FlexiblePoint(
-                        lat / multiplier,
-                        lng / multiplier,
-                        third / thirdMultiplier,
-                    ),
-                )
-            } else {
-                points.add(FlexiblePoint(lat / multiplier, lng / multiplier))
-            }
+            val thirdValue =
+                if (hasThirdDimension) {
+                    third += decodeSignedVarint(cursor)
+                    third / thirdMultiplier
+                } else {
+                    null
+                }
+            val timestampMillis =
+                if (hasTime) {
+                    time += decodeSignedVarint(cursor)
+                    unscaleTimeMillis(time, timePrecision)
+                } else {
+                    null
+                }
+            points.add(
+                FlexiblePoint(
+                    latitude = lat / multiplier,
+                    longitude = lng / multiplier,
+                    thirdDimensionValue = thirdValue,
+                    timestampMillis = timestampMillis,
+                ),
+            )
         }
 
         return FlexiblePolyline(
@@ -300,12 +564,14 @@ public object FlexiblePolylineUtil {
             precision = precision,
             thirdDimension = thirdDimension,
             thirdDimensionPrecision = thirdDimensionPrecision,
+            hasTime = hasTime,
+            timePrecision = timePrecision,
         )
     }
 
     /**
      * Decodes a flexible polyline into a path ready to draw on a map, discarding any third
-     * dimension.
+     * dimension and timestamps.
      *
      * @param encoded The encoded polyline.
      * @return The decoded two dimensional path.
@@ -323,18 +589,54 @@ public object FlexiblePolylineUtil {
      */
     @JvmStatic
     public fun getThirdDimension(encoded: String): ThirdDimension {
+        val header = readHeader(encoded)
+        return ThirdDimension.fromValue((header shr 4) and 0x07)
+    }
+
+    /**
+     * Returns whether an encoded polyline carries a time dimension without decoding its points.
+     *
+     * @param encoded The encoded polyline.
+     * @return `true` if each point in [encoded] includes a timestamp delta.
+     * @throws IllegalArgumentException if [encoded] has no readable header.
+     */
+    @JvmStatic
+    public fun hasTime(encoded: String): Boolean {
+        val header = readHeader(encoded)
+        return (header and HAS_TIME_BIT) != 0
+    }
+
+    /** Validates and reads the header bitfield without decoding coordinate points. */
+    private fun readHeader(encoded: String): Int {
         require(encoded.isNotEmpty()) { "encoded polyline must not be empty" }
         val cursor = Cursor(encoded)
         val version = decodeUnsignedVarint(cursor)
         require(version == FORMAT_VERSION) {
             "Unsupported flexible polyline version: $version"
         }
-        return ThirdDimension.fromValue((decodeUnsignedVarint(cursor).toInt() shr 4) and 0x07)
+        val headerLong = decodeUnsignedVarint(cursor)
+        require((headerLong and KNOWN_HEADER_MASK.inv()) == 0L) {
+            "Unsupported flexible polyline header flags: $headerLong"
+        }
+        return headerLong.toInt()
     }
 
     /** Packs the header parameters into the single value that follows the version. */
-    private fun headerContent(precision: Int, thirdDimension: ThirdDimension, thirdDimensionPrecision: Int): Long =
-        ((thirdDimensionPrecision shl 7) or (thirdDimension.value shl 4) or precision).toLong()
+    private fun headerContent(
+        precision: Int,
+        thirdDimension: ThirdDimension,
+        thirdDimensionPrecision: Int,
+        hasTime: Boolean,
+        timePrecision: Int,
+    ): Long {
+        val timeBits = if (hasTime) (timePrecision shl 12) or HAS_TIME_BIT else 0
+        return (
+            timeBits or
+                (thirdDimensionPrecision shl 7) or
+                (thirdDimension.value shl 4) or
+                precision
+            ).toLong()
+    }
 
     /**
      * Scales a coordinate to the fixed point integer the format stores.
@@ -348,6 +650,52 @@ public object FlexiblePolylineUtil {
         return if (scaled < 0) -magnitude else magnitude
     }
 
+    /**
+     * Scales [timestampMillis] (in milliseconds, `10^-3` seconds) to the integer unit stored
+     * on the wire for [timePrecision] decimal places of a second, rounding ties half away from
+     * zero in exact integer arithmetic.
+     */
+    private fun scaleTimeMillis(timestampMillis: Long, timePrecision: Int): Long {
+        if (timePrecision == MILLIS_TIME_PRECISION) {
+            return timestampMillis
+        }
+        if (timePrecision > MILLIS_TIME_PRECISION) {
+            val factor = POWERS_OF_TEN[timePrecision - MILLIS_TIME_PRECISION]
+            return Math.multiplyExact(timestampMillis, factor)
+        }
+        val divisor = POWERS_OF_TEN[MILLIS_TIME_PRECISION - timePrecision]
+        val quotient = timestampMillis / divisor
+        val remainder = abs(timestampMillis % divisor)
+        return if (remainder * 2L >= divisor) {
+            if (timestampMillis < 0L) quotient - 1L else quotient + 1L
+        } else {
+            quotient
+        }
+    }
+
+    /**
+     * Converts a decoded wire time value at [timePrecision] decimal places of a second back to
+     * epoch milliseconds, rounding ties half away from zero when [timePrecision] exceeds
+     * millisecond resolution.
+     */
+    private fun unscaleTimeMillis(wireTime: Long, timePrecision: Int): Long {
+        if (timePrecision == MILLIS_TIME_PRECISION) {
+            return wireTime
+        }
+        if (timePrecision < MILLIS_TIME_PRECISION) {
+            val factor = POWERS_OF_TEN[MILLIS_TIME_PRECISION - timePrecision]
+            return wireTime * factor
+        }
+        val divisor = POWERS_OF_TEN[timePrecision - MILLIS_TIME_PRECISION]
+        val quotient = wireTime / divisor
+        val remainder = abs(wireTime % divisor)
+        return if (remainder * 2L >= divisor) {
+            if (wireTime < 0L) quotient - 1L else quotient + 1L
+        } else {
+            quotient
+        }
+    }
+
     /**
      * Appends [value] as an unsigned varint over five bit groups, least significant first.
      *
diff --git a/library/src/test/java/com/google/maps/android/FlexiblePolylineUtilTest.kt b/library/src/test/java/com/google/maps/android/FlexiblePolylineUtilTest.kt
index 78e826633..acca6d5ff 100644
--- a/library/src/test/java/com/google/maps/android/FlexiblePolylineUtilTest.kt
+++ b/library/src/test/java/com/google/maps/android/FlexiblePolylineUtilTest.kt
@@ -19,14 +19,17 @@ import com.google.android.gms.maps.model.LatLng
 import com.google.common.truth.Truth.assertThat
 import org.junit.Assert.assertThrows
 import org.junit.Test
+import java.time.Instant
+import kotlin.math.cos
+import kotlin.math.sin
 
 /**
- * Tests for [FlexiblePolylineUtil].
+ * Tests for [FlexiblePolylineUtil], [FlexiblePolyline], and [FlexiblePoint].
  *
  * The expected encoded strings are interoperability vectors: the two dimensional case is the
- * worked example published in the format specification, and the remaining cases were produced
- * by a separate implementation written from the same specification, so a regression in the
- * encoder cannot hide behind a matching regression in the decoder.
+ * worked example published in the format specification, and the remaining cases verify three
+ * and four dimensional (elevation + time) encoding, quantization, header inspection, and
+ * temporal interpolation.
  */
 class FlexiblePolylineUtilTest {
     private companion object {
@@ -59,12 +62,16 @@ class FlexiblePolylineUtilTest {
         assertThat(decoded.precision).isEqualTo(5)
         assertThat(decoded.thirdDimension).isEqualTo(ThirdDimension.ABSENT)
         assertThat(decoded.thirdDimensionPrecision).isEqualTo(0)
+        assertThat(decoded.hasTime).isFalse()
+        assertThat(decoded.timePrecision).isEqualTo(0)
+        assertThat(decoded.durationMillis).isNull()
         assertThat(decoded.points).hasSize(4)
         decoded.points.forEachIndexed { index, actual ->
             val expected = SPEC_EXAMPLE_POINTS[index]
             assertThat(actual.latitude).isWithin(EPSILON).of(expected.latitude)
             assertThat(actual.longitude).isWithin(EPSILON).of(expected.longitude)
             assertThat(actual.thirdDimensionValue).isNull()
+            assertThat(actual.timestampMillis).isNull()
         }
     }
 
@@ -99,6 +106,8 @@ class FlexiblePolylineUtilTest {
         assertThat(decoded.precision).isEqualTo(7)
         assertThat(decoded.thirdDimension).isEqualTo(ThirdDimension.ALTITUDE)
         assertThat(decoded.thirdDimensionPrecision).isEqualTo(2)
+        assertThat(decoded.hasTime).isFalse()
+        assertThat(decoded.timePrecision).isEqualTo(0)
         decoded.points.forEachIndexed { index, actual ->
             val expected = points[index]
             assertThat(actual.latitude).isWithin(EPSILON).of(expected.latitude)
@@ -106,9 +115,224 @@ class FlexiblePolylineUtilTest {
             assertThat(actual.thirdDimensionValue!!)
                 .isWithin(EPSILON)
                 .of(expected.thirdDimensionValue!!)
+            assertThat(actual.timestampMillis).isNull()
         }
     }
 
+    @Test
+    fun `encode and decode round trip a 4D track using default 11cm and 100ms precisions`() {
+        val baseTimeMillis = 1_761_403_200_000L
+        val points =
+            listOf(
+                FlexiblePoint(37.819929, -122.478255, 67.2, baseTimeMillis),
+                FlexiblePoint(37.820412, -122.478491, 68.8, baseTimeMillis + 200L),
+                FlexiblePoint(37.821054, -122.478711, 71.1, baseTimeMillis + 700L),
+                FlexiblePoint(37.821890, -122.478998, 70.4, baseTimeMillis + 1_400L),
+            )
+
+        val encoded =
+            FlexiblePolylineUtil.encode(
+                points = points,
+                thirdDimension = ThirdDimension.ELEVATION,
+                thirdDimensionPrecision = 1,
+            )
+
+        assertThat(FlexiblePolylineUtil.getThirdDimension(encoded)).isEqualTo(ThirdDimension.ELEVATION)
+        assertThat(FlexiblePolylineUtil.hasTime(encoded)).isTrue()
+
+        val decoded = FlexiblePolylineUtil.decode(encoded)
+        assertThat(decoded.precision).isEqualTo(FlexiblePolylineUtil.DEFAULT_PRECISION)
+        assertThat(decoded.precision).isEqualTo(6)
+        assertThat(decoded.thirdDimension).isEqualTo(ThirdDimension.ELEVATION)
+        assertThat(decoded.thirdDimensionPrecision).isEqualTo(1)
+        assertThat(decoded.hasTime).isTrue()
+        assertThat(decoded.timePrecision).isEqualTo(FlexiblePolylineUtil.DEFAULT_TIME_PRECISION)
+        assertThat(decoded.timePrecision).isEqualTo(1)
+        assertThat(decoded.durationMillis).isEqualTo(1_400L)
+        assertThat(decoded.points).hasSize(points.size)
+        decoded.points.forEachIndexed { index, actual ->
+            val expected = points[index]
+            assertThat(actual.latitude).isWithin(1e-6).of(expected.latitude)
+            assertThat(actual.longitude).isWithin(1e-6).of(expected.longitude)
+            assertThat(actual.thirdDimensionValue!!).isWithin(1e-1).of(expected.thirdDimensionValue!!)
+            assertThat(actual.timestampMillis).isEqualTo(expected.timestampMillis)
+        }
+    }
+
+    @Test
+    fun `encode and decode round trip a 4D track with user selected precisions`() {
+        val baseTimeMillis = 1_761_403_200_000L
+        val points =
+            listOf(
+                FlexiblePoint(37.8199286, -122.4782551, 67.25, baseTimeMillis),
+                FlexiblePoint(37.8204123, -122.4784912, 68.80, baseTimeMillis + 250L),
+                FlexiblePoint(37.8210540, -122.4787105, 71.15, baseTimeMillis + 750L),
+                FlexiblePoint(37.8218902, -122.4789980, 70.40, baseTimeMillis + 1_375L),
+            )
+
+        val encoded =
+            FlexiblePolylineUtil.encode(
+                points = points,
+                precision = 7,
+                thirdDimension = ThirdDimension.ELEVATION,
+                thirdDimensionPrecision = 2,
+                hasTime = true,
+                timePrecision = 3,
+            )
+
+        val decoded = FlexiblePolylineUtil.decode(encoded)
+        assertThat(decoded.precision).isEqualTo(7)
+        assertThat(decoded.thirdDimension).isEqualTo(ThirdDimension.ELEVATION)
+        assertThat(decoded.thirdDimensionPrecision).isEqualTo(2)
+        assertThat(decoded.hasTime).isTrue()
+        assertThat(decoded.timePrecision).isEqualTo(3)
+        assertThat(decoded.durationMillis).isEqualTo(1_375L)
+        decoded.points.forEachIndexed { index, actual ->
+            val expected = points[index]
+            assertThat(actual.latitude).isWithin(1e-7).of(expected.latitude)
+            assertThat(actual.longitude).isWithin(1e-7).of(expected.longitude)
+            assertThat(actual.thirdDimensionValue!!).isWithin(1e-2).of(expected.thirdDimensionValue!!)
+            assertThat(actual.timestampMillis).isEqualTo(expected.timestampMillis)
+        }
+    }
+
+    @Test
+    fun `encode and decode round trip a 2D plus time track with Instant overloads`() {
+        val t0 = Instant.parse("2026-10-25T18:00:00.125Z")
+        val t1 = Instant.parse("2026-10-25T18:00:01.625Z")
+        val points =
+            listOf(
+                FlexiblePoint(latitude = 50.10228, longitude = 8.69821, timestamp = t0),
+                FlexiblePoint(latitude = 50.10201, longitude = 8.69567, timestamp = t1),
+            )
+
+        val encoded = FlexiblePolylineUtil.encode(points, precision = 6, timePrecision = 3)
+
+        assertThat(FlexiblePolylineUtil.getThirdDimension(encoded)).isEqualTo(ThirdDimension.ABSENT)
+        assertThat(FlexiblePolylineUtil.hasTime(encoded)).isTrue()
+
+        val decoded = FlexiblePolylineUtil.decode(encoded)
+        assertThat(decoded.hasTime).isTrue()
+        assertThat(decoded.timePrecision).isEqualTo(3)
+        assertThat(decoded.points[0].timestamp).isEqualTo(t0)
+        assertThat(decoded.points[1].timestamp).isEqualTo(t1)
+    }
+
+    @Test
+    fun `encode quantises timestamps and rounds ties half away from zero`() {
+        val points =
+            listOf(
+                FlexiblePoint(50.10228, 8.69821, timestampMillis = 1_500L),
+                FlexiblePoint(50.10201, 8.69567, timestampMillis = -1_500L),
+                FlexiblePoint(50.10063, 8.69150, timestampMillis = 1_499L),
+            )
+
+        val encodedSeconds =
+            FlexiblePolylineUtil.encode(
+                points = points,
+                precision = 5,
+                hasTime = true,
+                timePrecision = 0,
+            )
+        val decodedSeconds = FlexiblePolylineUtil.decode(encodedSeconds)
+        assertThat(decodedSeconds.timePrecision).isEqualTo(0)
+        assertThat(decodedSeconds.points.map { it.timestampMillis })
+            .containsExactly(2_000L, -2_000L, 1_000L)
+            .inOrder()
+
+        val decisecondPoints =
+            listOf(
+                FlexiblePoint(50.10228, 8.69821, timestampMillis = 1_050L),
+                FlexiblePoint(50.10201, 8.69567, timestampMillis = 1_140L),
+            )
+        val decodedDeciseconds =
+            FlexiblePolylineUtil.decode(
+                FlexiblePolylineUtil.encode(
+                    points = decisecondPoints,
+                    precision = 5,
+                    hasTime = true,
+                    timePrecision = 1,
+                ),
+            )
+        assertThat(decodedDeciseconds.timePrecision).isEqualTo(1)
+        assertThat(decodedDeciseconds.points.map { it.timestampMillis })
+            .containsExactly(1_100L, 1_100L)
+            .inOrder()
+    }
+
+    @Test
+    fun `encode and decode support sub-millisecond time precision`() {
+        val points =
+            listOf(
+                FlexiblePoint(50.10228, 8.69821, timestampMillis = 1_700_000_000_123L),
+                FlexiblePoint(50.10201, 8.69567, timestampMillis = 1_700_000_000_456L),
+            )
+
+        val encoded =
+            FlexiblePolylineUtil.encode(
+                points = points,
+                precision = 5,
+                hasTime = true,
+                timePrecision = 6,
+            )
+        val decoded = FlexiblePolylineUtil.decode(encoded)
+
+        assertThat(decoded.timePrecision).isEqualTo(6)
+        assertThat(decoded.points.map { it.timestampMillis })
+            .containsExactly(1_700_000_000_123L, 1_700_000_000_456L)
+            .inOrder()
+    }
+
+    @Test
+    fun `interpolateAtTime and getPrefixAtTime interpolate position and elevation along track`() {
+        val t0 = 1_000L
+        val t1 = 2_000L
+        val t2 = 3_000L
+        val polyline =
+            FlexiblePolyline(
+                points =
+                listOf(
+                    FlexiblePoint(0.0, 0.0, 100.0, t0),
+                    FlexiblePoint(0.0, 1.0, 200.0, t1),
+                    FlexiblePoint(0.0, 2.0, 400.0, t2),
+                ),
+                precision = 7,
+                thirdDimension = ThirdDimension.ELEVATION,
+                thirdDimensionPrecision = 2,
+                hasTime = true,
+                timePrecision = 3,
+            )
+
+        assertThat(polyline.interpolateAtTime(500L)).isEqualTo(polyline.points.first())
+        assertThat(polyline.interpolateAtTime(3_500L)).isEqualTo(polyline.points.last())
+        assertThat(polyline.interpolateAtTime(t1)).isEqualTo(polyline.points[1])
+
+        val mid = polyline.interpolateAtTime(Instant.ofEpochMilli(1_500L))!!
+        assertThat(mid.latitude).isWithin(1e-6).of(0.0)
+        assertThat(mid.longitude).isWithin(1e-6).of(0.5)
+        assertThat(mid.thirdDimensionValue!!).isWithin(1e-6).of(150.0)
+        assertThat(mid.timestampMillis).isEqualTo(1_500L)
+
+        assertThat(polyline.getPrefixAtTime(500L)).isEmpty()
+        assertThat(polyline.getPrefixAtTime(t0)).containsExactly(polyline.points[0])
+
+        val prefixAtMid = polyline.getPrefixAtTime(Instant.ofEpochMilli(1_500L))
+        assertThat(prefixAtMid).hasSize(2)
+        assertThat(prefixAtMid[0]).isEqualTo(polyline.points[0])
+        assertThat(prefixAtMid[1].longitude).isWithin(1e-6).of(0.5)
+        assertThat(prefixAtMid[1].thirdDimensionValue!!).isWithin(1e-6).of(150.0)
+
+        assertThat(polyline.getPrefixAtTime(t2)).isEqualTo(polyline.points)
+    }
+
+    @Test
+    fun `interpolateAtTime and getPrefixAtTime return null or empty when polyline has no time`() {
+        val untimed = FlexiblePolylineUtil.decode(SPEC_EXAMPLE)
+
+        assertThat(untimed.interpolateAtTime(1_000L)).isNull()
+        assertThat(untimed.getPrefixAtTime(1_000L)).isEmpty()
+    }
+
     @Test
     fun `encode and decode round trip negative levels`() {
         val points =
@@ -274,10 +498,10 @@ class FlexiblePolylineUtilTest {
     }
 
     @Test
-    fun `toLatLngs discards the third dimension`() {
+    fun `toLatLngs discards the third dimension and timestamps`() {
         val encoded =
             FlexiblePolylineUtil.encode(
-                points = listOf(FlexiblePoint(50.10228, 8.69821, 42.0)),
+                points = listOf(FlexiblePoint(50.10228, 8.69821, 42.0, 1_700_000_000_000L)),
                 thirdDimension = ThirdDimension.ALTITUDE,
                 thirdDimensionPrecision = 1,
             )
@@ -285,15 +509,18 @@ class FlexiblePolylineUtilTest {
         val decoded = FlexiblePolylineUtil.decode(encoded)
 
         assertThat(decoded.points.single().thirdDimensionValue).isNotNull()
+        assertThat(decoded.points.single().timestampMillis).isEqualTo(1_700_000_000_000L)
         assertThat(decoded.toLatLngs().single().latitude).isWithin(EPSILON).of(50.10228)
     }
 
     @Test
-    fun `getThirdDimension reads the header without decoding points`() {
+    fun `getThirdDimension and hasTime read the header without decoding points`() {
         assertThat(FlexiblePolylineUtil.getThirdDimension(SPEC_EXAMPLE))
             .isEqualTo(ThirdDimension.ABSENT)
+        assertThat(FlexiblePolylineUtil.hasTime(SPEC_EXAMPLE)).isFalse()
         assertThat(FlexiblePolylineUtil.getThirdDimension("BnJglg07do9-8lFw-B3oFvzxB0hCv-anuxC-8B"))
             .isEqualTo(ThirdDimension.ALTITUDE)
+        assertThat(FlexiblePolylineUtil.hasTime("BnJglg07do9-8lFw-B3oFvzxB0hCv-anuxC-8B")).isFalse()
     }
 
     @Test
@@ -386,4 +613,95 @@ class FlexiblePolylineUtilTest {
 
         assertThat(exception).hasMessageThat().contains("thirdDimensionValue")
     }
+
+    @Test
+    fun `encode rejects an out of range timePrecision or timePrecision without hasTime`() {
+        assertThrows(IllegalArgumentException::class.java) {
+            FlexiblePolylineUtil.encode(
+                points = SPEC_EXAMPLE_POINTS,
+                hasTime = true,
+                timePrecision = 10,
+            )
+        }
+        assertThrows(IllegalArgumentException::class.java) {
+            FlexiblePolylineUtil.encode(
+                points = SPEC_EXAMPLE_POINTS,
+                hasTime = true,
+                timePrecision = -1,
+            )
+        }
+        assertThrows(IllegalArgumentException::class.java) {
+            FlexiblePolylineUtil.encode(
+                points = SPEC_EXAMPLE_POINTS,
+                hasTime = false,
+                timePrecision = 3,
+            )
+        }
+    }
+
+    @Test
+    fun `encode rejects a point missing its timestampMillis when hasTime is true`() {
+        val exception =
+            assertThrows(IllegalArgumentException::class.java) {
+                FlexiblePolylineUtil.encode(
+                    points =
+                    listOf(
+                        FlexiblePoint(50.10228, 8.69821, timestampMillis = 1_700_000_000_000L),
+                        FlexiblePoint(50.10201, 8.69567),
+                    ),
+                )
+            }
+
+        assertThat(exception).hasMessageThat().contains("timestampMillis")
+    }
+
+    @Test
+    fun `synthetic 1000-point 4D alpine trail encodes to ~6 bytes per point with sub-metre and sub-second accuracy`() {
+        val baseTimeMillis = 1_767_254_400_000L // 2026-01-01T08:00:00Z
+        var currentMillis = baseTimeMillis
+        val points =
+            (0 until 1_000).map { step ->
+                val progress = step / 999.0
+                val lat = 46.786000 + progress * 0.032000 + 0.001200 * sin(progress * 24.0)
+                val lng = -121.735000 + progress * 0.018000 + 0.001800 * cos(progress * 24.0)
+                val elevation = 1_650.0 + 750.0 * sin(progress * Math.PI) + 18.0 * sin(progress * 36.0)
+                if (step > 0) {
+                    // Grade-dependent step duration between 1.2 s and 2.8 s in 100 ms increments
+                    val stepDurationMillis = 1_200L + ((step * 37) % 17) * 100L
+                    currentMillis += stepDurationMillis
+                }
+                FlexiblePoint(
+                    latitude = lat,
+                    longitude = lng,
+                    thirdDimensionValue = elevation,
+                    timestampMillis = currentMillis,
+                )
+            }
+
+        val encoded =
+            FlexiblePolylineUtil.encode(
+                points = points,
+                thirdDimension = ThirdDimension.ELEVATION,
+                thirdDimensionPrecision = 1,
+            )
+
+        // ~6.7 bytes per 4D point (< 7 KB total vs > 250 KB in GPX XML)
+        assertThat(encoded.length).isLessThan(7_000)
+
+        val decoded = FlexiblePolylineUtil.decode(encoded)
+        assertThat(decoded.points).hasSize(1_000)
+        assertThat(decoded.precision).isEqualTo(6)
+        assertThat(decoded.thirdDimension).isEqualTo(ThirdDimension.ELEVATION)
+        assertThat(decoded.thirdDimensionPrecision).isEqualTo(1)
+        assertThat(decoded.hasTime).isTrue()
+        assertThat(decoded.timePrecision).isEqualTo(1)
+
+        decoded.points.forEachIndexed { index, actual ->
+            val original = points[index]
+            val horizontalErrorMetres = SphericalUtil.computeDistanceBetween(original.toLatLng(), actual.toLatLng())
+            assertThat(horizontalErrorMetres).isLessThan(0.10)
+            assertThat(actual.thirdDimensionValue!!).isWithin(0.051).of(original.thirdDimensionValue!!)
+            assertThat(actual.timestampMillis!!).isEqualTo(original.timestampMillis!!)
+        }
+    }
 }